@jokerized/getresearchdone 0.4.1

package/commands/feasibility.md

@@ -0,0 +1,292 @@
+---
+description: Analyze paper-to-production gap for a specific approach — dependencies, scale, licensing, infra
+argument-hint: <method name, paper title, or URL>
+---
+
+<purpose>
+Analyze the gap between a research paper/method and production deployment. Evaluates
+dependencies, scaling characteristics, licensing constraints, infrastructure requirements,
+and engineering effort. Produces a structured feasibility report and updates KNOWHOW.md
+with production engineering knowledge.
+</purpose>
+
+<context>
+CLAUDE.md rules: @CLAUDE.md
+
+**Research directory structure** (paths resolved via init):
+- `${research_dir}/LANDSCAPE.md` — survey landscape
+- `${research_dir}/deep-dives/` — paper analyses (may have relevant deep-dive)
+- `.planning/KNOWHOW.md` — accumulated production engineering knowledge
+- `.planning/BASELINE.md` — current system baseline (if assessed)
+- `.planning/config.json` — GRD configuration
+
+**Agent available:**
+- `grd-feasibility-analyst` — specialized agent for paper-to-production gap analysis
+</context>
+
+<process>
+
+## Step 0: INITIALIZE — Load Method Context
+
+0. **Run initialization**:
+   ```bash
+   INIT=$(node ${CLAUDE_PLUGIN_ROOT}/bin/grd-tools.js init feasibility "$APPROACH")
+   ```
+   Parse JSON for: `research_dir`, `landscape_exists`, `deep_dives`, `knowhow_exists`, `baseline_exists`, `autonomous_mode`, `research_gates`.
+
+1. **Parse arguments**: Extract method/paper reference from `$ARGUMENTS`
+   - If paper title or URL: resolve to method name
+   - If method name: look up in LANDSCAPE.md
+   - If empty: check for LANDSCAPE.md recommendation or recent deep-dive verdict of ADOPT/TRIAL
+
+2. **Gather existing research context**:
+   - Load LANDSCAPE.md entry for this method
+   - Load deep-dive analysis if available (`${research_dir}/deep-dives/{slug}.md`)
+   - Load BASELINE.md if available (current system capabilities)
+   - Load existing KNOWHOW.md entries (prior production knowledge)
+
+3. **Gather codebase context**:
+   - Read project's dependency manifest (package.json, requirements.txt, Cargo.toml, etc.)
+   - Identify current tech stack, frameworks, deployment target
+   - Note existing infrastructure constraints
+
+4. **Read config**: Check `research_gates.feasibility_approval`
+
+**STEP_0_CHECKPOINT:**
+- [ ] Method identified with paper reference
+- [ ] Deep-dive loaded (or noted as unavailable)
+- [ ] Current tech stack identified
+- [ ] KNOWHOW.md context loaded
+
+---
+
+## Step 1: DISPLAY BANNER
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  GRD >>> FEASIBILITY ANALYSIS                               ║
+║                                                             ║
+║  Method: {method_name}                                      ║
+║  Paper: {paper_title_short}                                 ║
+║  Deep-dive: {available | not available}                     ║
+║  Current stack: {language/framework}                        ║
+║  Baseline: {available | not assessed}                       ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Step 2: SPAWN FEASIBILITY ANALYST
+
+**Launch `grd-feasibility-analyst` agent via Task tool:**
+
+Use Task tool with `subagent_type="grd:grd-feasibility-analyst"`:
+
+```
+Analyze paper-to-production feasibility for: {method_name}
+
+PATHS:
+research_dir: ${research_dir}
+codebase_dir: ${codebase_dir}
+
+PAPER CONTEXT:
+{Deep-dive content if available, otherwise LANDSCAPE.md entry}
+
+CURRENT SYSTEM:
+- Language/Framework: {from codebase}
+- Dependencies: {key deps from manifest}
+- Deployment: {target environment if known}
+- Baseline: {BASELINE.md summary if available}
+
+EXISTING KNOWHOW:
+{KNOWHOW.md relevant entries, or "No prior production knowledge"}
+
+ANALYZE THESE DIMENSIONS:
+
+1. DEPENDENCY ANALYSIS:
+   - Required libraries and their maturity/maintenance status
+   - Version conflicts with existing dependencies
+   - Transitive dependency risks
+   - Build system compatibility
+   - GPU/hardware-specific dependencies
+
+2. SCALING CHARACTERISTICS:
+   - Training time estimates at different data scales
+   - Inference latency characteristics (batch vs real-time)
+   - Memory footprint (training vs inference)
+   - Horizontal scaling feasibility
+   - Bottleneck analysis (CPU, GPU, memory, I/O, network)
+
+3. DATA REQUIREMENTS:
+   - Training data volume and format
+   - Data preprocessing pipeline complexity
+   - Data quality requirements and cleaning effort
+   - Ongoing data needs (retraining frequency)
+   - Data privacy and compliance implications
+
+4. INFRASTRUCTURE REQUIREMENTS:
+   - Compute requirements (CPU/GPU/TPU, vCPU count, RAM)
+   - Storage requirements (model weights, data, artifacts)
+   - Serving architecture (REST, gRPC, batch, streaming)
+   - Monitoring and observability needs
+   - Estimated cloud cost (monthly range)
+
+5. ENGINEERING EFFORT:
+   - Implementation complexity (person-weeks estimate)
+   - Integration points with existing system
+   - Testing complexity (unit, integration, eval)
+   - Documentation and knowledge transfer needs
+   - Maintenance burden (ongoing)
+
+6. LICENSING AND LEGAL:
+   - Model/code license (MIT, Apache, GPL, proprietary, etc.)
+   - Data license restrictions
+   - Patent considerations
+   - Commercial use restrictions
+   - Attribution requirements
+
+7. RISK ASSESSMENT:
+   - Technical risks with mitigation strategies
+   - Schedule risks
+   - Quality risks (will it actually work in production?)
+   - Organizational risks (skills gap, bus factor)
+
+8. GAP ANALYSIS:
+   - PAPER_CLAIMS vs PRODUCTION_REALITY for each key metric
+   - What the paper assumes that we cannot assume
+   - What the paper omits that production requires
+
+9. VERDICT:
+   - FEASIBLE: can go to production with reasonable effort
+   - FEASIBLE_WITH_CAVEATS: possible but significant work needed (list caveats)
+   - RESEARCH_ONLY: not production-ready, needs fundamental work
+   - INFEASIBLE: blocking issues identified (list blockers)
+
+   Provide effort estimate: {weeks} and confidence: {HIGH/MEDIUM/LOW}
+
+OUTPUT FORMAT:
+Return structured markdown with all 9 sections, gap analysis table,
+and clear verdict with effort estimate.
+```
+
+**STEP_2_CHECKPOINT:**
+- [ ] Feasibility analyst launched with full context
+- [ ] Agent returned structured analysis
+- [ ] All 9 dimensions covered
+- [ ] Verdict includes effort estimate
+
+---
+
+## Step 3: DISPLAY FEASIBILITY VERDICT
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  FEASIBILITY VERDICT                                        ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                             ║
+║  Method: {method_name}                                      ║
+║  Verdict: {FEASIBLE | FEASIBLE_WITH_CAVEATS |               ║
+║            RESEARCH_ONLY | INFEASIBLE}                      ║
+║  Effort: {N} weeks                                          ║
+║  Confidence: {HIGH | MEDIUM | LOW}                          ║
+║                                                             ║
+║  Key gaps:                                                  ║
+║    Paper assumes → Production requires                      ║
+║    {assumption}  → {reality}                                ║
+║    {assumption}  → {reality}                                ║
+║                                                             ║
+║  Blockers: {count} ({list if any})                          ║
+║  Caveats:  {count} ({list if any})                          ║
+║  Est. cloud cost: ${min}-${max}/month                       ║
+║                                                             ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Step 4: UPDATE KNOWHOW.md
+
+1. **Load or create** `.planning/KNOWHOW.md`
+2. **Append feasibility findings** under a new section:
+   ```markdown
+   ## {method_name} — Feasibility ({YYYY-MM-DD})
+
+   **Verdict**: {verdict}
+   **Effort**: {weeks} weeks
+   **Key insight**: {one-line summary of most important finding}
+
+   ### Production gaps
+   - {gap_1}: {mitigation}
+   - {gap_2}: {mitigation}
+
+   ### Engineering notes
+   - {note_1}
+   - {note_2}
+   ```
+
+3. **Preserve existing KNOWHOW.md content** — append, do not overwrite
+
+---
+
+## Step 5: WRITE FEASIBILITY REPORT
+
+1. **Write detailed report**:
+   - Path: `${research_dir}/deep-dives/{PAPER-SLUG}-FEASIBILITY.md`
+   - Include all 9 dimensions from agent analysis
+   - Include gap analysis table
+   - Include verdict and effort estimate
+
+2. **Update PAPERS.md** (if exists):
+   - Add feasibility status column or annotation
+   - Link to feasibility report
+
+---
+
+## Step 6: COMMIT
+
+```bash
+git add .planning/KNOWHOW.md
+git add ${research_dir}/deep-dives/{PAPER-SLUG}-FEASIBILITY.md
+git add ${research_dir}/PAPERS.md 2>/dev/null
+git commit -m "research: feasibility {method_name} — {verdict}, {N}wk effort"
+```
+
+---
+
+## Step 7: ROUTE NEXT ACTION
+
+| Verdict | Suggestion |
+|---------|------------|
+| FEASIBLE | `/grd:product-plan` or `/grd:plan-phase` — start building |
+| FEASIBLE_WITH_CAVEATS | `/grd:eval-plan` — design evaluation to validate caveats |
+| RESEARCH_ONLY | `/grd:compare-methods` — look at production-ready alternatives |
+| INFEASIBLE | `/grd:survey {broader_topic}` — find alternative approaches |
+
+</process>
+
+<output>
+**FILES_WRITTEN:**
+- `${research_dir}/deep-dives/{PAPER-SLUG}-FEASIBILITY.md` — full feasibility report
+- `.planning/KNOWHOW.md` — updated with production engineering knowledge
+- `${research_dir}/PAPERS.md` — annotated with feasibility status
+
+**DISPLAY**: Feasibility verdict with gaps, blockers, effort estimate, and routing
+
+**GIT**: Committed: `research: feasibility {method} — {verdict}, {N}wk effort`
+</output>
+
+<error_handling>
+- **No deep-dive available**: Warn that feasibility analysis will be less accurate, suggest deep-dive first
+- **No LANDSCAPE.md**: Proceed with paper reference alone, but note limited context
+- **Method has no code**: Flag as major risk, increase effort estimate accordingly
+- **Cannot determine tech stack**: Ask user for deployment target and constraints
+- **KNOWHOW.md format corrupted**: Back up and append new section at end
+</error_handling>
+
+<success_criteria>
+- Gap analysis is specific (paper assumption vs production reality, not generic)
+- Effort estimate includes confidence level and assumptions
+- Infrastructure costs are estimated with ranges
+- KNOWHOW.md captures reusable production engineering knowledge
+- Verdict is actionable with clear next step
+</success_criteria>

package/commands/help.md

@@ -0,0 +1,407 @@
+---
+description: Show available GRD commands and usage guide
+argument-hint: [command name for detailed help]
+---
+
+<purpose>
+Complete help reference for all GRD (Get Research Done) commands. Organized by category
+with usage examples, workflow diagrams, and quick-start guides. Serves as both a
+reference card and onboarding document for the GRD R&D workflow system.
+</purpose>
+
+<context>
+CLAUDE.md rules: @CLAUDE.md
+
+GRD is a research-grade project automation system for Claude Code. It extends traditional
+software development workflows with research survey, paper analysis, tiered evaluation,
+iteration loops, and autonomous operation modes.
+</context>
+
+<process>
+
+## Step 0: PARSE ARGUMENTS
+
+1. **Check if specific command help requested**: `$ARGUMENTS`
+   - If a command name is provided (e.g., "survey"): show detailed help for that command only
+   - If empty: show full help listing
+
+---
+
+## Step 1: DISPLAY MAIN HELP (if no specific command requested)
+
+```
+╔══════════════════════════════════════════════════════════════════════╗
+║                                                                     ║
+║   ██████  ██████  ██████                                            ║
+║  ██       ██   ██ ██   ██                                           ║
+║  ██   ██  ██████  ██   ██    Get Research Done                      ║
+║  ██   ██  ██   ██ ██   ██    v{version} — R&D Workflow Automation   ║
+║   ██████  ██   ██ ██████                                            ║
+║                                                                     ║
+╚══════════════════════════════════════════════════════════════════════╝
+
+RESEARCH — Survey, analyze, and compare state-of-the-art
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:survey <topic>           Scan papers, repos, benchmarks for a
+                                research topic. Updates LANDSCAPE.md.
+
+  /grd:deep-dive <paper>        Deep analysis of a specific paper —
+                                method, code, limitations, verdict.
+
+  /grd:compare-methods [m1,m2]  Compare methods from LANDSCAPE.md.
+                                Build performance/complexity matrix.
+
+  /grd:feasibility <method>     Analyze paper-to-production gap.
+                                Dependencies, scale, licensing, effort.
+
+
+PLANNING — Strategic and tactical planning
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:init                      Initialize new R&D project with deep
+                                  context gathering and research setup.
+
+  /grd:product-plan <goals>     Product-level roadmap from research
+                                findings. Gap analysis, phase breakdown.
+
+  /grd:plan-phase <N>           Create detailed execution plan for a
+                                phase with research context injection.
+                                Flags: --research-only (research only),
+                                       --eval-only (eval plan only).
+
+  /grd:discuss-phase <N>        Gather phase context through adaptive
+                                questioning before planning.
+
+
+EXECUTION — Build and implement
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:execute-phase <N>        Execute all plans in a phase with
+                                wave-based parallelization, atomic commits.
+
+  /grd:quick <task>             Quick task with GRD guarantees but
+                                skip optional agents. Fast execution.
+
+
+EVALUATION — Measure, verify, and iterate
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:eval-report <N>          Run evaluations and report results.
+                                Compare against baselines and targets.
+
+  /grd:assess-baseline [scope]  Assess current code quality and
+                                establish performance baseline.
+
+  /grd:iterate <N>              Iteration loop when eval misses targets.
+                                Survey alternatives, adjust, or accept.
+
+
+VERIFICATION — Quality gates and validation
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:verify-phase <N>         Verify phase completion with tiered
+                                evaluation and quantitative metrics.
+
+  /grd:verify-work              Validate built features through
+                                conversational UAT with metrics.
+
+
+NAVIGATION — Project status and configuration
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:progress                 Check project progress with research
+                                metrics and route to next action.
+    progress dashboard          Full TUI tree view of milestones, phases,
+                                and plans with progress bars.
+    progress health             Project health: blockers, velocity, stale
+                                phases, risk register.
+    progress phase <N>          Detailed drill-down for a single phase
+                                with plans, metrics, and artifacts.
+
+  /grd:help [command]           Show this help (or detailed command help).
+
+  /grd:settings                 Configure all workflow settings interactively.
+                                Subcommands for quick toggles:
+                                  settings yolo [on|off] — autonomous mode
+                                  settings profile <p>   — model profile
+                                  settings ceremony <l>  — ceremony level
+
+
+PROJECT MANAGEMENT — Phase and task operations
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:add-phase <name>         Add phase to end of current milestone.
+
+  /grd:insert-phase <N.M> <nm>  Insert urgent work between existing
+                                phases as decimal phase.
+
+  /grd:remove-phase <N>         Remove future phase and renumber.
+
+  /grd:add-todo <description>   Capture idea or task as todo from
+                                current conversation context.
+
+  /grd:check-todos              List pending todos, select one to work on.
+
+
+LIFECYCLE — Session and milestone management
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:pause-work               Create context handoff when pausing
+                                work mid-phase. Saves full state.
+
+  /grd:resume-work              Resume work from previous session with
+                                full context restoration.
+
+  /grd:complete-milestone       Audit, archive, and tag a completed
+                                milestone. Runs integration checks first.
+
+  /grd:new-milestone            Start a new milestone cycle. Update
+                                PROJECT.md and route to requirements.
+
+
+INTEGRATION — Issue tracker sync
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:sync [roadmap|phase N]   Sync GRD state to issue tracker.
+                                Push phases and plans to GitHub/Jira.
+
+  /grd:tracker-setup            Configure issue tracker integration.
+                                Supports GitHub Issues and MCP Atlassian.
+
+
+TOOLS — Analysis and debugging utilities
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:map-codebase             Analyze codebase with parallel mapper
+                                agents. Produce codebase analysis docs.
+
+  /grd:debug                    Systematic debugging with persistent
+                                state across context resets.
+
+  /grd:list-phase-assumptions   Surface Claude's assumptions about a
+                                phase approach before planning.
+
+  /grd:plan-milestone-gaps      Create phases to close all gaps
+                                identified by milestone audit.
+
+
+UPDATE — Self-update and patch management
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /grd:update                   Check for updates, display changelog,
+                                back up modifications, pull latest.
+
+  /grd:reapply-patches          Restore local modifications after a
+                                GRD update with conflict resolution.
+
+
+TOOLING — grd-tools.js CLI reference
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  node bin/grd-tools.js <command> [args]
+
+  State:      state load | get | patch | advance-plan | record-metric | add-decision
+  Verify:     verify plan-structure | phase-completeness | references | commits | artifacts | key-links
+  Phase:      phase add | insert | remove | complete
+  Roadmap:    roadmap get-phase | analyze
+  Scaffold:   scaffold context | uat | verification | phase-dir | research-dir | eval | baseline
+  Progress:   progress json | table | bar
+  Parsers:    phase-plan-index | state-snapshot | summary-extract | history-digest
+  Frontmatter: frontmatter get | set | merge | validate
+  Tracker:    tracker get-config | sync-roadmap | sync-phase | update-status | add-comment | prepare-*
+  Validate:   validate consistency
+  Milestone:  milestone complete
+```
+
+---
+
+## Step 2: DISPLAY WORKFLOW DIAGRAM
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+                         GRD R&D WORKFLOW
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  RESEARCH PHASE (understand the problem space)
+  ─────────────────────────────────────────────
+
+    Idea/Goal
+        │
+        ▼
+    ┌──────────┐     ┌────────────┐     ┌─────────────┐
+    │  survey   │────►│ deep-dive  │────►│  compare-   │
+    │          │     │            │     │  methods    │
+    └──────────┘     └────────────┘     └──────┬──────┘
+                                               │
+                                               ▼
+                                        ┌─────────────┐
+                                        │ feasibility  │
+                                        └──────┬──────┘
+                                               │
+  PLANNING PHASE (design the solution)         │
+  ────────────────────────────────────         │
+                                               ▼
+    ┌──────────────┐     ┌──────────┐     ┌──────────┐
+    │assess-baseline│────►│ product- │────►│  plan-   │
+    │              │     │  plan    │     │  phase   │
+    └──────────────┘     └──────────┘     └────┬─────┘
+                                               │
+  EXECUTION PHASE (build it)                   │
+  ──────────────────────────                   │
+                                               ▼
+                                        ┌──────────────┐
+                                        │execute-phase │
+                                        └──────┬───────┘
+                                               │
+  EVALUATION PHASE (measure it)                │
+  ─────────────────────────────                │
+                                               ▼
+    ┌──────────┐     ┌──────────┐     ┌──────────────┐
+    │plan-phase│────►│eval-report│────►│   iterate?   │
+    │--eval-only     │            │     │              │
+    └──────────┘     └──────────┘     └──────┬───────┘
+                                             │
+                          ┌──────────────────┤
+                          │ targets met      │ targets missed
+                          ▼                  ▼
+                    ┌──────────┐      ┌──────────┐
+                    │ verify-  │      │  iterate  │──── loop back to
+                    │  phase   │      │          │     survey/plan/exec
+                    └────┬─────┘      └──────────┘
+                         │
+  INTEGRATION (ship it)  │
+  ─────────────────────  │
+                         ▼
+                    ┌──────────┐     ┌──────────┐
+                    │ next     │────►│ complete- │
+                    │ phase    │     │ milestone │
+                    └──────────┘     └──────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## Step 3: DISPLAY QUICK START GUIDE
+
+```
+QUICK START
+━━━━━━━━━━━
+
+  New R&D project:
+    1. /grd:init
+    2. /grd:survey "your research topic"
+    3. /grd:deep-dive "promising paper"
+    4. /grd:feasibility "chosen method"
+    5. /grd:assess-baseline
+    6. /grd:product-plan "your product goal"
+    7. /grd:plan-phase 1
+    8. /grd:execute-phase 1
+    9. /grd:eval-report 1
+   10. /grd:iterate 1  (if needed)
+
+  Quick task (skip research):
+    /grd:quick "implement feature X"
+
+  Autonomous batch run:
+    /grd:settings yolo on
+    /grd:execute-phase 1
+    /grd:eval-report 1
+
+  Resume after break:
+    /grd:resume-work
+
+  Check where you are:
+    /grd:progress
+```
+
+---
+
+## Step 4: DISPLAY KEY FILES REFERENCE
+
+```
+KEY FILES
+━━━━━━━━━
+
+  .planning/
+  ├── PROJECT.md              Project definition and goals
+  ├── ROADMAP.md              Phase-level roadmap
+  ├── BASELINE.md             Current performance baseline
+  ├── BENCHMARKS.md           Historical benchmark tracking
+  ├── KNOWHOW.md              Production engineering knowledge
+  ├── config.json             GRD configuration
+  ├── yolo-decisions.log      Autonomous mode decision log
+  │
+  ├── research/
+  │   ├── LANDSCAPE.md        State-of-the-art survey
+  │   ├── PAPERS.md           Paper index
+  │   ├── COMPARISON-*.md     Method comparison matrices
+  │   └── deep-dives/         Individual paper analyses
+  │       ├── {paper}.md
+  │       └── {paper}-feasibility.md
+  │
+  ├── phases/
+  │   └── {N}-{name}/
+  │       ├── PLAN.md         Phase execution plan
+  │       └── EVAL.md         Evaluation plan and results
+  │
+  └── codebase/               Codebase analysis docs
+```
+
+---
+
+## Step 5: SPECIFIC COMMAND HELP (if requested)
+
+If `$ARGUMENTS` matches a command name, display detailed help:
+
+```
+/grd:{command}
+━━━━━━━━━━━━━━
+
+  Description: {from plugin.json}
+  Arguments:   {argument-hint}
+
+  What it does:
+    {detailed explanation}
+
+  Files it reads:
+    {list of input files}
+
+  Files it writes:
+    {list of output files}
+
+  Agent spawned:
+    {agent name or "none — orchestrator only"}
+
+  Research gates:
+    {which gates apply to this command}
+
+  Related commands:
+    {commands typically run before/after}
+
+  Example:
+    /grd:{command} {example_args}
+```
+
+</process>
+
+<output>
+**DISPLAY**: Full help listing with command reference, workflow diagram, quick start, and file reference.
+
+No files are created or modified by this command.
+</output>
+
+<error_handling>
+- **Unknown command in arguments**: Show "Command not found" with closest match suggestion
+- **VERSION file missing**: Display "version unknown"
+</error_handling>
+
+<success_criteria>
+- All GRD commands are listed with descriptions
+- Commands are organized by logical category
+- Workflow diagram shows the full R&D lifecycle
+- Quick start guide enables immediate productivity
+- File reference shows project structure at a glance
+- Specific command help provides actionable detail
+</success_criteria>