feat: initial commit - Multilingual ABSA project setup with 6 phases, 36 requirements

.claude/AGENTS.md

@@ -0,0 +1,221 @@
+<!-- GSD:project-start source:PROJECT.md -->
+
+## Project
+
+**Multilingual ABSA**
+
+Aspect-based sentiment analysis (ABSA) system that extracts aspect terms and classifies their sentiment from multilingual product reviews. Supports English, Hindi, and Hinglish (code-mixed) — fine-tuned on XLM-RoBERTa with an ONNX-exported inference pipeline, served via FastAPI with a React dashboard.
+
+**Core Value:** Accurately extract aspect terms and their sentiment from product reviews across English, Hindi, and Hinglish — enabling brands to understand what customers feel about specific product features in the languages their users actually write in.
+
+### Constraints
+
+- **Model**: XLM-RoBERTa base (primary), IndicBERT for Hindi-focused runs
+- **Export**: ONNX required before any model reaches the API
+- **Metric**: Macro-F1 is the evaluation standard (not accuracy)
+- **Stack**: FastAPI + Celery + Redis + PostgreSQL backend; React + Vite + Recharts frontend
+
+<!-- GSD:project-end -->
+
+<!-- GSD:stack-start source:research/STACK.md -->
+
+## Technology Stack
+
+## Recommended Stack
+
+### Core Technologies
+
+| Technology | Version | Purpose | Why Recommended |
+|------------|---------|---------|-----------------|
+| Python | 3.11+ | Runtime language | ONNX Runtime 1.27+ drops Python 3.10 support; PyTorch 2.12+ requires 3.10+. 3.11 is the safe floor for all dependencies. |
+| HuggingFace Transformers | 5.12.x | Model loading, tokenization, training loop | The de facto standard. Provides `XLMRobertaForTokenClassification` and `AutoTokenizer` out of the box. v5.x is a major rearchitecture — test thoroughly before upgrading from 4.x. |
+| PyTorch | 2.12.x | Deep learning framework | Required by Transformers. v2.12 is latest stable (June 2026). Ships CUDA 13.0 by default. Use `--index-url https://download.pytorch.org/whl/cu126` if on older drivers. |
+| XLM-RoBERTa | base (0.3B params) | Multilingual encoder | Pre-trained on 100 languages including Hindi. Strong cross-lingual zero-shot transfer. No `lang` tensor needed — auto-detects language. `FacebookAI/xlm-roberta-base` scores 16M+ downloads/month. Use `xlm-roberta-large` (0.55B) only if Macro-F1 on Hindi/Hinglish is >3 points below English after tuning base. |
+| HuggingFace PEFT | 0.19.x | Parameter-efficient fine-tuning (LoRA) | LoRA is the standard for efficient encoder fine-tuning. v0.19 adds GraLoRA and QALoRA. For XLM-RoBERTa base (0.3B), full fine-tuning is feasible on consumer GPUs — **do not default to LoRA for this model size**. Use PEFT only if you need to fine-tune xlm-roberta-large on a single 24GB GPU. |
+| Optimum | 1.26.x / latest | ONNX export bridge | Required for ONNX export. `optimum-cli export onnx` handles the conversion with architecture-specific configuration objects. |
+| optimum-onnx | 0.1.x | ONNX export + runtime | **Split from Optimum in late 2025.** Contains the actual ONNX export logic and `ORTModelForXXX` classes. Must install separately. |
+| ONNX Runtime | 1.27.x | Production inference engine | Runs the exported ONNX model in the API. No PyTorch dependency in production. v1.27 (June 2026) requires Python 3.11+, ONNX 1.21. |
+| seqeval | 1.2.2 | Sequence labeling evaluation | The standard for BIO-tagging evaluation (precision, recall, F1 per entity type). Last updated 2020 but stable — no better alternative exists. |
+| scikit-learn | 1.9.x | Metrics (Macro-F1, classification_report) | `sklearn.metrics` for overall metrics. v1.9 (June 2026) adds narwhals and GPU support for some estimators. |
+
+### Model Variants
+
+| Model | Params | Best For | When to Use |
+|-------|--------|----------|-------------|
+| `FacebookAI/xlm-roberta-base` | 0.3B | Primary model for all 3 languages | Default choice. Good cross-lingual transfer. Fine-tunes on 16GB GPU. |
+| `FacebookAI/xlm-roberta-large` | 0.55B | Higher accuracy target | Only if base underperforms on Hindi/Hinglish by >3 Macro-F1 points. Needs 24GB+ GPU or PEFT. |
+| `ai4bharat/IndicBERT-v3-1B` | 1B | Hindi-focused runs | **Game-changer (Jan 2026):** Bidirectional Gemma-3 based encoder trained on 23 Indic languages + English. Trained with curriculum learning to prevent catastrophic forgetting. Likely beats XLM-R on Hindi/Hinglish specifically. |
+| `ai4bharat/IndicBERT-v3-4B` | 4B | Max Hindi accuracy | 4B params — requires PEFT (LoRA). Overkill unless Hindi metrics are the primary concern. |
+| `ai4bharat/indic-bert` | ~100M | (AVOID) | Original ALBERT-based IndicBERT. Too small, outdated architecture. **Do not use.** |
+
+### Supporting Libraries
+
+| Library | Version | Purpose | When to Use |
+|---------|---------|---------|-------------|
+| datasets | 3.x | Data loading, preprocessing, train/test split | Use for loading SemEval 2014, M-ABSA, and custom datasets. Built-in caching and mapping functions. |
+| tokenizers | 0.21.x | Fast tokenization | Backs Transformers' `AutoTokenizer`. Needed only if customizing tokenizer for Hinglish. |
+| dhvani | 0.2.x | Hinglish phonetic normalization | **Primary tool for code-mixed Hinglish preprocessing.** Normalizes Romanized Hindi spelling variants ("bahut"/"bohot"/"boht" → canonical) using IPA as bridge. 1M+ lexicon, <1ms per word. Pure lookup + rules — no GPU needed. +1.2% Macro-F1 observed on Hindi sentiment. |
+| akshar-32k | — | Custom BPE tokenizer for Hinglish | HuggingFace tokenizer trained on 40M tokens of Romanized Hinglish. Use **only if** XLM-RoBERTa's SentencePiece tokenizer fragments Hinglish words badly. Caveat: still struggles with spelling variation — pair with dhvani. |
+| accelerate | 1.x | Training utilities | Required by Transformers `Trainer`. Handles device placement, mixed precision, gradient accumulation. |
+| bitsandbytes | 0.45.x | 4-bit quantization for QLoRA | Only needed if you insist on QLoRA for xlm-roberta-large. **Not recommended** — XLM-R base fine-tunes fine on 16GB without quantization. |
+| wandb | 0.19.x | Experiment logging (alternative to MLflow) | Use **only** if you prefer cloud logging over MLflow's self-hosted tracking. Both can coexist. |
+| pydantic | 2.x | API schema validation | Already in project spec. Required for FastAPI request/response models. |
+| celery | 5.4.x | Async task queue | For long-running inference jobs. Paired with Redis as broker. |
+| redis | 5.x | Celery broker + cache | Required. Use `redis-py` (Python client). |
+| psycopg2-binary | 2.9.x | PostgreSQL driver | Required by project spec. |
+| sqlalchemy | 2.x | ORM for PostgreSQL | Required by project spec. |
+
+### Development & MLOps Tools
+
+| Tool | Version | Purpose | Notes |
+|------|---------|---------|-------|
+| MLflow | 3.14.x | Experiment tracking, model registry, metrics logging | Latest (June 2026). v3.x focus is LLM observability but experiment tracking works identically. Log params, metrics, artifacts per training run. **Pin to `mlflow-skinny==3.14.0` for minimal dependencies** on the training side. Use full MLflow for the tracking server. |
+| DVC | 3.67.x | Data and model version control | DVC tracks dataset versions and model files outside Git. v3.67.1 latest (Mar 2026). Use `dvc init` at project root, `dvc add data/` to track datasets. |
+| Evidently AI | 0.7.x | Model monitoring, data drift detection | v0.7.21 latest (Mar 2026). Use for **data quality monitoring** after deployment — detecting distribution shifts in review text. Not needed during training. |
+| Prometheus + Grafana | — | API metrics, request monitoring | Standard for FastAPI production monitoring. Not research-critical — standard setup. |
+| Docker | 27.x | Containerization | Required for reproducible deployments. |
+
+### Frontend Stack
+
+| Technology | Version | Purpose | Why |
+|------------|---------|---------|-----|
+| React | 19.x | UI framework | Standard choice. v19 stable. |
+| Vite | 6.x | Build tool | Faster than CRA. Standard for new React projects. |
+| Recharts | 2.x | Charting library | Built on D3. Good for confusion matrices, F1 trends, sentiment distributions. |
+| TailwindCSS | 4.x | Utility CSS | v4 uses CSS-first config (no tailwind.config.js needed). Faster build times. |
+
+## Installation
+
+# Core ML stack
+
+# Hinglish preprocessing
+
+# MLOps
+
+# API
+
+# Dev
+
+# Frontend
+
+## Alternatives Considered
+
+| Recommended | Alternative | When to Use Alternative |
+|-------------|-------------|-------------------------|
+| XLM-RoBERTa base | mBERT (BERT-base-multilingual-cased) | mBERT is smaller (0.18B vs 0.3B). Use **only** if inference latency is critical and you can accept 2-5 point F1 drop. XLM-RoBERTa is stronger on code-mixed and low-resource languages. |
+| XLM-RoBERTa base | IndicBERT-v3-1B | Use IndicBERT-v3-1B when you pivot to Hindi/Hinglish-only evaluation. Its curriculum training (English → Indic) prevents catastrophic forgetting better than XLM-R's generic multilingual pretraining. |
+| LoRA for large models | QLoRA (4-bit) | QLoRA only needed for xlm-roberta-large on a 16GB GPU. For base models, full fine-tuning is simpler and more accurate. |
+| optimum-onnx export | torch.onnx.export (manual) | Manual `torch.onnx.export` gives finer control over dynamic axes and opset version. Use **only** if optimum's config doesn't support XLM-RoBERTa's architecture (unlikely — it's well-supported). |
+| seqeval | evaluate (HuggingFace) | HuggingFace's `evaluate` library wraps seqeval. Use `evaluate` if you want a unified metrics API. Either works — seqeval is the underlying engine. |
+| MLflow | wandb | MLflow is self-hosted (data stays private), wandb is SaaS with a free tier. Use wandb if you prefer cloud dashboards. This project spec already requires MLflow. |
+| DVC | Git LFS | DVC is more flexible (any cloud storage as remote) and integrates with ML pipelines. Git LFS is simpler but doesn't handle dataset versioning workflows as well. |
+
+## What NOT to Use
+
+| Avoid | Why | Use Instead |
+|-------|-----|-------------|
+| Original `ai4bharat/indic-bert` | ALBERT-based, ~100M params, outdated (2020). Significantly weaker than XLM-R or IndicBERT-v3. | `ai4bharat/IndicBERT-v3-1B` or `FacebookAI/xlm-roberta-base` |
+| `ai4bharat/IndicBERTv2-*` | ALBERT-based, still inferior to XLM-R. v2 (2023) is better than v1 but v3 (Jan 2026) is a completely new architecture (Gemma-3). | `ai4bharat/IndicBERT-v3-1B` |
+| Older `optimum` ONNX path (optimum<1.15) | ONNX export was split to `optimum-onnx` in late 2025. Early 2025 versions may have path resolution bugs. | `optimum-onnx>=0.1.0` |
+| `bert-base-multilingual-cased` (mBERT) | Weaker cross-lingual transfer than XLM-RoBERTa. Trained on Wikipedia only (vs CommonCrawl for XLM-R). | `FacebookAI/xlm-roberta-base` |
+| PyABSA as a dependency | PyABSA is a full framework that abstracts away the training loop. This project is building from scratch for learning + custom ONNX export. Using PyABSA would hide the architecture decisions. | Build custom pipeline: Transformers `Trainer` + custom model class |
+| IndicTrans2 for Hinglish → Hindi | Translating Hinglish to Hindi removes the code-mixed signal. Romanized Hindi + English mixed text is the actual distribution. Translating loses information. | `dhvani` normalization (keeps English, normalizes Romanized Hindi spellings) |
+| SentencePiece from scratch for Hinglish | XLM-RoBERTa's tokenizer already handles multilingual text adequately. Training a custom SentencePiece is expensive and rarely improves F1 by >1 point. | `dhvani` normalization + XLM-RoBERTa tokenizer. Only reach for `akshar-32k` if word fragmentation is severe. |
+
+## ABSA Architecture Choices
+
+### Stage 1: Aspect Term Extraction
+
+- **Approach:** Token classification with BIO tagging (B-Aspect, I-Aspect, O)
+- **Model head:** `XLMRobertaForTokenClassification` with 3 output labels
+- **Context:** Standard approach in all cross-lingual ABSA literature (2025 survey: Smíd et al.)
+
+### Stage 2: Aspect Sentiment Classification
+
+- **Approach:** Extract each aspect span's pooled embedding → classify into {Positive, Negative, Neutral, Conflict}
+- **Model head:** Linear classifier on top of pooled aspect span representations
+- **Alternative (merged):** Single token classification head with merged labels (e.g., `B-ASP-Positive`, `I-ASP-Negative`, `O`) as demonstrated by `yangheng/deberta-v3-base-end2end-absa`
+- **Recommendation for this project:** Use **separate heads on a shared encoder** for Stage 1 and Stage 2, compiled into a single ONNX graph. This allows different optimization for each task while sharing the multilingual encoder. The merged-label approach is simpler but couples the two tasks rigidly.
+
+### ONNX Export Strategy
+
+## Hinglish Preprocessing Pipeline
+
+- XLM-RoBERTa's SentencePiece tokenizer was trained on clean text. Hinglish has extreme spelling variation ("kaise" / "kese" / "kayse").
+- dhvani normalizes all Romanized Hindi variants to a canonical IPA-based form **without** transliterating to Devanagari — preserving the Roman-script input that the model was fine-tuned on.
+- English words pass through untouched.
+- <1ms per word — negligible latency cost.
+- Add `akshar-32k` tokenizer as a pre-tokenization step. But benchmark first — it may not improve F1 over using XLM-R's tokenizer directly after dhvani normalization.
+
+## Version Compatibility
+
+| Package | Compatible With | Notes |
+|---------|-----------------|-------|
+| transformers 5.x | PyTorch 2.10+ | v5.x is a major restructure. `Trainer`, `AutoModel`, and pipeline APIs are backward-compatible but some internals changed. Pin carefully. |
+| optimum-onnx 0.1.x | optimum 1.26+, transformers 5.x | Split from optimum. Must install both. |
+| onnxruntime 1.27.x | Python 3.11+ | Python 3.10 wheels no longer published. |
+| PEFT 0.19.x | transformers 5.x, accelerate 1.x | Check `get_peft_model` compatibility with XLMRobertaForTokenClassification. |
+| dhvani 0.2.x | Python 3.10+ | No external model dependencies. Pure Python. |
+| MLflow 3.14.x | Python 3.10+ | `mlflow-skinny` for minimal deps, `mlflow[extras]` for full. |
+| DVC 3.67.x | Python 3.10+ | Works with any Git remote. |
+
+## Sources
+
+- HuggingFace Transformers docs (v5.12.1) — XLM-RoBERTa model card, export guide, token classification tutorial — HIGH confidence
+- `huggingface.co/facebookai/xlm-roberta-base` — 16M+ monthly downloads, confirmed active — HIGH confidence
+- `huggingface.co/ai4bharat/IndicBERT-v3-4B` — IndicBERT v3 model card, curriculum training strategy — HIGH confidence
+- PEFT GitHub releases (v0.19.0, 2026-04-14) — feature list, LoRA/QLoRA/GraLoRA support — HIGH confidence
+- optimum-onnx GitHub (v0.1.0, 2025-12-23) — split from optimum, export CLI — HIGH confidence
+- onnxruntime PyPI (v1.27.0, 2026-06-15) — version history, Python requirement — HIGH confidence
+- seqeval PyPI (v1.2.2, latest) — stable, last updated 2020 — MEDIUM confidence (no updates needed but inactive)
+- dhvani PyPI + GitHub — Hinglish normalization documentation — HIGH confidence
+- akshar-32k HuggingFace — custom Hinglish BPE tokenizer — MEDIUM confidence (niche, unproven at scale)
+- Cross-lingual ABSA survey (Smíd et al., 2025) — token-classification paradigm for ATE, pipeline for compound tasks — HIGH confidence
+- M-ABSA dataset paper (Wu et al., EMNLP 2025) — multilingual ABSA benchmark, 21 languages — HIGH confidence
+- LACA: Cross-lingual ABSA with LLM augmentation (Šmíd et al., ACL 2025) — state-of-the-art cross-lingual methods — HIGH confidence
+
+<!-- GSD:stack-end -->
+
+<!-- GSD:conventions-start source:CONVENTIONS.md -->
+
+## Conventions
+
+Conventions not yet established. Will populate as patterns emerge during development.
+<!-- GSD:conventions-end -->
+
+<!-- GSD:architecture-start source:ARCHITECTURE.md -->
+
+## Architecture
+
+Architecture not yet mapped. Follow existing patterns found in the codebase.
+<!-- GSD:architecture-end -->
+
+<!-- GSD:skills-start source:skills/ -->
+
+## Project Skills
+
+No project skills found. Add skills to any of: `.claude/skills/`, `.agents/skills/`, `.cursor/skills/`, `.github/skills/`, or `.codex/skills/` with a `SKILL.md` index file.
+<!-- GSD:skills-end -->
+
+<!-- GSD:workflow-start source:GSD defaults -->
+
+## GSD Workflow Enforcement
+
+Before using Edit, Write, or other file-changing tools, start work through a GSD command so planning artifacts and execution context stay in sync.
+
+Use these entry points:
+
+- `/gsd-quick` for small fixes, doc updates, and ad-hoc tasks
+- `/gsd-debug` for investigation and bug fixing
+- `/gsd-execute-phase` for planned phase work
+
+Do not make direct repo edits outside a GSD workflow unless the user explicitly asks to bypass it.
+<!-- GSD:workflow-end -->
+
+<!-- GSD:profile-start -->
+
+## Developer Profile
+
+> Profile not yet configured. Run `/gsd-profile-user` to generate your developer profile.
+> This section is managed by `generate-claude-profile` -- do not edit manually.
+<!-- GSD:profile-end -->

.gitignore

@@ -0,0 +1,21 @@
+node_modules/
+.env*
+*.log
+.DS_Store
+opencode.exe
+
+# Opencode/GSD files to exclude
+.opencode/*
+!.opencode/package.json
+!.opencode/package-lock.json
+!.opencode/.gsd-profile
+!.opencode/skills
+!.opencode/skills/**
+!.opencode/scripts
+!.opencode/scripts/**
+!.opencode/hooks
+!.opencode/hooks/**
+!.opencode/command
+!.opencode/command/**
+!.opencode/gsd-core
+!.opencode/gsd-core/**

.opencode/.gsd-profile

@@ -0,0 +1 @@
+full

.opencode/command/gsd-add-tests.md

@@ -0,0 +1,41 @@
+---
+description: Generate tests for a completed phase based on UAT criteria and implementation
+argument-hint: "<phase> [additional instructions]"
+argument-instructions: |
+  Parse the argument as a phase number (integer, decimal, or letter-suffix), plus optional free-text instructions.
+  Example: /gsd-add-tests 12
+  Example: /gsd-add-tests 12 focus on edge cases in the pricing module
+requires: [phase]
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  question: true
+---
+<objective>
+Generate unit and E2E tests for a completed phase, using its SUMMARY.md, CONTEXT.md, and VERIFICATION.md as specifications.
+
+Analyzes implementation files, classifies them into TDD (unit), E2E (browser), or Skip categories, presents a test plan for user approval, then generates tests following RED-GREEN conventions.
+
+Output: Test files committed with message `test(phase-{N}): add unit and E2E tests from add-tests command`
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/add-tests.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS
+
+@.planning/STATE.md
+@.planning/ROADMAP.md
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (classification approval, test plan approval, RED-GREEN verification, gap reporting).
+</process>

.opencode/command/gsd-ai-integration-phase.md

@@ -0,0 +1,36 @@
+---
+description: Generate an AI-SPEC.md design contract for phases that involve building AI systems.
+argument-hint: "[phase number]"
+requires: [phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  webfetch: true
+  websearch: true
+  question: true
+  mcp__context7__*: true
+---
+<objective>
+Create an AI design contract (AI-SPEC.md) for a phase involving AI system development.
+Orchestrates gsd-framework-selector → gsd-ai-researcher → gsd-domain-researcher → gsd-eval-planner.
+Flow: Select Framework → Research Docs → Research Domain → Design Eval Strategy → Done
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/ai-integration-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ai-frameworks.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ai-evals.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS — optional, auto-detects next unplanned phase if omitted.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

.opencode/command/gsd-audit-fix.md

@@ -0,0 +1,33 @@
+---
+type: prompt
+description: Autonomous audit-to-fix pipeline — find issues, classify, fix, test, commit
+argument-hint: "--source <audit-uat> [--severity <medium|high|all>] [--max N] [--dry-run]"
+requires: [audit-uat]
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  grep: true
+  glob: true
+  agent: true
+  question: true
+---
+<objective>
+Run an audit, classify findings as auto-fixable vs manual-only, then autonomously fix
+auto-fixable issues with test verification and atomic commits.
+
+Flags:
+- `--max N` — maximum findings to fix (default: 5)
+- `--severity high|medium|all` — minimum severity to process (default: medium)
+- `--dry-run` — classify findings without fixing (shows classification table)
+- `--source <audit>` — which audit to run (default: audit-uat)
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/audit-fix.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

.opencode/command/gsd-audit-milestone.md

@@ -0,0 +1,36 @@
+---
+description: Audit milestone completion against original intent before archiving
+argument-hint: "[version]"
+requires: [execute-phase]
+tools:
+  read: true
+  glob: true
+  grep: true
+  bash: true
+  agent: true
+  write: true
+---
+<objective>
+Verify milestone achieved its definition of done. Check requirements coverage, cross-phase integration, and end-to-end flows.
+
+**This command IS the orchestrator.** Reads existing VERIFICATION.md files (phases already verified during execute-phase), aggregates tech debt and deferred gaps, then spawns integration checker for cross-phase wiring.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/audit-milestone.md
+</execution_context>
+
+<context>
+Version: $ARGUMENTS (optional — defaults to current milestone)
+
+Core planning files are resolved in-workflow (`init milestone-op`) and loaded only as needed.
+
+**Completed Work:**
+Glob: .planning/phases/*/*-SUMMARY.md
+Glob: .planning/phases/*/*-VERIFICATION.md
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (scope determination, verification reading, integration check, requirements coverage, routing).
+</process>

.opencode/command/gsd-audit-uat.md

@@ -0,0 +1,23 @@
+---
+description: Cross-phase audit of all outstanding UAT and verification items
+tools:
+  read: true
+  glob: true
+  grep: true
+  bash: true
+---
+<objective>
+Scan all phases for pending, skipped, blocked, and human_needed UAT items. Cross-reference against codebase to detect stale documentation. Produce prioritized human test plan.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/audit-uat.md
+</execution_context>
+
+<context>
+Core planning files are loaded in-workflow via CLI.
+
+**Scope:**
+Glob: .planning/phases/*/*-UAT.md
+Glob: .planning/phases/*/*-VERIFICATION.md
+</context>

.opencode/command/gsd-autonomous.md

@@ -0,0 +1,50 @@
+---
+description: Run all remaining phases autonomously — discuss→plan→execute per phase
+argument-hint: "[--from N] [--to N] [--only N] [--interactive] [--converge]"
+effort: max
+requires: [cleanup, phase, progress]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  agent: true
+---
+<objective>
+Execute all remaining milestone phases autonomously. For each phase: discuss → plan → execute. Pauses only for user decisions (grey area acceptance, blockers, validation requests).
+
+Uses ROADMAP.md phase discovery and Skill() flat invocations for each phase command. After all phases complete: milestone audit → complete → cleanup.
+
+**Creates/Updates:**
+- `.planning/STATE.md` — updated after each phase
+- `.planning/ROADMAP.md` — progress updated after each phase
+- Phase artifacts — CONTEXT.md, PLANs, SUMMARYs per phase
+
+**After:** Milestone is complete and cleaned up.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/autonomous.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Optional flags:
+- `--from N` — start from phase N instead of the first incomplete phase.
+- `--to N` — stop after phase N completes (halt instead of advancing to next phase).
+- `--only N` — execute only phase N (single-phase mode).
+- `--interactive` — run discuss inline with questions (not auto-answered), then dispatch plan→execute as background agents. Keeps the main context lean while preserving user input on decisions.
+- `--converge` — run each phase's planning step through `gsd-plan-review-convergence` instead of plain `gsd-plan-phase`. Requires `workflow.plan_review_convergence=true`.
+- `--cross-ai` — compatibility alias for `--converge`.
+
+When `--converge` or `--cross-ai` is set, reviewer selector flags supported by `gsd-plan-review-convergence` may be passed through: `--codex`, `--gemini`, `--claude`, `--opencode`, `--ollama`, `--lm-studio`, `--llama-cpp`, `--all`, and `--max-cycles N`.
+
+Project context, phase list, and state are resolved inside the workflow using init commands (`gsd-tools query init.milestone-op`, `gsd-tools query roadmap.analyze`). No upfront context loading needed.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (phase discovery, per-phase execution, blocker handling, progress display).
+</process>

.opencode/command/gsd-capture.md

@@ -0,0 +1,61 @@
+---
+description: Capture ideas, tasks, notes, and seeds to their destination
+argument-hint: "[--note | --backlog | --seed | --list] [text]"
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+---
+
+<objective>
+Capture ideas, tasks, notes, and seeds to their appropriate destination in the GSD system.
+
+Mode routing:
+- **default** (no flag): Capture as a structured todo for later work → add-todo workflow
+- **--note**: Zero-friction idea capture (append/list/promote) → note workflow
+- **--backlog**: Add an idea to the backlog parking lot (999.x numbering) → add-backlog workflow
+- **--seed**: Capture a forward-looking idea with trigger conditions → plant-seed workflow
+- **--list**: List pending todos and select one to work on → check-todos workflow
+</objective>
+
+<routing>
+
+| Flag | Destination | Workflow |
+|------|-------------|----------|
+| (none) | Structured todo in .planning/todos/ | add-todo |
+| --note | Timestamped note file, list, or promote | note |
+| --backlog | ROADMAP.md backlog section (999.x) | add-backlog |
+| --seed | .planning/seeds/SEED-NNN-slug.md | plant-seed |
+| --list | Interactive todo browser + action router | check-todos |
+
+</routing>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/add-todo.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/note.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/add-backlog.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/plant-seed.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/check-todos.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--note`: strip the flag, pass remainder to note workflow
+- If it is `--backlog`: strip the flag, pass remainder to add-backlog workflow
+- If it is `--seed`: strip the flag, pass remainder to plant-seed workflow
+- If it is `--list`: pass remainder (optional area filter) to check-todos workflow
+- Otherwise: pass all of $ARGUMENTS to add-todo workflow
+</context>
+
+<process>
+1. Parse the leading flag (if any) from $ARGUMENTS.
+2. Load and execute the appropriate workflow end-to-end based on the routing table above.
+3. Preserve all workflow gates from the target workflow (directory structure, duplicate detection, commits, etc.).
+</process>

.opencode/command/gsd-cleanup.md

@@ -0,0 +1,23 @@
+---
+description: Archive accumulated phase directories from completed milestones
+requires: [phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  question: true
+---
+<objective>
+Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`.
+
+Use when `.planning/phases/` has accumulated directories from past milestones.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/cleanup.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+Identify completed milestones, show a dry-run summary, and archive on confirmation.
+</process>

.opencode/command/gsd-code-review.md

@@ -0,0 +1,58 @@
+---
+description: Review source files changed during a phase for bugs, security issues, and code quality problems
+argument-hint: "<phase-number> [--depth=quick|standard|deep] [--files file1,file2,...] [--fix [--all] [--auto]]"
+requires: [config, import, phase, quick, review]
+tools:
+  read: true
+  bash: true
+  glob: true
+  grep: true
+  write: true
+  agent: true
+---
+<objective>
+Review source files changed during a phase for bugs, security vulnerabilities, and code quality problems.
+
+Spawns the gsd-code-reviewer agent to analyze code at the specified depth level. Produces REVIEW.md artifact in the phase directory with severity-classified findings.
+
+Arguments:
+- Phase number (required) — which phase's changes to review (e.g., "2" or "02")
+- `--depth=quick|standard|deep` (optional) — review depth level, overrides workflow.code_review_depth config
+  - quick: Pattern-matching only (~2 min)
+  - standard: Per-file analysis with language-specific checks (~5-15 min, default)
+  - deep: Cross-file analysis including import graphs and call chains (~15-30 min)
+- `--files file1,file2,...` (optional) — explicit comma-separated file list, skips SUMMARY/git scoping (highest precedence for scoping)
+- `--fix` (optional) — after review completes (or if REVIEW.md already exists), auto-apply fixes found. Spawns gsd-code-fixer agent. Accepts sub-flags:
+  - `--all` — include Info findings in fix scope (default: Critical + Warning only)
+  - `--auto` — enable fix + re-review iteration loop, capped at 3 iterations
+
+Output: {padded_phase}-REVIEW.md in phase directory + inline summary of findings
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/code-review.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS (first positional argument is phase number)
+
+Optional flags parsed from $ARGUMENTS:
+- `--depth=VALUE` — Depth override (quick|standard|deep). If provided, overrides workflow.code_review_depth config.
+- `--files=file1,file2,...` — Explicit file list override. Has highest precedence for file scoping per D-08. When provided, workflow skips SUMMARY.md extraction and git diff fallback entirely.
+
+Context files (AGENTS.md, SUMMARY.md, phase state) are resolved inside the workflow via `gsd-tools query init.phase-op` and delegated to agent via `<files_to_read>` blocks.
+</context>
+
+<process>
+This command is a thin dispatch layer. It parses arguments and delegates to the workflow.
+
+Execute end-to-end.
+
+The workflow (not this command) enforces these gates:
+- Phase validation (before config gate)
+- Config gate check (workflow.code_review)
+- File scoping (--files override > SUMMARY.md > git diff fallback)
+- Empty scope check (skip if no files)
+- Agent spawning (gsd-code-reviewer)
+- Result presentation (inline summary + next steps)
+</process>

.opencode/command/gsd-complete-milestone.md

@@ -0,0 +1,142 @@
+---
+type: prompt
+description: Archive completed milestone and prepare for next version
+argument-hint: <version>
+requires: [audit-milestone, discuss-phase, execute-phase, new-milestone, phase, plan-phase, stats, update]
+tools:
+  read: true
+  write: true
+  bash: true
+---
+
+<objective>
+Mark milestone {{version}} complete, archive to milestones/, and update ROADMAP.md and REQUIREMENTS.md.
+
+Purpose: Create historical record of shipped version, archive milestone artifacts (roadmap + requirements), and prepare for next milestone.
+Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tagged.
+</objective>
+
+<execution_context>
+**Load these files NOW (before proceeding):**
+
+- @/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/complete-milestone.md (main workflow)
+- @/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/templates/milestone-archive.md (archive template)
+  </execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/REQUIREMENTS.md`
+- `.planning/STATE.md`
+- `.planning/PROJECT.md`
+
+**User input:**
+
+- Version: {{version}} (e.g., "1.0", "1.1", "2.0")
+  </context>
+
+<process>
+
+**Follow complete-milestone.md workflow:**
+
+0. **Check for audit:**
+
+   - Look for `.planning/v{{version}}-MILESTONE-AUDIT.md`
+   - If missing or stale: recommend `/gsd-audit-milestone` first
+   - If audit status is `gaps_found`: recommend closing the gaps inline
+     (the audit output already enumerates them — insert closure phases
+     via `/gsd-phase --insert <N>` plus the standard
+     discuss/plan/execute chain) before proceeding.
+   - If audit status is `passed`: proceed to step 1
+
+   ```markdown
+   ## Pre-flight Check
+
+   {If no v{{version}}-MILESTONE-AUDIT.md:}
+   ⚠ No milestone audit found. Run `/gsd-audit-milestone` first to verify
+   requirements coverage, cross-phase integration, and E2E flows.
+
+   {If audit has gaps:}
+   ⚠ Milestone audit found gaps. The audit output already enumerates the
+   unsatisfied requirements, cross-phase issues, and broken flows — insert
+   a closure phase per gap with `/gsd-phase --insert <N>` and run the
+   standard `/gsd-discuss-phase` → `/gsd-plan-phase` → `/gsd-execute-phase`
+   chain. Or proceed anyway to accept the gaps as tech debt.
+
+   {If audit passed:}
+   ✓ Milestone audit passed. Proceeding with completion.
+   ```
+
+1. **Verify readiness:**
+
+   - Check all phases in milestone have completed plans (SUMMARY.md exists)
+   - Present milestone scope and stats
+   - Wait for confirmation
+
+2. **Gather stats:**
+
+   - Count phases, plans, tasks
+   - Calculate git range, file changes, LOC
+   - Extract timeline from git log
+   - Present summary, confirm
+
+3. **Extract accomplishments:**
+
+   - Read all phase SUMMARY.md files in milestone range
+   - Extract 4-6 key accomplishments
+   - Present for approval
+
+4. **Archive milestone:**
+
+   - Create `.planning/milestones/v{{version}}-ROADMAP.md`
+   - Extract full phase details from ROADMAP.md
+   - Fill milestone-archive.md template
+   - Update ROADMAP.md to one-line summary with link
+
+5. **Archive requirements:**
+
+   - Create `.planning/milestones/v{{version}}-REQUIREMENTS.md`
+   - Mark all v1 requirements as complete (checkboxes checked)
+   - Note requirement outcomes (validated, adjusted, dropped)
+   - Delete `.planning/REQUIREMENTS.md` (fresh one created for next milestone)
+
+6. **Update PROJECT.md:**
+
+   - Add "Current State" section with shipped version
+   - Add "Next Milestone Goals" section
+   - Archive previous content in `<details>` (if v1.1+)
+
+7. **Commit and tag:**
+
+   - Stage: MILESTONES.md, PROJECT.md, ROADMAP.md, STATE.md, archive files
+   - Commit: `chore: archive v{{version}} milestone`
+   - Tag: `git tag -a v{{version}} -m "[milestone summary]"`
+   - Ask about pushing tag
+
+8. **Offer next steps:**
+   - `/gsd-new-milestone` — start next milestone (questioning → research → requirements → roadmap)
+
+</process>
+
+<success_criteria>
+
+- Milestone archived to `.planning/milestones/v{{version}}-ROADMAP.md`
+- Requirements archived to `.planning/milestones/v{{version}}-REQUIREMENTS.md`
+- `.planning/REQUIREMENTS.md` deleted (fresh for next milestone)
+- ROADMAP.md collapsed to one-line entry
+- PROJECT.md updated with current state
+- Git tag v{{version}} created (if `git.create_tag` enabled)
+- Commit successful
+- User knows next steps (including need for fresh requirements)
+  </success_criteria>
+
+<critical_rules>
+
+- **Load workflow first:** Read complete-milestone.md before executing
+- **Verify completion:** All phases must have SUMMARY.md files
+- **User confirmation:** Wait for approval at verification gates
+- **Archive before deleting:** Always create archive files before updating/deleting originals
+- **One-line summary:** Collapsed milestone in ROADMAP.md should be single line with link
+- **Context efficiency:** Archive keeps ROADMAP.md and REQUIREMENTS.md constant size per milestone
+- **Fresh requirements:** Next milestone starts with `/gsd-new-milestone` which includes requirements definition
+  </critical_rules>

.opencode/command/gsd-config.md

@@ -0,0 +1,55 @@
+---
+description: Configure GSD settings — workflow toggles, advanced knobs, integrations, and model profile
+argument-hint: "[--advanced | --integrations | --profile <name>]"
+requires: [code-review, review, settings]
+tools:
+  read: true
+  write: true
+  bash: true
+  question: true
+---
+
+<objective>
+Configure GSD settings interactively with a single consolidated command.
+
+Mode routing:
+- **default** (no flag): Common-case toggles (model, research, plan_check, verifier, branching) → settings workflow
+- **--advanced**: Power-user knobs (planning tuning, timeouts, branch templates, cross-AI execution) → settings-advanced workflow
+- **--integrations**: Third-party API keys, code-review CLI routing, agent-skill injection → settings-integrations workflow
+- **--profile <name>**: Switch model profile (quality|balanced|budget|inherit) → set-profile (inline)
+</objective>
+
+<routing>
+
+| Flag | Action | Workflow |
+|------|--------|----------|
+| (none) | Interactive 5-question common-case config prompt | settings |
+| --advanced | Power-user knobs: planning, execution, discussion, cross-AI, git, runtime | settings-advanced |
+| --integrations | API keys (Brave/Firecrawl/Exa), review CLI routing, agent skills | settings-integrations |
+| --profile &lt;name&gt; | Switch model profile without interactive prompt | gsd-tools query config-set-model-profile |
+
+</routing>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/settings.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/settings-advanced.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/settings-integrations.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--advanced`: strip the flag, execute settings-advanced workflow
+- If it is `--integrations`: strip the flag, execute settings-integrations workflow
+- If it starts with `--profile`: extract the profile name (remainder after `--profile`), then:
+  1. Verify `gsd-tools` is on PATH via `command -v gsd-tools`; if absent, emit the install hint `Install GSD via 'npm i -g @opengsd/gsd-core'` and stop.
+  2. Run: `gsd-tools query config-set-model-profile <profile-name> --raw` and display the output verbatim.
+- Otherwise: execute settings workflow (no argument needed)
+</context>
+
+<process>
+1. Parse the leading flag (if any) from $ARGUMENTS.
+2. Load and execute the appropriate workflow end-to-end, or run the inline SDK command for --profile.
+3. Preserve all workflow gates from the target workflow.
+</process>

.opencode/command/gsd-debug.md

@@ -0,0 +1,51 @@
+---
+description: Systematic debugging with persistent state across context resets
+argument-hint: "[list | status <slug> | continue <slug> | --diagnose] [issue description]"
+tools:
+  read: true
+  write: true
+  bash: true
+  agent: true
+  question: true
+---
+
+<objective>
+Debug issues using scientific method with subagent isolation.
+
+**Orchestrator role:** Gather symptoms, spawn gsd-debugger agent, handle checkpoints, spawn continuations.
+
+**Flags:**
+- `--diagnose` — Diagnose only. Returns a Root Cause Report without applying a fix.
+
+**Subcommands:** `list` · `status <slug>` · `continue <slug>`
+</objective>
+
+<available_agent_types>
+Valid GSD subagent types (use exact names — do not fall back to 'general-purpose'):
+- gsd-debug-session-manager — manages debug checkpoint/continuation loop in isolated context
+- gsd-debugger — investigates bugs using scientific method
+</available_agent_types>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/debug.md
+</execution_context>
+
+<context>
+User's input: $ARGUMENTS
+
+Parse subcommands and flags from $ARGUMENTS BEFORE the active-session check:
+- If $ARGUMENTS starts with "list": SUBCMD=list, no further args
+- If $ARGUMENTS starts with "status ": SUBCMD=status, SLUG=remainder (trim whitespace)
+- If $ARGUMENTS starts with "continue ": SUBCMD=continue, SLUG=remainder (trim whitespace)
+- If $ARGUMENTS contains `--diagnose`: SUBCMD=debug, diagnose_only=true, strip `--diagnose` from description
+- Otherwise: SUBCMD=debug, diagnose_only=false
+
+Check for active sessions (used for non-list/status/continue flows):
+```bash
+ls .planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
+```
+</context>
+
+<process>
+Execute end-to-end.
+</process>

.opencode/command/gsd-discuss-phase.md

@@ -0,0 +1,76 @@
+---
+description: Gather phase context through adaptive questioning before planning.
+argument-hint: "<phase> [--all] [--auto] [--chain] [--batch] [--analyze] [--text] [--power] [--assumptions]"
+requires: [config, phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  agent: true
+  mcp__context7__resolve-library-id: true
+  mcp__context7__query-docs: true
+---
+
+<objective>
+Extract implementation decisions that downstream agents need — researcher and planner will use CONTEXT.md to know what to investigate and what choices are locked.
+
+**How it works:**
+1. Load prior context (PROJECT.md, REQUIREMENTS.md, STATE.md, prior CONTEXT.md files)
+2. Scout codebase for reusable assets and patterns
+3. Analyze phase — skip gray areas already decided in prior phases
+4. Present remaining gray areas — user selects which to discuss
+5. Deep-dive each selected area until satisfied
+6. Create CONTEXT.md with decisions that guide research and planning
+
+**Output:** `{phase_num}-CONTEXT.md` — decisions clear enough that downstream agents can act without asking the user again
+</objective>
+
+<execution_context>
+Workflow files are loaded on-demand in the <process> section below — not upfront.
+Do not pre-load any workflow files before reading the mode routing instructions.
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+Context files are resolved in-workflow using `init phase-op` and roadmap/state tool calls.
+</context>
+
+<process>
+**Mode routing:**
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+DISCUSS_MODE=$(gsd_run query config-get workflow.discuss_mode 2>/dev/null || echo "discuss")
+```
+
+If `--assumptions` is in $ARGUMENTS:
+Read and execute `/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/list-phase-assumptions.md` end-to-end.
+Stop here.
+
+Otherwise, if `DISCUSS_MODE` is `"assumptions"`:
+Read and execute `/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/discuss-phase-assumptions.md` end-to-end.
+
+Otherwise (`"discuss"` / unset / any other value):
+Read and execute `/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/discuss-phase.md` end-to-end.
+
+**MANDATORY:** Read the appropriate workflow file BEFORE taking any action. The objective and success_criteria sections in this command file are summaries — the workflow file contains the complete step-by-step process with all required behaviors, config checks, and interaction patterns. Do not improvise from the summary.
+
+**Lazy loading:** `templates/context.md` is loaded inside the `write_context` step of the active workflow. `discuss-phase-power.md` is loaded inside `discuss-phase.md` when `--power` is detected. Do not load either here.
+</process>
+
+<success_criteria>
+- Prior context loaded and applied (no re-asking decided questions)
+- Gray areas identified through intelligent analysis
+- User chose which areas to discuss
+- Each selected area explored until satisfied
+- Scope creep redirected to deferred ideas
+- CONTEXT.md captures decisions, not vague vision
+- User knows next steps
+</success_criteria>

.opencode/command/gsd-docs-update.md

@@ -0,0 +1,48 @@
+---
+description: Generate or update project documentation verified against the codebase
+argument-hint: "[--force] [--verify-only]"
+requires: [update]
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  question: true
+---
+<objective>
+Generate and update up to 9 documentation files for the current project. Each doc type is written by a gsd-doc-writer subagent that explores the codebase directly — no hallucinated paths, phantom endpoints, or stale signatures.
+
+Flag handling rule:
+- The optional flags documented below are available behaviors, not implied active behaviors
+- A flag is active only when its literal token appears in `$ARGUMENTS`
+- If a documented flag is absent from `$ARGUMENTS`, treat it as inactive
+- `--force`: skip preservation prompts, regenerate all docs regardless of existing content or GSD markers
+- `--verify-only`: check existing docs for accuracy against codebase, no generation (full verification requires Phase 4 verifier)
+- If `--force` and `--verify-only` both appear in `$ARGUMENTS`, `--force` takes precedence
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/docs-update.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Available optional flags (documentation only — not automatically active):**
+- `--force` — Regenerate all docs. Overwrites hand-written and GSD docs alike. No preservation prompts.
+- `--verify-only` — Check existing docs for accuracy against the codebase. No files are written. Reports VERIFY marker count. Full codebase fact-checking requires the gsd-doc-verifier agent (Phase 4).
+
+**Active flags must be derived from `$ARGUMENTS`:**
+- `--force` is active only if the literal `--force` token is present in `$ARGUMENTS`
+- `--verify-only` is active only if the literal `--verify-only` token is present in `$ARGUMENTS`
+- If neither token appears, run the standard full-phase generation flow
+- Do not infer that a flag is active just because it is documented in this prompt
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (preservation_check, flag handling, wave execution, monorepo dispatch, commit, reporting).
+</process>

.opencode/command/gsd-eval-review.md

@@ -0,0 +1,32 @@
+---
+description: Audit an executed AI phase's evaluation coverage and produce an EVAL-REVIEW.md remediation plan.
+argument-hint: "[phase number]"
+requires: [phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  question: true
+---
+<objective>
+Conduct a retroactive evaluation coverage audit of a completed AI phase.
+Checks whether the evaluation strategy from AI-SPEC.md was implemented.
+Produces EVAL-REVIEW.md with score, verdict, gaps, and remediation plan.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/eval-review.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ai-evals.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS — optional, defaults to last completed phase.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

.opencode/command/gsd-execute-phase.md

@@ -0,0 +1,64 @@
+---
+description: Execute all plans in a phase with wave-based parallelization
+argument-hint: "<phase-number> [--wave N] [--gaps-only] [--interactive] [--tdd]"
+effort: max
+requires: [phase, verify-work]
+tools:
+  read: true
+  write: true
+  edit: true
+  glob: true
+  grep: true
+  bash: true
+  agent: true
+  todowrite: true
+  question: true
+---
+<objective>
+Execute all plans in a phase using wave-based parallel execution.
+
+Orchestrator stays lean: discover plans, analyze dependencies, group into waves, spawn subagents, collect results. Each subagent loads the full execute-plan context and handles its own plan.
+
+Optional wave filter:
+- `--wave N` executes only Wave `N` for pacing, quota management, or staged rollout
+- phase verification/completion still only happens when no incomplete plans remain after the selected wave finishes
+
+Flag handling rule:
+- The optional flags documented below are available behaviors, not implied active behaviors
+- A flag is active only when its literal token appears in `$ARGUMENTS`
+- If a documented flag is absent from `$ARGUMENTS`, treat it as inactive
+
+Context budget: ~15% orchestrator, 100% fresh per subagent.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/execute-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
+<context>
+Phase: $ARGUMENTS
+
+**Available optional flags (documentation only — not automatically active):**
+- `--wave N` — Execute only Wave `N` in the phase. Use when you want to pace execution or stay inside usage limits.
+- `--gaps-only` — Execute only gap closure plans (plans with `gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
+- `--interactive` — Execute plans sequentially inline (no subagents) with user checkpoints between tasks. Lower token usage, pair-programming style. Best for small phases, bug fixes, and verification gaps.
+
+**Active flags must be derived from `$ARGUMENTS`:**
+- `--wave N` is active only if the literal `--wave` token is present in `$ARGUMENTS`
+- `--gaps-only` is active only if the literal `--gaps-only` token is present in `$ARGUMENTS`
+- `--interactive` is active only if the literal `--interactive` token is present in `$ARGUMENTS`
+- If none of these tokens appear, run the standard full-phase execution flow with no flag-specific filtering
+- Do not infer that a flag is active just because it is documented in this prompt
+
+Context files are resolved inside the workflow via `gsd-tools query init.execute-phase` and per-subagent `<files_to_read>` blocks.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (wave execution, checkpoint handling, verification, state updates, routing).
+</process>

.opencode/command/gsd-explore.md

@@ -0,0 +1,26 @@
+---
+description: Socratic ideation and idea routing — think through ideas before committing to plans
+tools:
+  read: true
+  write: true
+  bash: true
+  grep: true
+  glob: true
+  agent: true
+  question: true
+---
+<objective>
+Open-ended Socratic ideation session. Guides the developer through exploring an idea via
+probing questions, optionally spawns research, then routes outputs to the appropriate GSD
+artifacts (notes, todos, seeds, research questions, requirements, or new phases).
+
+Accepts an optional topic argument: `/gsd-explore authentication strategy`
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/explore.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

.opencode/command/gsd-extract-learnings.md

@@ -0,0 +1,22 @@
+---
+description: Extract decisions, lessons, patterns, and surprises from completed phase artifacts
+argument-hint: <phase-number>
+type: prompt
+requires: [phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  grep: true
+  glob: true
+  agent: true
+---
+<objective>
+Extract structured learnings from completed phase artifacts (PLAN.md, SUMMARY.md, VERIFICATION.md, UAT.md, STATE.md) into a LEARNINGS.md file that captures decisions, lessons learned, patterns discovered, and surprises encountered.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/extract-learnings.md
+</execution_context>
+
+Execute the extract-learnings workflow from @/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/extract-learnings.md end-to-end.

.opencode/command/gsd-fast.md

@@ -0,0 +1,30 @@
+---
+description: Execute a trivial task inline — no subagents, no planning overhead
+argument-hint: "[task description]"
+requires: [config, quick]
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  grep: true
+  glob: true
+---
+
+<objective>
+Execute a trivial task directly in the current context without spawning subagents
+or generating PLAN.md files. For tasks too small to justify planning overhead:
+typo fixes, config changes, small refactors, forgotten commits, simple additions.
+
+This is NOT a replacement for /gsd-quick — use /gsd-quick for anything that
+needs research, multi-step planning, or verification. /gsd-fast is for tasks
+you could describe in one sentence and execute in under 2 minutes.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/fast.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

.opencode/command/gsd-forensics.md

@@ -0,0 +1,56 @@
+---
+type: prompt
+description: Post-mortem investigation for failed GSD workflows — diagnoses what went wrong.
+argument-hint: "[problem description]"
+requires: [phase, progress, update]
+tools:
+  read: true
+  write: true
+  bash: true
+  grep: true
+  glob: true
+---
+
+<objective>
+Investigate what went wrong during a GSD workflow execution. Analyzes git history, `.planning/` artifacts, and file system state to detect anomalies and generate a structured diagnostic report.
+
+Purpose: Diagnose failed or stuck workflows so the user can understand root cause and take corrective action.
+Output: Forensic report saved to `.planning/forensics/`, presented inline, with optional issue creation.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/forensics.md
+</execution_context>
+
+<context>
+**Data sources:**
+- `git log` (recent commits, patterns, time gaps)
+- `git status` / `git diff` (uncommitted work, conflicts)
+- `.planning/STATE.md` (current position, session history)
+- `.planning/ROADMAP.md` (phase scope and progress)
+- `.planning/phases/*/` (PLAN.md, SUMMARY.md, VERIFICATION.md, CONTEXT.md)
+- `.planning/reports/SESSION_REPORT.md` (last session outcomes)
+
+**User input:**
+- Problem description: $ARGUMENTS (optional — will ask if not provided)
+</context>
+
+<process>
+Execute end-to-end.
+</process>
+
+<success_criteria>
+- Evidence gathered from all available data sources
+- At least 4 anomaly types checked (stuck loop, missing artifacts, abandoned work, crash/interruption)
+- Structured forensic report written to `.planning/forensics/report-{timestamp}.md`
+- Report presented inline with findings, anomalies, and recommendations
+- Interactive investigation offered for deeper analysis
+- GitHub issue creation offered if actionable findings exist
+</success_criteria>
+
+<critical_rules>
+- **Read-only investigation:** Do not modify project source files during forensics. Only write the forensic report and update STATE.md session tracking.
+- **Redact sensitive data:** Strip absolute paths, API keys, tokens from reports and issues.
+- **Ground findings in evidence:** Every anomaly must cite specific commits, files, or state data.
+- **No speculation without evidence:** If data is insufficient, say so — do not fabricate root causes.
+</critical_rules>

.opencode/command/gsd-graphify.md

@@ -0,0 +1,203 @@
+---
+description: "Build, query, and inspect the project knowledge graph in .planning/graphs/"
+argument-hint: "[build|query <term>|status|diff]"
+requires: [config, fast, phase, update]
+tools:
+  read: true
+  bash: true
+---
+
+**STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's command system. Using the Read tool on this file wastes tokens. Begin executing Step 0 immediately.**
+
+**CJS-only (graphify):** `graphify` subcommands are not registered on `gsd-tools query`. Use the `gsd_run` launcher shim (defined in each bash block below) or invoke the binary directly: `node <runtime-home>/gsd-core/bin/gsd-tools.cjs graphify …` where `<runtime-home>` is your runtime's config directory (e.g. `~/.config/opencode`, `~/.hermes`, `~/.cursor`). See `docs/CLI-TOOLS.md` for details. Other tooling may still use `gsd-tools query` where a handler exists.
+
+## Step 0 -- Banner
+
+**Before ANY tool calls**, display this banner:
+
+```
+GSD > GRAPHIFY
+```
+
+Then proceed to Step 1.
+
+## Step 1 -- Config Gate
+
+Check if graphify is enabled by reading `.planning/config.json` directly using the Read tool.
+
+**DO NOT use the gsd-tools config get-value command** -- it hard-exits on missing keys.
+
+1. Read `.planning/config.json` using the Read tool
+2. If the file does not exist: display the disabled message below and **STOP**
+3. Parse the JSON content. Check if `config.graphify && config.graphify.enabled === true`
+4. If `graphify.enabled` is NOT explicitly `true`: display the disabled message below and **STOP**
+5. If `graphify.enabled` is `true`: proceed to Step 2
+
+**Disabled message:**
+
+```
+GSD > GRAPHIFY
+
+Knowledge graph is disabled. To activate:
+
+  node <runtime-home>/gsd-core/bin/gsd-tools.cjs config-set graphify.enabled true
+
+Then run /gsd-graphify build to create the initial graph.
+```
+
+---
+
+## Step 2 -- Parse Argument
+
+Parse `$ARGUMENTS` to determine the operation mode:
+
+| Argument | Action |
+|----------|--------|
+| `build` | Run inline build (Step 3) |
+| `query <term>` | Run inline query (Step 2a) |
+| `status` | Run inline status check (Step 2b) |
+| `diff` | Run inline diff check (Step 2c) |
+| No argument or unknown | Show usage message |
+
+**Usage message** (shown when no argument or unrecognized argument):
+
+```
+GSD > GRAPHIFY
+
+Usage: /gsd-graphify <mode>
+
+Modes:
+  build           Build or rebuild the knowledge graph
+  query <term>    Search the graph for a term
+  status          Show graph freshness and statistics
+  diff            Show changes since last build
+```
+
+### Step 2a -- Query
+
+Run:
+
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+gsd_run graphify query <term>
+```
+
+Parse the JSON output and display results:
+- If the output contains `"disabled": true`, display the disabled message from Step 1 and **STOP**
+- If the output contains `"error"` field, display the error message and **STOP**
+- If no nodes found, display: `No graph matches for '<term>'. Try /gsd-graphify build to create or rebuild the graph.`
+- Otherwise, display matched nodes grouped by type, with edge relationships and confidence tiers (EXTRACTED/INFERRED/AMBIGUOUS)
+
+**STOP** after displaying results. Do not spawn an agent.
+
+### Step 2b -- Status
+
+Run:
+
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+gsd_run graphify status
+```
+
+Parse the JSON output and display:
+- If `exists: false`, display the message field
+- Otherwise show last build time, node/edge/hyperedge counts, and STALE or FRESH indicator
+- If `built_at_commit` is non-null, also display a `Source commit:` line:
+  - `commit_stale === false` (rebuilt at HEAD): `Source commit: <built_at_commit> (current)`
+  - `commit_stale === true` (graph behind HEAD): `Source commit: <built_at_commit> (<commits_behind> commits behind HEAD)`
+  - `commit_stale === null` (unreachable commit / no git): `Source commit: <built_at_commit> (freshness unknown)`
+- If `built_at_commit` is null (pre-graphify-v0.7 graph), omit the source-commit line entirely — do not render "Source commit: unknown"
+
+The mtime-based STALE/FRESH flag and the commit-based `commit_stale` measure
+different things and can disagree (e.g., a CI-built graph rebuilt minutes ago
+against an old checkout reads as FRESH on mtime but `commit_stale: true`).
+Surface both so the agent can choose.
+
+**STOP** after displaying status. Do not spawn an agent.
+
+### Step 2c -- Diff
+
+Run:
+
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+gsd_run graphify diff
+```
+
+Parse the JSON output and display:
+- If `no_baseline: true`, display the message field
+- Otherwise show node and edge change counts (added/removed/changed)
+
+If no snapshot exists, suggest running `build` twice (first to create, second to generate a diff baseline).
+
+**STOP** after displaying diff. Do not spawn an agent.
+
+---
+
+## Step 3 -- Build (Inline)
+
+Run the pre-flight check first:
+
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+gsd_run graphify build
+```
+
+Parse the JSON output:
+- If `disabled: true`: display the disabled message from Step 1 and **STOP**
+- If `error`: display the error message and **STOP**
+- If `action: "spawn_agent"`: pre-flight passed -- proceed with the inline build below
+
+(The `spawn_agent` action name is historical. The skill now performs the build inline because graphify v0.7+ split the build into a fast AST-extraction phase and a separate clustering + report-write phase. Sub-agent isolation kept the cached extraction phase alive but SIGTERM'd the post-extraction phase when the agent exited, leaving the cache populated but no `graph.json` artifacts written. The CLI still emits the `spawn_agent` signal so external callers and tests keep working.)
+
+Display:
+
+```text
+GSD > Building knowledge graph...
+```
+
+Run the build, copy artifacts, write the diff snapshot, and report the summary in a single foreground Bash call so the whole pipeline survives to completion. Use a `timeout` of `600000` ms (10 minutes), which covers the `graphify.build_timeout` ceiling (default 300 s) with margin:
+
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+graphify update . \
+  && cp graphify-out/graph.json .planning/graphs/graph.json \
+  && { [ -f graphify-out/graph.html ] && cp graphify-out/graph.html .planning/graphs/graph.html || true; } \
+  && cp graphify-out/GRAPH_REPORT.md .planning/graphs/GRAPH_REPORT.md \
+  && gsd_run graphify build snapshot \
+  && gsd_run graphify status
+```
+
+Do NOT pass `run_in_background: true`. Typical builds complete in 15-60 seconds and the entire chain must run foreground.
+
+If the chain fails (non-zero exit):
+- Display: `## GRAPHIFY BUILD FAILED` followed by the captured stderr
+- Do NOT delete `.planning/graphs/` -- the prior valid graph remains available
+- **STOP**
+
+If the chain succeeds:
+- Parse the trailing `graphify status` JSON
+- Display: `## GRAPHIFY BUILD COMPLETE` with the node, edge, and hyperedge counts
+
+---
+
+## MVP-Mode Node Rendering
+
+**MVP-mode rendering.** When a phase has `**Mode:** mvp` in ROADMAP.md (resolved via `gsd-tools query roadmap.get-phase --pick mode`), render its graph node with two distinct visual signals:
+
+1. **Distinct fill color.** Use `#22c55e` (green) for MVP-mode phase nodes. Standard phases keep the default fill color. Two-channel signaling (color + label) handles color-blind and grayscale renders.
+2. **`MVP` label suffix.** Append ` (MVP)` to the node's label text. Example: a phase originally labeled `Phase 1: User Auth` renders as `Phase 1: User Auth (MVP)`.
+
+Both signals fire together — never just one. Per PRD Q5 decision, the goal is unambiguous visual distinction in any render context.
+
+When the phase mode is null/absent, render with the standard color and label — no behavioral change for non-MVP phases.
+
+---
+
+## Anti-Patterns
+
+1. DO NOT spawn an agent for any operation -- build, query, status, and diff all run inline. Sub-agent isolation terminates background bash when the agent exits, which previously truncated graphify builds mid-write and left only the cache populated (#3166).
+2. DO NOT pass `run_in_background: true` for the build chain -- the operation is fast and must complete in the foreground.
+3. DO NOT modify graph files directly -- always go through `graphify update .` and the snapshot CLI.
+4. DO NOT skip the config gate check.
+5. DO NOT use `gsd-tools config get-value` for the config gate -- it exits on missing keys.

.opencode/command/gsd-health.md

@@ -0,0 +1,30 @@
+---
+description: Diagnose planning directory health and optionally repair issues
+argument-hint: "[--repair] [--context]"
+requires: [thread]
+tools:
+  read: true
+  bash: true
+  write: true
+  question: true
+---
+<objective>
+Validate `.planning/` directory integrity and report actionable issues. Checks for missing files, invalid configurations, inconsistent state, and orphaned plans.
+
+`--context` runs an orthogonal check: the running session's context utilization. The workflow asks for the model's tokensUsed + contextWindow, calls `gsd-tools query validate.context`, and renders one of three states:
+
+| Utilization | State    | Action                                                |
+|-------------|----------|-------------------------------------------------------|
+| < 60%       | healthy  | no action — context is comfortable                    |
+| 60% – 70%   | warning  | recommend `/gsd-thread` to start fresh                |
+| ≥ 70%       | critical | reasoning quality may degrade past the fracture point |
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/health.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+Parse `--repair` and `--context` flags from arguments and pass to workflow.
+</process>

.opencode/command/gsd-help.md

@@ -0,0 +1,27 @@
+---
+description: Show available GSD commands and usage guide
+argument-hint: "[--brief | --full | <topic> | --brief <topic>]"
+tools:
+  read: true
+---
+<objective>
+Display GSD help at the tier the user asked for: brief (one-line refresher), default (one-page tour), full (complete reference), a single topic section, or a compact scoped lookup of one topic (`--brief <topic>`: signature + one-line summary).
+
+Output ONLY the reference content of the chosen tier. Do NOT add:
+- Project-specific analysis
+- Git status or file context
+- Next-step suggestions
+- Any commentary beyond the reference
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/help.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+</context>
+
+<process>
+Follow /Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/help.md with $ARGUMENTS.
+</process>

.opencode/command/gsd-import.md

@@ -0,0 +1,44 @@
+---
+description: Ingest external plans with conflict detection against project decisions before writing anything.
+argument-hint: "--from <filepath> | --from-gsd2"
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  agent: true
+---
+
+<objective>
+Import external plan files into the GSD planning system with conflict detection against PROJECT.md decisions.
+
+- **--from**: Import an external plan file, detect conflicts, write as GSD PLAN.md, validate via gsd-plan-checker.
+- **--from-gsd2**: Reverse-migrate a GSD-2 project (`.gsd/` directory) back to GSD v1 (`.planning/`) format. Runs `gsd-tools.cjs from-gsd2`. Pass `--path <dir>` to migrate a project at a different path.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/import.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/gate-prompts.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/doc-conflict-engine.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+If `--from-gsd2` is in $ARGUMENTS:
+Run the reverse-migration (append `--path <dir>` if provided):
+```bash
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; if [ -f "$GSD_TOOLS" ]; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif command -v gsd-tools >/dev/null 2>&1; then GSD_TOOLS="$(command -v gsd-tools)"; gsd_run() { "$GSD_TOOLS" "$@"; }; elif [ -f "/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; elif [ -f "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}" ]; then GSD_TOOLS="${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; gsd_run() { node "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and gsd-tools is not on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi
+gsd_run from-gsd2
+```
+Present the migration result to the user.
+Stop here (do not run the standard import workflow).
+
+Otherwise, execute the import workflow end-to-end.
+</process>

.opencode/command/gsd-inbox.md

@@ -0,0 +1,38 @@
+---
+description: Triage and review open GitHub issues and PRs against project templates and contribution guidelines.
+argument-hint: "[--issues] [--prs] [--label] [--close-incomplete] [--repo owner/repo]"
+requires: [review]
+tools:
+  read: true
+  bash: true
+  write: true
+  grep: true
+  glob: true
+  question: true
+---
+<objective>
+One-command triage of the project's GitHub inbox. Fetches all open issues and PRs,
+reviews each against the corresponding template requirements (feature, enhancement,
+bug, chore, fix PR, enhancement PR, feature PR), reports completeness and compliance,
+and optionally applies labels or closes non-compliant submissions.
+
+**Flow:** Detect repo → Fetch open issues + PRs → Classify each by type → Review against template → Report findings → Optionally act (label, comment, close)
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/inbox.md
+</execution_context>
+
+<context>
+**Flags:**
+- `--issues` — Review only issues (skip PRs)
+- `--prs` — Review only PRs (skip issues)
+- `--label` — Auto-apply recommended labels after review
+- `--close-incomplete` — Close issues/PRs that fail template compliance (with comment explaining why)
+- `--repo owner/repo` — Override auto-detected repository (defaults to current git remote)
+</context>
+
+<process>
+Execute end-to-end.
+Parse flags from arguments and pass to workflow.
+</process>

.opencode/command/gsd-ingest-docs.md

@@ -0,0 +1,41 @@
+---
+description: Bootstrap or merge a .planning/ setup from existing ADRs, PRDs, SPECs, and docs in a repo.
+argument-hint: "[path] [--mode new|merge] [--manifest <file>] [--resolve auto|interactive]"
+tools:
+  read: true
+  write: true
+  edit: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  agent: true
+---
+
+<objective>
+Build the full `.planning/` setup (or merge into an existing one) from multiple pre-existing planning documents — ADRs, PRDs, SPECs, DOCs — in one pass.
+
+- **Net-new bootstrap** (`--mode new`, default when `.planning/` is absent): produces PROJECT.md + REQUIREMENTS.md + ROADMAP.md + STATE.md from synthesized doc content, delegating final generation to `gsd-roadmapper`.
+- **Merge into existing** (`--mode merge`, default when `.planning/` is present): appends phases and requirements derived from the ingested docs; hard-blocks any contradiction with existing locked decisions.
+
+Auto-synthesizes most conflicts using the precedence rule `ADR > SPEC > PRD > DOC` (overridable via manifest). Surfaces unresolved cases in `.planning/INGEST-CONFLICTS.md` with three buckets: auto-resolved, competing-variants, unresolved-blockers. The BLOCKER gate from the shared conflict engine prevents any destination file from being written when unresolved contradictions exist.
+
+**Inputs:** directory-convention discovery (`docs/adr/`, `docs/prd/`, `docs/specs/`, `docs/rfc/`, root-level `{ADR,PRD,SPEC,RFC}-*.md`), or an explicit `--manifest <file>` YAML listing `{path, type, precedence?}` per doc.
+
+**v1 constraints:** hard cap of 50 docs per invocation; `--resolve interactive` is reserved for a future release.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/ingest-docs.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/gate-prompts.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/doc-conflict-engine.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the ingest-docs workflow end-to-end. Preserve all approval gates (discovery, conflict report, routing) and the BLOCKER safety rule.
+</process>

.opencode/command/gsd-manager.md

@@ -0,0 +1,44 @@
+---
+description: Interactive command center for managing multiple phases from one terminal
+argument-hint: "[--analyze-deps]"
+requires: [phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  skill: true
+  agent: true
+---
+<objective>
+Single-terminal command center for managing a milestone. Shows a dashboard of all phases with visual status indicators, recommends optimal next actions, and dispatches work — discuss runs inline, plan/execute run as background agents.
+
+Designed for power users who want to parallelize work across phases from one terminal: discuss a phase while another plans or executes in the background.
+
+**Creates/Updates:**
+- No files created directly — dispatches to existing GSD commands via Skill() and background Task agents.
+- Reads `.planning/STATE.md`, `.planning/ROADMAP.md`, phase directories for status.
+
+**After:** User exits when done managing, or all phases complete and milestone lifecycle is suggested.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/manager.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+No arguments required. Requires an active milestone with ROADMAP.md and STATE.md.
+
+Project context, phase list, dependencies, and recommendations are resolved inside the workflow using `gsd-tools query init.manager`. No upfront context loading needed.
+</context>
+
+<process>
+If `--analyze-deps` is in $ARGUMENTS:
+Read and execute `/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/analyze-dependencies.md` end-to-end.
+
+Execute end-to-end.
+Maintain the dashboard refresh loop until the user exits or all phases complete.
+</process>

.opencode/command/gsd-map-codebase.md

@@ -0,0 +1,82 @@
+---
+description: Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
+argument-hint: "[--fast [--focus tech|arch|quality|concerns]] [--query <term>|status|diff|refresh] [area]"
+requires: [config, new-project, plan-phase]
+tools:
+  read: true
+  bash: true
+  glob: true
+  grep: true
+  write: true
+  agent: true
+---
+
+<objective>
+Analyze existing codebase using parallel gsd-codebase-mapper agents to produce structured codebase documents.
+
+Each mapper agent explores a focus area and **writes documents directly** to `.planning/codebase/`. The orchestrator only receives confirmations, keeping context usage minimal.
+
+Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/map-codebase.md
+</execution_context>
+
+<flags>
+- **--fast**: Lightweight scan mode — spawns one mapper agent instead of four. Accepts an optional `--focus` value: `tech`, `arch`, `quality`, `concerns`, or `tech+arch` (default). Faster and lower-context than the full map.
+- **--query**: Codebase intelligence query mode. Sub-commands: `query <term>`, `status`, `diff`, `refresh`. Requires intel to be enabled in config (`intel.enabled: true`). Runs inline for query/status/diff; spawns an agent for refresh.
+- **(no flag)**: Full parallel map — spawns 4 mapper agents to produce all 7 codebase documents.
+</flags>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--fast`: strip the flag, run the scan workflow (passing remaining args including optional --focus).
+- If it is `--query`: strip the flag, run the intel workflow (passing remaining args as the subcommand).
+- Otherwise: pass all of $ARGUMENTS as focus area to the map-codebase workflow.
+
+**Load project state if exists:**
+Check for .planning/STATE.md - loads context if project already initialized
+
+**This command can run:**
+- Before /gsd-new-project (brownfield codebases) - creates codebase map first
+- After /gsd-new-project (greenfield codebases) - updates codebase map as code evolves
+- Anytime to refresh codebase understanding
+</context>
+
+<when_to_use>
+**Use map-codebase for:**
+- Brownfield projects before initialization (understand existing code first)
+- Refreshing codebase map after significant changes
+- Onboarding to an unfamiliar codebase
+- Before major refactoring (understand current state)
+- When STATE.md references outdated codebase info
+
+**Skip map-codebase for:**
+- Greenfield projects with no code yet (nothing to map)
+- Trivial codebases (<5 files)
+</when_to_use>
+
+<process>
+1. Check if .planning/codebase/ already exists (offer to refresh or skip)
+2. Create .planning/codebase/ directory structure
+3. Spawn 4 parallel gsd-codebase-mapper agents:
+   - Agent 1: tech focus → writes STACK.md, INTEGRATIONS.md
+   - Agent 2: arch focus → writes ARCHITECTURE.md, STRUCTURE.md
+   - Agent 3: quality focus → writes CONVENTIONS.md, TESTING.md
+   - Agent 4: concerns focus → writes CONCERNS.md
+4. Wait for agents to complete, collect confirmations (NOT document contents)
+5. Verify all 7 documents exist with line counts
+6. Commit codebase map
+7. Offer next steps (typically: /gsd-new-project or /gsd-plan-phase)
+</process>
+
+<success_criteria>
+- [ ] .planning/codebase/ directory created
+- [ ] All 7 codebase documents written by mapper agents
+- [ ] Documents follow template structure
+- [ ] Parallel agents completed without errors
+- [ ] User knows next steps
+</success_criteria>

.opencode/command/gsd-mempalace-capture.md

@@ -0,0 +1,70 @@
+---
+description: "File a phase artifact into MemPalace; mirror decision facts into its temporal KG"
+argument-hint: "[CONTEXT.md|PLAN.md|SUMMARY.md]"
+requires: [config]
+tools:
+  read: true
+  bash: true
+---
+
+**STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by the command system. Using the Read tool on this file wastes tokens. Begin executing Step 0 immediately.**
+
+## Step 0 -- Banner
+
+**Before ANY tool calls**, display this banner:
+
+```
+GSD > MEMPALACE CAPTURE
+```
+
+Then proceed to Step 1.
+
+## Step 1 -- Config Gate
+
+Check whether the MemPalace capability is enabled by reading `.planning/config.json` directly with the Read tool.
+
+1. Read `.planning/config.json` with the Read tool.
+2. If the file does not exist, or `config.mempalace` is absent, or `config.mempalace.enabled !== true`, or `config.mempalace.capture_artifacts !== true`: display the disabled message and **STOP**.
+3. Otherwise proceed to Step 2.
+
+**Disabled message:**
+
+```
+GSD > MEMPALACE CAPTURE
+
+MemPalace capture is disabled (mempalace.enabled / mempalace.capture_artifacts).
+Nothing was filed; the loop proceeds normally.
+```
+
+This step is `onError: skip` at `discuss:post` / `plan:post` / `verify:post` -- capture never fails a phase.
+
+## Step 2 -- Resolve target
+
+1. **Artifact.** Take the artifact from `$ARGUMENTS`. If absent, infer from the loop point: `discuss:post` → `CONTEXT.md`, `plan:post` → `PLAN.md`, `verify:post` → `SUMMARY.md`.
+2. **Room.** Map artifact → room:
+   - `CONTEXT.md` → `decisions`
+   - `PLAN.md` → `planning`
+   - `SUMMARY.md` → `milestones`
+   (Confirmed problem→fix pairs go to `problems` — see the `capture-problems` fragment used at `execute:wave:post`.)
+3. **Wing.** `config.mempalace.wing` if non-empty, else `config.project_code`, else the repo directory name.
+4. **Mode / transport.** Read `config.mempalace.memory_mode`. Prefer MCP (`mempalace_*`) when your MemPalace MCP server is registered and your runtime permits those tools; otherwise use the `mempalace` CLI (covered by this skill's `Bash` allow-tool), as in `mempalace-recall`.
+
+## Step 3 -- File verbatim (idempotent)
+
+On any error or timeout, stop and let the phase continue -- capture is best-effort.
+
+1. **Dedup first.** Interactive: `mempalace_check_duplicate` on the artifact's deterministic drawer id. Headless: rely on `mempalace mine`'s content-hash idempotency.
+2. **Add the drawer (verbatim).** File the exact artifact text into `room: <room>` of `wing: <wing>` with provenance (`source_file`, phase id). Interactive: `mempalace_add_drawer`. Headless: `mempalace mine <path> --wing <wing> --room <room>`.
+3. **Mirror KG facts** when `config.mempalace.mirror_kg` is true: extract decision/delivery facts and `mempalace_kg_add` them with `valid_from` = the phase date (e.g. `(<project>, decided, <decision>)` from CONTEXT; `(<phase>, delivered, <capability>)` from SUMMARY). Only `augment` is currently wired, so these are an *additive* mirror of `.planning/graphs/`. (`kg_backend`/`replace` are forward-declared and behave as `augment` today.)
+4. Re-running a phase MUST NOT create duplicate drawers (deterministic ids + `check_duplicate`).
+
+## Step 4 -- Report
+
+Print a one-line summary: `Filed <artifact> → <wing>/<room> (<n> KG facts)` or `MemPalace unavailable — capture skipped`.
+
+## Anti-Patterns
+
+1. DO NOT let any MemPalace error fail the step -- capture is `onError: skip`.
+2. DO NOT write lossy summaries -- store the verbatim artifact text (AAAK compression is a separate, optional index).
+3. DO NOT prune or delete drawers here -- pruning (`sync --apply`) is the curator agent's job at `ship:post`, wing-scoped only.
+4. DO NOT skip the config gate or the dedup check.

.opencode/command/gsd-mempalace-recall.md

@@ -0,0 +1,101 @@
+---
+description: "Recall decisions, patterns, and surprises from MemPalace before planning"
+argument-hint: "[phase-slug]"
+requires: [config]
+tools:
+  read: true
+  write: true
+  bash: true
+---
+
+**STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by the command system. Using the Read tool on this file wastes tokens. Begin executing Step 0 immediately.**
+
+## Step 0 -- Banner
+
+**Before ANY tool calls**, display this banner:
+
+```
+GSD > MEMPALACE RECALL
+```
+
+Then proceed to Step 1.
+
+## Step 1 -- Config Gate
+
+Check whether the MemPalace capability is enabled by reading `.planning/config.json` directly with the Read tool.
+
+**DO NOT use `gsd-tools config get-value`** -- it hard-exits on missing keys.
+
+1. Read `.planning/config.json` with the Read tool.
+2. If the file does not exist: write the "unavailable" stub (Step 4) and **STOP**.
+3. Parse the JSON. Proceed to Step 2 only if `config.mempalace && config.mempalace.enabled === true` **and** `config.mempalace.recall_on_plan !== false`. Otherwise display the disabled message and **STOP** (`recall_on_plan: false` turns plan-time recall off while leaving the rest of the capability enabled).
+
+**Disabled message:**
+
+```
+GSD > MEMPALACE RECALL
+
+MemPalace memory is disabled. To activate:
+
+  node <runtime-home>/gsd-core/bin/gsd-tools.cjs config-set mempalace.enabled true
+
+Recall is opt-in; the loop proceeds normally without it.
+```
+
+This step is `onError: skip` at `plan:pre` -- recall never blocks planning.
+
+## Step 2 -- Resolve wing, mode, and transport
+
+1. **Wing.** Use `config.mempalace.wing` if non-empty; otherwise derive from `config.project_code`; otherwise fall back to the repository directory name.
+2. **Mode.** Read `config.mempalace.memory_mode` (`augment` | `kg_backend` | `replace`, default `augment`). Only `augment` is wired today, so recall always treats the palace as additive; `kg_backend`/`replace` are forward-declared and behave as `augment`.
+3. **Transport.** Prefer the **MCP tools** (`mempalace_*`) in interactive runs *when your MemPalace MCP server is registered and your runtime permits those tools*. Otherwise — headless/cron/autonomous runs, or runtimes that don't grant the MemPalace MCP tools — use the **CLI** (`mempalace wake-up`, `mempalace search`), which this skill's `Bash` allow-tool always covers. If neither is reachable, go to Step 4.
+4. **Topic.** Read the phase `CONTEXT.md` (the consumed artifact). Derive a short search query from its title, goal, and key decisions.
+
+## Step 3 -- Retrieve (read-only)
+
+All calls in this step are side-effect-free. On any error or timeout, stop retrieving and write whatever was gathered (or the stub) -- never raise.
+
+1. **Wake up** (cheap, ~600--900 tokens):
+   - Interactive: read the wing identity/summary, then `mempalace_search`.
+   - Headless: `mempalace wake-up --wing <wing>`.
+2. **Targeted search:**
+   - Interactive: `mempalace_search(query=<topic>, wing=<wing>)`.
+   - Headless: `mempalace search "<topic>" --wing <wing>`.
+3. **Knowledge-graph facts** (when `config.mempalace.mirror_kg` is true): `mempalace_kg_query` / `mempalace_kg_timeline` for decisions relevant to the topic and their validity windows. Only `augment` is currently wired, so the palace KG *supplements* GSD's native `.planning/graphs/` — do not treat it as the sole source. (`kg_backend`/`replace` are forward-declared and behave as `augment` today.)
+4. **Dedup** the returned drawers/facts; keep the top results.
+
+## Step 4 -- Write MEMORY-RECALL.md
+
+Write `MEMORY-RECALL.md` in the current phase directory. The planner consumes it.
+
+When recall succeeded, structure it as:
+
+```markdown
+# Memory Recall (MemPalace)
+
+_Wing: <wing> · Mode: <mode> · Transport: <mcp|cli>_
+
+## Prior decisions
+- <decision> — <provenance: drawer id / kg fact, valid_from>
+
+## Patterns
+- <pattern> — <provenance>
+
+## Surprises / gotchas
+- <surprise> — <provenance>
+```
+
+When MemPalace is unreachable, write the stub and continue:
+
+```markdown
+# Memory Recall (MemPalace)
+
+_MemPalace unavailable at recall time — proceeding without recalled memory._
+```
+
+## Anti-Patterns
+
+1. DO NOT let any MemPalace error fail the step -- recall is `onError: skip`.
+2. DO NOT write to the palace from this skill -- recall is read-only; capture is a separate skill.
+3. DO NOT paste raw search output into the file -- distil to decisions/patterns/surprises with provenance.
+4. DO NOT skip the config gate.

.opencode/command/gsd-milestone-summary.md

@@ -0,0 +1,50 @@
+---
+type: prompt
+description: Generate a comprehensive project summary from milestone artifacts for team onboarding and review
+argument-hint: "[version]"
+tools:
+  read: true
+  write: true
+  bash: true
+  grep: true
+  glob: true
+---
+
+<objective>
+Generate a structured milestone summary for team onboarding and project review. Reads completed milestone artifacts (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION files) and produces a human-friendly overview of what was built, how, and why.
+
+Purpose: Enable new team members to understand a completed project by reading one document and asking follow-up questions.
+Output: MILESTONE_SUMMARY written to `.planning/reports/`, presented inline, optional interactive Q&A.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/milestone-summary.md
+</execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/PROJECT.md`
+- `.planning/STATE.md`
+- `.planning/RETROSPECTIVE.md`
+- `.planning/milestones/v{version}-ROADMAP.md` (if archived)
+- `.planning/milestones/v{version}-REQUIREMENTS.md` (if archived)
+- `.planning/phases/*-*/` (SUMMARY.md, VERIFICATION.md, CONTEXT.md, RESEARCH.md)
+
+**User input:**
+- Version: $ARGUMENTS (optional — defaults to current/latest milestone)
+</context>
+
+<process>
+Execute end-to-end.
+</process>
+
+<success_criteria>
+- Milestone version resolved (from args, STATE.md, or archive scan)
+- All available artifacts read (ROADMAP, REQUIREMENTS, CONTEXT, SUMMARY, VERIFICATION, RESEARCH, RETROSPECTIVE)
+- Summary document written to `.planning/reports/MILESTONE_SUMMARY-v{version}.md`
+- All 7 sections generated (Overview, Architecture, Phases, Decisions, Requirements, Tech Debt, Getting Started)
+- Summary presented inline to user
+- Interactive Q&A offered
+- STATE.md updated
+</success_criteria>

.opencode/command/gsd-mvp-phase.md

@@ -0,0 +1,44 @@
+---
+description: Plan a phase as a vertical MVP slice — user story, SPIDR splitting, then plan-phase
+argument-hint: "<phase-number>"
+requires: [new-project, phase, plan-phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  question: true
+---
+<objective>
+Guide the user through MVP-mode planning for a phase. The command:
+
+1. Prompts for an "As a / I want to / So that" user story (three structured questions)
+2. Runs SPIDR splitting check — if the story is too large, walks through Spike/Paths/Interfaces/Data/Rules and offers to split into multiple phases
+3. Writes `**Mode:** mvp` and the reformatted `**Goal:**` to the phase's ROADMAP.md section
+4. Delegates to `/gsd plan-phase <N>` which auto-detects MVP mode via the roadmap field
+
+Phase 1 of the vertical-mvp-slice PRD shipped the planner-side machinery; this command is the user entry point for it.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/mvp-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/spidr-splitting.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/user-story-template.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. Equivalent API.
+</runtime_note>
+
+<context>
+Phase number: $ARGUMENTS (required — integer or decimal like `2.1`)
+
+The phase must already exist in ROADMAP.md (created via `/gsd new-project`, `/gsd add-phase`, or `/gsd insert-phase`). This command does not create new phases — it converts an existing phase to MVP mode.
+</context>
+
+<process>
+Execute the mvp-phase workflow from @/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/mvp-phase.md end-to-end.
+Preserve all gates: phase existence, status guard (refuse in_progress/completed), user-story format validation, SPIDR splitting check, ROADMAP write confirmation, plan-phase delegation.
+</process>

.opencode/command/gsd-new-milestone.md

@@ -0,0 +1,44 @@
+---
+description: Start a new milestone cycle — update PROJECT.md and route to requirements
+argument-hint: "[milestone name, e.g., 'v1.1 Notifications']"
+requires: [new-project, phase, plan-phase]
+tools:
+  read: true
+  write: true
+  bash: true
+  agent: true
+  question: true
+---
+<objective>
+Start a new milestone: questioning → research (optional) → requirements → roadmap.
+
+Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
+
+**Creates/Updates:**
+- `.planning/PROJECT.md` — updated with new milestone goals
+- `.planning/research/` — domain research (optional, NEW features only)
+- `.planning/REQUIREMENTS.md` — scoped requirements for this milestone
+- `.planning/ROADMAP.md` — phase structure (continues numbering)
+- `.planning/STATE.md` — reset for new milestone
+
+**After:** `/gsd-plan-phase [N]` to start execution.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/new-milestone.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/questioning.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/templates/project.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/templates/requirements.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+Project and milestone context files are resolved inside the workflow (`init new-milestone`) and delegated via `<files_to_read>` blocks where subagents are used.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (validation, questioning, research, requirements, roadmap approval, commits).
+</process>

.opencode/command/gsd-new-project.md

@@ -0,0 +1,46 @@
+---
+description: Initialize a new project with deep context gathering and PROJECT.md
+argument-hint: "[--auto]"
+requires: [config, phase, plan-phase]
+tools:
+  read: true
+  bash: true
+  write: true
+  agent: true
+  question: true
+---
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API.
+</runtime_note>
+
+<context>
+**Flags:**
+- `--auto` — Automatic mode. After config questions, runs research → requirements → roadmap without further interaction. Expects idea document via @ reference.
+</context>
+
+<objective>
+Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.
+
+**Creates:**
+- `.planning/PROJECT.md` — project context
+- `.planning/config.json` — workflow preferences
+- `.planning/research/` — domain research (optional)
+- `.planning/REQUIREMENTS.md` — scoped requirements
+- `.planning/ROADMAP.md` — phase structure
+- `.planning/STATE.md` — project memory
+
+**After this command:** Run `/gsd-plan-phase 1` to start execution.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/new-project.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/questioning.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/templates/project.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/templates/requirements.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (validation, approvals, commits, routing).
+</process>

.opencode/command/gsd-ns-context.md

@@ -0,0 +1,24 @@
+---
+description: "codebase intel | map graphify docs learnings mempalace"
+argument-hint: ""
+requires: [map-codebase, graphify, docs-update, extract-learnings, mempalace-recall, mempalace-capture]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate codebase-intelligence skill based on the user's intent.
+`gsd-scan` and `gsd-intel` were folded into `gsd-map-codebase` flags by #2790.
+
+| User wants | Invoke |
+|---|---|
+| Map the full codebase structure | gsd-map-codebase |
+| Quick lightweight codebase scan | gsd-map-codebase --fast |
+| Query mapped intelligence files | gsd-map-codebase --query |
+| Generate a knowledge graph | gsd-graphify |
+| Update project documentation | gsd-docs-update |
+| Extract learnings from a completed phase | gsd-extract-learnings |
+| Recall prior decisions and patterns before planning | gsd-mempalace-recall |
+| File a phase artifact into MemPalace | gsd-mempalace-capture |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-ns-ideate.md

@@ -0,0 +1,23 @@
+---
+description: "exploration capture | explore sketch spike spec capture"
+argument-hint: ""
+requires: [capture, explore, sketch, spike, spec-phase]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate exploration / capture skill based on the user's intent.
+`gsd-note`, `gsd-add-todo`, `gsd-add-backlog`, and `gsd-plant-seed` were folded
+into `gsd-capture` (with `--note`, default, `--backlog`, `--seed` modes) by
+#2790. The capture target lists pending todos via `--list`.
+
+| User wants | Invoke |
+|---|---|
+| Explore an idea or opportunity | gsd-explore |
+| Sketch out a rough design or plan | gsd-sketch |
+| Time-boxed technical spike | gsd-spike |
+| Write a spec for a phase | gsd-spec-phase |
+| Capture a thought (todo / note / backlog / seed) | gsd-capture |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-ns-manage.md

@@ -0,0 +1,35 @@
+---
+description: "config workspace | workstreams thread update ship inbox"
+argument-hint: ""
+requires: [config, workspace, workstreams, thread, pause-work, resume-work, update, ship, inbox, pr-branch, undo, cleanup, health, manager, settings, stats, surface, help]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate management skill based on the user's intent.
+`gsd-config` (settings + advanced + integrations + profile) and `gsd-workspace`
+(new + list + remove) are post-#2790 consolidated entries.
+
+| User wants | Invoke |
+|---|---|
+| Configure GSD settings (basic / advanced / integrations / profile) | gsd-config |
+| Manage workspaces (create / list / remove) | gsd-workspace |
+| Manage parallel workstreams | gsd-workstreams |
+| Continue work in a fresh context thread | gsd-thread |
+| Pause current work | gsd-pause-work |
+| Resume paused work | gsd-resume-work |
+| Update the GSD installation | gsd-update |
+| Ship completed work | gsd-ship |
+| Process inbox items | gsd-inbox |
+| Create a clean PR branch | gsd-pr-branch |
+| Undo the last GSD action | gsd-undo |
+| Archive accumulated phase directories | gsd-cleanup |
+| Diagnose planning directory health | gsd-health |
+| Open the interactive command center | gsd-manager |
+| Configure workflow toggles and model profile | gsd-settings |
+| Show project statistics | gsd-stats |
+| Toggle which skills are surfaced | gsd-surface |
+| Show the GSD command guide | gsd-help |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-ns-project.md

@@ -0,0 +1,26 @@
+---
+description: "project lifecycle | milestones audits summary"
+argument-hint: ""
+requires: [new-project, new-milestone, complete-milestone, audit-milestone, milestone-summary, import, ingest-docs, profile-user, review-backlog]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate project / milestone skill based on the user's intent.
+`gsd-plan-milestone-gaps` was deleted by #2790 — gap planning now happens
+inline as part of `gsd-audit-milestone`'s output.
+
+| User wants | Invoke |
+|---|---|
+| Start a new project | gsd-new-project |
+| Create a new milestone | gsd-new-milestone |
+| Complete the current milestone | gsd-complete-milestone |
+| Audit a milestone for issues | gsd-audit-milestone |
+| Summarize milestone status | gsd-milestone-summary |
+| Import an external plan | gsd-import |
+| Bootstrap planning from existing docs | gsd-ingest-docs |
+| Generate a developer profile | gsd-profile-user |
+| Review and promote backlog items | gsd-review-backlog |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-ns-review.md

@@ -0,0 +1,28 @@
+---
+description: "quality gates | code review debug audit security eval ui"
+argument-hint: ""
+requires: [code-review, audit-uat, secure-phase, eval-review, ui-review, validate-phase, debug, forensics, audit-fix, review, ui-phase]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate quality / review skill based on the user's intent.
+`gsd-code-review-fix` was absorbed by `gsd-code-review --fix` in #2790.
+
+| User wants | Invoke |
+|---|---|
+| Review code for quality and correctness | gsd-code-review |
+| Auto-fix code review findings | gsd-code-review --fix |
+| Audit UAT / acceptance testing | gsd-audit-uat |
+| Security review of a phase | gsd-secure-phase |
+| Evaluate AI response quality | gsd-eval-review |
+| Review UI for design and accessibility | gsd-ui-review |
+| Validate phase outputs | gsd-validate-phase |
+| Debug a failing feature or error | gsd-debug |
+| Forensic investigation of a broken system | gsd-forensics |
+| Autonomous audit-to-fix pipeline | gsd-audit-fix |
+| Cross-AI peer review of plans | gsd-review |
+| Generate a UI design contract | gsd-ui-phase |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-ns-workflow.md

@@ -0,0 +1,33 @@
+---
+description: "workflow | discuss plan execute verify phase progress"
+argument-hint: ""
+requires: [discuss-phase, spec-phase, plan-phase, execute-phase, verify-work, phase, progress, ultraplan-phase, plan-review-convergence, add-tests, ai-integration-phase, autonomous, fast, mvp-phase, quick]
+tools:
+  read: true
+  skill: true
+---
+
+Route to the appropriate phase-pipeline skill based on the user's intent.
+Sub-skill names below are post-#2790 consolidated targets — `gsd-phase`
+absorbs the former add/insert/remove/edit-phase commands and `gsd-progress`
+absorbs the former next/do commands.
+
+| User wants | Invoke |
+|---|---|
+| Gather context before planning | gsd-discuss-phase |
+| Clarify what a phase delivers | gsd-spec-phase |
+| Create a PLAN.md | gsd-plan-phase |
+| Execute plans in a phase | gsd-execute-phase |
+| Verify built features through UAT | gsd-verify-work |
+| Add / insert / remove / edit a phase | gsd-phase |
+| Advance to the next logical step | gsd-progress |
+| Offload planning to the ultraplan cloud | gsd-ultraplan-phase |
+| Cross-AI plan review convergence loop | gsd-plan-review-convergence |
+| Generate tests for a completed phase | gsd-add-tests |
+| Design an AI-integration phase | gsd-ai-integration-phase |
+| Run all remaining phases autonomously | gsd-autonomous |
+| Execute a trivial task inline | gsd-fast |
+| Plan a phase as a vertical MVP slice | gsd-mvp-phase |
+| Execute a quick task with GSD guarantees | gsd-quick |
+
+Invoke the matched skill directly using the Skill tool.

.opencode/command/gsd-pause-work.md

@@ -0,0 +1,42 @@
+---
+description: Create context handoff when pausing work mid-phase
+argument-hint: "[--report]"
+requires: [phase, progress]
+tools:
+  read: true
+  write: true
+  bash: true
+---
+
+<objective>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions.
+
+Routes to the pause-work workflow which handles:
+- Current phase detection from recent files
+- Complete state gathering (position, completed work, remaining work, decisions, blockers)
+- Handoff file creation with all context sections
+- Git commit as WIP
+- Resume instructions
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/pause-work.md
+</execution_context>
+
+<context>
+State and phase progress are gathered in-workflow with targeted reads.
+</context>
+
+<process>
+If `--report` is in $ARGUMENTS:
+Read and execute `/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/session-report.md` end-to-end.
+
+**Follow the pause-work workflow**.
+
+The workflow handles all logic including:
+1. Phase directory detection
+2. State gathering with user clarifications
+3. Handoff file writing with timestamp
+4. Git commit
+5. Confirmation with resume instructions
+</process>

.opencode/command/gsd-phase.md

@@ -0,0 +1,55 @@
+---
+description: CRUD for phases in ROADMAP.md — add, insert, remove, or edit phases
+argument-hint: "[--insert | --remove | --edit] <phase-name-or-number>"
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+---
+
+<objective>
+Manage phases in ROADMAP.md with a single consolidated command.
+
+Mode routing:
+- **default** (no flag): Add a new integer phase to the end of the current milestone → add-phase workflow
+- **--insert**: Insert urgent work as a decimal phase (e.g., 72.1) between existing phases → insert-phase workflow
+- **--remove**: Remove a future phase and renumber subsequent phases → remove-phase workflow
+- **--edit**: Edit any field of an existing phase in place → edit-phase workflow
+</objective>
+
+<routing>
+
+| Flag | Action | Workflow |
+|------|--------|----------|
+| (none) | Add new integer phase at end of milestone | add-phase |
+| --insert | Insert decimal phase (e.g., 72.1) after specified phase | insert-phase |
+| --remove | Remove future phase, renumber subsequent | remove-phase |
+| --edit | Edit fields of existing phase in place | edit-phase |
+
+</routing>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/add-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/insert-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/remove-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/edit-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Parse the first token of $ARGUMENTS:
+- If it is `--insert`: strip the flag, pass remainder (format: <after-phase-number> <description>) to insert-phase workflow
+- If it is `--remove`: strip the flag, pass remainder (phase number) to remove-phase workflow
+- If it is `--edit`: strip the flag, pass remainder (phase-number [--force]) to edit-phase workflow
+- Otherwise: pass all of $ARGUMENTS (phase description) to add-phase workflow
+
+Roadmap and state are resolved in-workflow via `init phase-op` and targeted reads.
+</context>
+
+<process>
+1. Parse the leading flag (if any) from $ARGUMENTS.
+2. Load and execute the appropriate workflow end-to-end based on the routing table above.
+3. Preserve all validation gates from the target workflow.
+</process>

.opencode/command/gsd-plan-phase.md

@@ -0,0 +1,62 @@
+---
+description: Create detailed phase plan (PLAN.md) with verification loop
+argument-hint: "[phase] [--auto] [--research] [--skip-research] [--research-phase <N>] [--view] [--gaps] [--skip-verify] [--prd <file>] [--ingest <path-or-glob>] [--ingest-format <auto|nygard|madr|narrative>] [--reviews] [--text] [--tdd] [--mvp]"
+effort: max
+requires: [discuss-phase, phase, review, update]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  question: true
+  webfetch: true
+  mcp__context7__*: true
+---
+<objective>
+Create executable phase prompts (PLAN.md files) for a roadmap phase with integrated research and verification.
+
+**Default flow:** Research (if needed) → Plan → Verify → Done
+
+**Research-only mode (`--research-phase <N>`):** Spawn `gsd-phase-researcher` for phase `N`, write `RESEARCH.md`, then exit before the planner runs. Useful for cross-phase research, doc review before committing to a planning approach, and correction-without-replanning loops where iterating on research alone is dramatically cheaper than re-spawning the planner. Replaces the deleted research-phase command (#3042).
+
+**Research-only modifiers:**
+- **No flag** — when `RESEARCH.md` already exists, auto-uses it: emits a one-line notice and exits cleanly, no prompt.
+- **`--research`** — force-refresh: re-spawn the researcher unconditionally, no prompt. Bypasses the existing-RESEARCH.md auto-use path.
+- **`--view`** — view-only: print existing `RESEARCH.md` to stdout. Does not spawn the researcher. Cheapest mode for the correction-without-replanning loop. If no `RESEARCH.md` exists yet, errors with a hint to drop `--view`.
+
+**Orchestrator role:** Parse arguments, validate phase, research domain (unless skipped), spawn gsd-planner, verify with gsd-plan-checker, iterate until pass or max iterations, present results.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/plan-phase.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API. Do not skip questioning steps because `question` appears unavailable; use `vscode_askquestions` instead.
+</runtime_note>
+
+<context>
+Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omitted)
+
+**Flags:**
+- `--research` — Force re-research even if RESEARCH.md exists
+- `--skip-research` — Skip research, go straight to planning
+- `--gaps` — Gap closure mode (reads VERIFICATION.md, skips research)
+- `--skip-verify` — Skip verification loop
+- `--prd <file>` — Use a PRD/acceptance criteria file instead of discuss-phase. Parses requirements into CONTEXT.md automatically. Skips discuss-phase entirely.
+- `--ingest <path-or-glob>` — Use one or more ADR files instead of discuss-phase. Parses locked decisions + scope fences into CONTEXT.md automatically. Skips discuss-phase entirely.
+- `--ingest-format <auto|nygard|madr|narrative>` — Optional ADR parser format override (`auto` default).
+- `--reviews` — Replan incorporating cross-AI review feedback from REVIEWS.md (produced by `/gsd-review`)
+- `--text` — Use plain-text numbered lists instead of TUI menus (required for `/rc` remote sessions)
+- `--mvp` — Vertical MVP mode. Planner organizes tasks as feature slices (UI→API→DB) instead of horizontal layers. On Phase 1 of a new project, also emits `SKELETON.md` (Walking Skeleton). Can be persisted on a phase via `**Mode:** mvp` in ROADMAP.md.
+
+Normalize phase input in step 2 before any directory lookups.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (validation, research, planning, verification loop, routing).
+</process>

.opencode/command/gsd-plan-review-convergence.md

@@ -0,0 +1,59 @@
+---
+description: "Cross-AI plan convergence - replan until review concerns are resolved."
+argument-hint: "<phase> [--codex] [--gemini] [--claude] [--opencode] [--ollama] [--lm-studio] [--llama-cpp] [--text] [--ws <name>] [--all] [--max-cycles N]"
+requires: [phase, review]
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  agent: true
+  skill: true
+  question: true
+---
+
+<objective>
+Cross-AI plan convergence loop — an outer revision gate around gsd-review and gsd-planner.
+Repeatedly: review plans with external AI CLIs → if HIGH or actionable non-HIGH concerns remain → replan with --reviews feedback → re-review. Stops when no unresolved HIGH concerns or actionable MEDIUM/LOW findings remain outside PLAN.md, or when max cycles is reached.
+
+**Flow:** Skill("gsd-plan-phase") → Agent→Skill("gsd-review") → check unresolved HIGH + actionable non-HIGH → Skill("gsd-plan-phase --reviews") → Agent→Skill("gsd-review") → ... → Converge or escalate
+
+Replaces gsd-plan-phase's internal gsd-plan-checker with external AI reviewers (codex, gemini, etc.). Plan-phase runs **inline** (bare Skill at depth 0) so it can spawn gsd-planner/gsd-plan-checker at depth 1. Review runs inside an isolated Agent (gsd-review is a Bash leaf — no sub-agents needed). Orchestrator only does loop control.
+
+**Orchestrator role:** Parse arguments, validate phase, run plan-phase inline (Skill at depth 0), spawn an Agent for gsd-review, check unresolved HIGH and actionable non-HIGH counts, stall detection, escalation gate.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/plan-review-convergence.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/revision-loop.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/gates.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/agent-contracts.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `question`. They are equivalent — `vscode_askquestions` is the VS Code Copilot implementation of the same interactive question API. Do not skip questioning steps because `question` appears unavailable; use `vscode_askquestions` instead.
+</runtime_note>
+
+<context>
+Phase number: extracted from $ARGUMENTS (required)
+
+**Flags:**
+- `--codex` — Use Codex CLI as reviewer (default if no reviewer specified)
+- `--gemini` — Use Gemini CLI as reviewer
+- `--claude` — Use the agent CLI as reviewer (separate session)
+- `--opencode` — Use OpenCode as reviewer
+- `--ollama` — Use local Ollama server as reviewer (OpenAI-compatible, default host `http://localhost:11434`; configure model via `review.models.ollama`)
+- `--lm-studio` — Use local LM Studio server as reviewer (OpenAI-compatible, default host `http://localhost:1234`; configure model via `review.models.lm_studio`)
+- `--llama-cpp` — Use local llama.cpp server as reviewer (OpenAI-compatible, default host `http://localhost:8080`; configure model via `review.models.llama_cpp`)
+- `--all` — Use all available CLIs and running local model servers
+- `--max-cycles N` — Maximum replan→review cycles (default: 3)
+
+**Feature gate:** This command requires `workflow.plan_review_convergence=true`. Enable with:
+`gsd config-set workflow.plan_review_convergence true`
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (pre-flight, revision loop, stall detection, escalation).
+</process>

.opencode/command/gsd-pr-branch.md

@@ -0,0 +1,25 @@
+---
+description: Create a clean PR branch by filtering out .planning/ commits — ready for code review
+argument-hint: "[target branch, default: main]"
+requires: [review]
+tools:
+  bash: true
+  read: true
+  question: true
+---
+
+<objective>
+Create a clean branch suitable for pull requests by filtering out .planning/ commits
+from the current branch. Reviewers see only code changes, not GSD planning artifacts.
+
+This solves the problem of PR diffs being cluttered with PLAN.md, SUMMARY.md, STATE.md
+changes that are irrelevant to code review.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/pr-branch.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

.opencode/command/gsd-profile-user.md

@@ -0,0 +1,45 @@
+---
+description: Generate developer behavioral profile and create Claude-discoverable artifacts
+argument-hint: "[--questionnaire] [--refresh]"
+tools:
+  read: true
+  write: true
+  bash: true
+  glob: true
+  grep: true
+  question: true
+  agent: true
+---
+
+<objective>
+Generate a developer behavioral profile from session analysis (or questionnaire) and produce artifacts (USER-PROFILE.md, `gsd-dev-preferences` skill config, AGENTS.md section) that personalize the agent's responses.
+
+Routes to the profile-user workflow which orchestrates the full flow: consent gate, session analysis or questionnaire fallback, profile generation, result display, and artifact selection.
+</objective>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/profile-user.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Flags from $ARGUMENTS:
+- `--questionnaire` -- Skip session analysis entirely, use questionnaire-only path
+- `--refresh` -- Rebuild profile even when one exists, backup old profile, show dimension diff
+</context>
+
+<process>
+Execute the profile-user workflow end-to-end.
+
+The workflow handles all logic including:
+1. Initialization and existing profile detection
+2. Consent gate before session analysis
+3. Session scanning and data sufficiency checks
+4. Session analysis (profiler agent) or questionnaire fallback
+5. Cross-project split resolution
+6. Profile writing to USER-PROFILE.md
+7. Result display with report card and highlights
+8. Artifact selection (dev-preferences, AGENTS.md sections)
+9. Sequential artifact generation
+10. Summary with refresh diff (if applicable)
+</process>

.opencode/command/gsd-progress.md

@@ -0,0 +1,48 @@
+---
+description: Check progress, advance workflow, or dispatch freeform intent — the unified GSD situational command
+argument-hint: "[--forensic | --next [--auto] [--converge] | --do \"task description\"]"
+effort: low
+requires: [phase]
+tools:
+  read: true
+  bash: true
+  grep: true
+  glob: true
+  skill: true
+  question: true
+---
+<objective>
+Check project progress, summarize recent work and what's ahead, then intelligently route to the next action.
+
+Three modes:
+- **default**: Show progress report + intelligently route to the next action (execute or plan). Provides situational awareness before continuing work.
+- **--next**: Automatically advance to the next logical step without manual route selection. Reads STATE.md, ROADMAP.md, and phase directories. Supports `--force` to bypass safety gates.
+- **--do "task description"**: Analyze freeform natural language and dispatch to the most appropriate GSD command. Never does the work itself — matches intent, confirms, hands off.
+- **--forensic**: Append a 6-check integrity audit after the standard progress report.
+</objective>
+
+<flags>
+- **--next**: Detect current project state and automatically invoke the next logical GSD workflow step. Scans all prior phases for incomplete work before routing. `--next --force` bypasses safety gates.
+- **--next --auto**: Like `--next`, but after the determined step completes, automatically re-invokes `/gsd-progress --next --auto` to continue chaining steps until completion or a blocking decision. Enables hands-free plan→execute→verify→complete progression.
+- **--next --converge**: When the next action is planning (Route 3), route it through the plan-review **convergence** loop instead of the standard planner. Requires `workflow.plan_review_convergence=true` (enable with `gsd config-set workflow.plan_review_convergence true`). `--cross-ai` is an alias. Reviewer flags (`--codex`, `--gemini`, `--claude`, `--opencode`, `--ollama`, `--lm-studio`, `--llama-cpp`, `--all`) and `--max-cycles N` are forwarded to the convergence loop.
+- **--do "..."**: Smart dispatcher — match freeform intent to the best GSD command using routing rules, confirm the match, then hand off.
+- **--forensic**: Run 6-check integrity audit after the standard progress report.
+- **(no flag)**: Standard progress check + intelligent routing (Routes A through F).
+</flags>
+
+<execution_context>
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/progress.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/next.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/workflows/do.md
+@/Users/theogengineer/Projects/Multilingual-Absa/.opencode/gsd-core/references/ui-brand.md
+</execution_context>
+
+<process>
+Arguments provided: "$ARGUMENTS"
+Parse the first token from the provided arguments:
+- If it is `--next`: strip the flag, execute the next workflow (passing remaining args e.g. --force, --auto).
+- If it is `--do`: strip the flag, pass remainder as freeform intent to the do workflow.
+- Otherwise: execute the progress workflow end-to-end (pass --forensic through if present).
+
+Preserve all routing logic from the target workflow.
+</process>