@grainulation/wheat 1.0.0

package/templates/claude.md

@@ -0,0 +1,122 @@
+# Wheat — Research Sprint
+
+> This file configures Claude Code for Wheat research sprints. It is auto-maintained by `wheat init`. Edit with care.
+
+## Sprint
+
+**Question:** {{QUESTION}}
+
+**Audience:** {{AUDIENCE}}
+
+**Constraints:**
+{{CONSTRAINTS}}
+
+**Done looks like:** {{DONE_CRITERIA}}
+
+## Connectors
+
+_No connectors configured. Use `/connect` to link org tools._
+
+## Intent Router
+
+When the user sends a plain message (no slash command), assess whether a Wheat command applies. If it does, announce which command you're running and execute it. If no command fits, respond normally.
+
+**Route by intent:**
+
+| User says something like... | Route to | Why |
+|---|---|---|
+| "look into X", "what about X", "explore X", "how does X work" | `/research X` | Information gathering |
+| "build X", "try X", "make a quick X", "test whether X" | `/prototype` | Hands-on validation |
+| "is p001 really true?", "I doubt X", "what if X is wrong" | `/challenge <id>` | Adversarial testing |
+| "check this: <url>", "does <url> support X", "verify X against <url>" | `/witness <id> <url>` | External corroboration |
+| "what are we missing", "any gaps?", "what haven't we considered" | `/blind-spot` | Structural gap analysis |
+| "where are we", "what's the status", "show me the dashboard" | `/status` | Sprint snapshot |
+| "write it up", "give me the recommendation", "summarize for the team" | `/brief` | Decision document |
+| "make slides", "prepare for the meeting" | `/present` | Stakeholder presentation |
+| "someone else is taking over", "hand this off", "document for successor" | `/handoff` | Knowledge transfer |
+| "combine with the other sprint", "merge these" | `/merge <path>` | Cross-sprint merge |
+| "how did we get here", "show the history", "what changed over time" | `/replay` | Sprint archaeology |
+| "we shipped, here's what happened", "actual results were X" | `/calibrate --outcome "X"` | Prediction scoring |
+| "the stakeholder said X", "new constraint: X", "change of direction" | `/feedback` | Stakeholder input |
+| "resolve the conflict", "pick between X and Y" | `/resolve` | Conflict adjudication |
+| "connect to <repo/jira/docs>" | `/connect <type> <target>` | External source linking |
+
+**When NOT to route:** Questions about the framework itself ("how does the compiler work?"), code edits to wheat files, general conversation, ambiguous intent. When in doubt, ask: "That sounds like it could be a `/research` -- want me to run it as a full research pass, or just answer the question?"
+
+**Announce the routing:** Always tell the user what you're doing:
+> Running as `/research "SSE scalability"` -- this will create claims and compile. Say "just answer" if you wanted a quick response instead.
+
+This gives the user a chance to redirect before the full pipeline runs.
+
+### Claims System (Bran IR)
+- All findings are tracked as typed claims in `claims.json`
+- Every slash command that produces findings MUST append claims
+- Every slash command that produces output artifacts MUST run `wheat compile` first
+- Output artifacts consume `compilation.json`, never `claims.json` directly
+- The compiler is the enforcement layer -- if it says blocked, no artifact gets produced
+
+### Claim Types
+- `constraint` -- hard requirements, non-negotiable boundaries
+- `factual` -- verifiable statements about the world
+- `estimate` -- projections, approximations, ranges
+- `risk` -- potential failure modes, concerns
+- `recommendation` -- proposed courses of action
+- `feedback` -- stakeholder input, opinions, direction changes
+
+### Evidence Tiers (lowest to highest)
+1. `stated` -- stakeholder said it, no verification
+2. `web` -- found online, not independently verified
+3. `documented` -- in source code, official docs, or ADRs
+4. `tested` -- verified via prototype or benchmark
+5. `production` -- measured from live production systems
+
+### Claim ID Prefixes
+- `d###` -- define phase (from /init)
+- `r###` -- research phase (from /research)
+- `p###` -- prototype phase (from /prototype)
+- `e###` -- evaluate phase (from /evaluate)
+- `f###` -- feedback phase (from /feedback)
+- `x###` -- challenge claims (from /challenge)
+- `w###` -- witness claims (from /witness)
+- `burn-###` -- synthetic claims (from /control-burn, always reverted)
+- `cal###` -- calibration claims (from /calibrate)
+- `<sprint-slug>-<prefix>###` -- merged claims keep original prefix with sprint slug (from /merge)
+
+### Next Command Hints
+Every slash command MUST end its output with a "Next steps" section suggesting 2-4 concrete commands the user could run next, based on the current sprint state. Use this decision tree:
+
+- Unresolved conflicts exist -> suggest `/resolve`
+- Claim has no corroboration -> suggest `/witness <id> <relevant-url>`
+- Topic has weak evidence -> suggest `/research <topic>` or `/prototype`
+- Topic has type monoculture -> suggest `/challenge <id>` or `/research <topic>`
+- Sprint is late-phase with gaps -> suggest `/blind-spot`
+- Claims untested against reality -> suggest `/calibrate`
+- Sprint ready for output -> suggest `/brief`, `/present`, or `/handoff`
+- Multiple sprints exist -> suggest `/merge`
+- Want to understand history -> suggest `/replay`
+
+Format:
+```
+Next steps:
+  /challenge p001     -- stress-test the zero-deps claim
+  /witness r002 <url> -- corroborate fs.watch reliability
+  /blind-spot         -- check for structural gaps
+```
+
+### Git Discipline
+- Every slash command that modifies claims.json auto-commits
+- Commit format: `wheat: /<command> <summary> -- added/updated <claim IDs>`
+- `git log --oneline claims.json` = the sprint event log
+- Compilation certificate references the claims hash for reproducibility
+
+### Output Artifacts
+- HTML files are self-contained (inline CSS/JS, no external deps)
+- Use the dark scroll-snap template for explainers and presentations
+- Use the dashboard template for status and comparisons
+- PDFs generated via `node build-pdf.js <file.md>`
+
+### Directory Structure
+- `research/` -- topic explainers (HTML + MD)
+- `prototypes/` -- working proof-of-concepts
+- `evidence/` -- evaluation results and comparison dashboards
+- `output/` -- compiled artifacts (briefs, presentations, dashboards)

package/templates/commands/blind-spot.md

@@ -0,0 +1,47 @@
+# /blind-spot — Analyze What's NOT Being Claimed
+
+You are scanning the claim set for structural gaps — not what's wrong, but what's *missing*. Read CLAUDE.md for sprint context, claims.json for existing claims, and compilation.json for coverage data.
+
+## Process
+
+1. **Run the compiler** to get fresh data:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+
+2. **Read compilation.json** for coverage analysis, including source diversity, type diversity, and corroboration data.
+
+3. **Analyze four categories of blind spots**:
+
+### (a) Dependency gaps
+Scan claim content for topic-like nouns that are NOT in the current topic set. If claims reference concepts like "latency," "compliance," "security," "cost," or "performance" but no topic covers those, they're implicit dependencies never addressed.
+
+### (b) Type monoculture
+Check `type_diversity` in coverage for each topic. Flag topics with < 2 distinct claim types. A topic with 5 factual claims but no risks is suspicious — where's the downside analysis?
+
+### (c) Echo chambers
+Check `source_origins` and `source_count` in coverage for each topic. Flag topics where:
+- All claims come from a single source origin (e.g., all "research" with no external feedback)
+- Claims >= 3 but source_count == 1
+
+### (d) Evidence ceiling
+Check `max_evidence` relative to the current sprint phase. If the sprint phase is `prototype` but a key topic is still at `stated` or `web` tier, that's a gap.
+
+Phase expectations:
+- `define`: `stated` is fine everywhere
+- `research`: key topics should be at least `web`
+- `prototype`: key topics should be at least `tested`
+- `evaluate`: everything should be `documented` or above
+
+4. **Check dismissed blind spots**: Look for a `dismissed_blind_spots` field in claims.json meta. Don't re-flag items the user has already dismissed.
+
+5. **Print the analysis** to the terminal. This command does NOT modify claims.json — it only reads and reports.
+
+## Tell the user
+
+- Present the blind spot analysis clearly
+- For each gap, suggest a specific action (which command to run)
+- Remind them they can dismiss false-positive blind spots by adding to `meta.dismissed_blind_spots`
+- If no blind spots found, say so — a clean bill of health is valuable information
+
+$ARGUMENTS

package/templates/commands/brief.md

@@ -0,0 +1,73 @@
+# /brief — Compile the decision document
+
+You are compiling the final decision brief for this Wheat sprint. This is the Bran compilation step — deterministic output from resolved claims.
+
+## Process
+
+1. **Run the compiler with check**:
+   ```bash
+   npx @grainulation/wheat compile --check
+   ```
+
+   **If the compiler returns an error (exit code 1), STOP.** Do not generate a brief. Instead:
+   - Show the user the compilation errors
+   - Explain what needs to be resolved
+   - Suggest specific commands to fix each blocker
+   - Do NOT proceed until compilation passes
+
+2. **Read compilation.json** — use ONLY `resolved_claims` as your source material. Never read claims.json directly for the brief.
+
+3. **Generate the brief as markdown**: Create `output/brief.md` with this structure:
+
+   ```markdown
+   # Decision Brief: [Sprint Question]
+
+   **Date**: [date]  |  **Audience**: [audience]  |  **Phase**: Compiled
+
+   ## Executive Summary
+   [2-3 sentences: the recommendation and why]
+
+   ## Recommendation
+   [The recommended course of action, with specific next steps]
+
+   ## Evidence Summary
+   [For each topic: key findings, evidence tier, source]
+   [Every statement must cite a claim ID]
+
+   ## Tradeoffs and Risks
+   [Risks identified, with evidence tier for each]
+
+   ## Resolved Conflicts
+   [What disagreed, how it was resolved, what evidence won]
+
+   ## Appendix: Claim Inventory
+   [Table of all resolved claims: ID, type, content, evidence, source]
+
+   ---
+   Compilation certificate: [hash] | Compiler: wheat v[version] | Claims: [count] | Compiled: [timestamp]
+   ```
+
+4. **Also generate brief as HTML**: Create `output/brief.html` — a clean, print-friendly HTML version for browser viewing.
+
+## Key rules
+
+- **Every statement in the brief must trace to a claim ID**. No uncited assertions.
+- **Use only resolved_claims from compilation.json**. Superseded claims are excluded.
+- **Include the compilation certificate** — this is the Bran determinism invariant. Same claims = same brief.
+- **The brief is deterministic**: given the same compilation.json, the structure and content should be reproducible.
+
+## Git commit
+
+Stage all output files.
+
+Commit: `wheat: /brief compiled — [total] claims, [conflicts resolved] conflicts resolved, certificate [hash]`
+
+## Tell the user
+
+- The brief is ready at `output/brief.md` and `output/brief.html`
+- Show the compilation certificate
+- Remind them they can share these with stakeholders
+- Mention `/present` if they need a presentation version
+- Mention `/feedback` for incorporating stakeholder responses
+
+$ARGUMENTS

package/templates/commands/calibrate.md

@@ -0,0 +1,39 @@
+# /calibrate — Score Past Predictions Against Reality
+
+You are checking what actually happened after a sprint's recommendations were implemented. This closes the feedback loop by comparing predictions to outcomes.
+
+## Process
+
+1. **Parse the outcome**: The user provides outcome data, either as:
+   - Free text: `/calibrate --outcome "Shipped Auth0. Took 3 weeks not 2. Costs $18K/year not $15K."`
+   - Claim-specific: `/calibrate e003 "actual: 3 weeks, $18K/year"`
+
+2. **Read the sprint data** and match outcomes to original predictions.
+
+3. **Create calibration claims** (`cal###` prefix, evidence: `production`).
+
+4. **Compute accuracy scorecard** by evidence tier, source origin, and claim type.
+
+5. **Write/update calibration.json** and add claims to claims.json:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+
+6. **Print the scorecard** to the terminal.
+
+## The meta-insight
+
+This is the only command that validates the framework itself. If `tested` claims are right 95% of the time and `web` 65%, the tier system works.
+
+## Git commit
+
+Commit: `wheat: /calibrate — scored <N> predictions against outcomes`
+
+## Tell the user
+
+- The accuracy scorecard
+- Which predictions were wrong and by how much
+- Whether the evidence tier hierarchy is predictive
+- Suggest: future sprints should weight evidence tiers based on this data
+
+$ARGUMENTS

package/templates/commands/challenge.md

@@ -0,0 +1,72 @@
+# /challenge — Structured Devil's Advocacy
+
+You are stress-testing a specific claim by researching the **strongest possible counter-argument** with real evidence. Read CLAUDE.md for sprint context and claims.json for existing claims.
+
+## Process
+
+1. **Identify the target claim**: The user's argument is a claim ID (e.g., `p001`). Read that claim from claims.json. If no ID provided, ask the user which claim to challenge.
+
+2. **Understand what's being claimed**: Break down the claim into its core assertions.
+
+3. **Research AGAINST the claim**: Use web search to find the strongest counter-evidence. Search for problems, limitations, failure modes, alternatives, and contradictions. Be adversarial — your job is to find what's wrong, not confirm what's right.
+
+   Guidelines for research:
+   - Focus on factual counter-evidence, not opinion
+   - Only challenge claims at `web` tier or above (challenging `stated` is pointless — they're already known-weak)
+   - Distinguish "contradicts the claim" from "adds a related concern"
+   - Look for: documented bugs, breaking changes, scalability limits, maintenance costs, better alternatives
+
+4. **Create challenge claims**: For each substantive counter-argument found, create a claim with:
+   - ID: `x###` prefix (continue sequence from existing x-prefixed claims)
+   - `"source.origin": "challenge"`
+   - `"source.challenged_claim": "<target claim ID>"`
+   - Evidence tier based on what you found (web, documented, etc.)
+   - Set `conflicts_with` ONLY if the challenge directly contradicts the target claim's factual assertions.
+
+```json
+{
+  "id": "x001",
+  "type": "risk|factual",
+  "topic": "<same topic as challenged claim>",
+  "content": "<specific counter-argument with evidence>",
+  "source": {
+    "origin": "challenge",
+    "challenged_claim": "<target claim ID>",
+    "artifact": null,
+    "connector": null
+  },
+  "evidence": "web|documented",
+  "status": "active",
+  "phase_added": "<current phase>",
+  "timestamp": "<ISO timestamp>",
+  "conflicts_with": [],
+  "resolved_by": null,
+  "tags": ["challenge", "<relevant tags>"]
+}
+```
+
+5. **Run the compiler**:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+   Report whether challenges created new conflicts and whether the compiler auto-resolved any.
+
+6. **Assess the outcome**:
+   - If the challenge finds `tested` or `documented` evidence contradicting a `web`-tier claim -> compiler may auto-resolve
+   - If same tier -> unresolved conflict -> needs `/resolve`
+   - If challenge only raises concerns without contradiction -> no conflict, just enriched claim set
+
+## Git commit
+
+Stage claims.json and any new files.
+
+Commit: `wheat: /challenge <claim ID> — added <challenge claim IDs>`
+
+## Tell the user
+
+- Summarize what you challenged and what you found
+- Flag which challenges contradict vs. add concerns
+- Report compiler status (new conflicts? auto-resolved?)
+- Suggest: `/resolve` if unresolved conflicts, `/witness` to corroborate survivors, more `/challenge` for other claims
+
+$ARGUMENTS

package/templates/commands/connect.md

@@ -0,0 +1,104 @@
+# /connect — Link an external data source
+
+You are connecting an external tool or data source to this Wheat sprint. Connected sources provide higher-quality evidence than web research alone.
+
+## Connector Types
+
+### GitHub Repository
+```
+/connect github <org/repo>
+```
+- Read the repo's README, key source files, architecture
+- Extract claims about existing infrastructure, patterns, dependencies
+- Evidence tier: `documented`
+- Track as connector in claims.json source field
+
+### Atlas File
+```
+/connect atlas <path-to-atlas.yaml>
+```
+- Read a RepoAtlas-style YAML file for multi-repo routing intelligence
+- Extract claims about repo ownership, dependencies, infrastructure
+- Evidence tier: `documented`
+
+### Jira / Linear (via MCP)
+```
+/connect jira <project-key>
+```
+- Read relevant tickets, priorities, blockers
+- Extract constraint and risk claims
+- Evidence tier: `stated` (tickets are stakeholder input)
+
+### Monitoring (Datadog, Grafana, etc.)
+```
+/connect monitoring <dashboard-name>
+```
+- Pull current metrics if accessible
+- Evidence tier: `production` (highest tier)
+
+### Confluence / Notion (via MCP)
+```
+/connect docs <space/page>
+```
+- Read existing documentation, ADRs, decision records
+- Evidence tier: `documented`
+
+## Process
+
+1. **Parse the argument** to determine connector type and target.
+
+2. **Attempt to access the source**: Use available MCP tools, file system access, or web fetch as appropriate. If the source isn't accessible, tell the user what's needed (MCP server config, file path, etc.)
+
+3. **Extract initial claims**: Pull relevant information and create claims:
+
+```json
+{
+  "id": "r0XX",
+  "type": "factual|constraint",
+  "topic": "<relevant topic>",
+  "content": "<extracted finding>",
+  "source": {
+    "origin": "connector",
+    "artifact": null,
+    "connector": {
+      "type": "<github|atlas|jira|monitoring|docs>",
+      "target": "<org/repo or project-key or path>",
+      "ref": "<specific file/ticket/page if applicable>",
+      "fetched": "<ISO timestamp>"
+    }
+  },
+  "evidence": "documented",
+  "status": "active",
+  "phase_added": "research",
+  "timestamp": "<ISO timestamp>",
+  "conflicts_with": [],
+  "resolved_by": null,
+  "tags": ["connector", "<type>"]
+}
+```
+
+4. **Register the connector** in claims.json `meta.connectors`:
+```json
+{ "type": "github", "target": "org/repo", "connected": "<ISO timestamp>" }
+```
+
+5. **Update CLAUDE.md** Connectors section with the new connection.
+
+6. **Run the compiler**:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+
+## Git commit
+
+Stage claims.json, CLAUDE.md, and any new files.
+
+Commit: `wheat: /connect <type> <target> — added <claim IDs>`
+
+## Tell the user
+
+- Confirm what was connected and what was found
+- List the claims extracted
+- Suggest `/research` to dig deeper into findings, or `/status` to see the updated dashboard
+
+$ARGUMENTS

package/templates/commands/evaluate.md

@@ -0,0 +1,80 @@
+# /evaluate — Test claims against reality, resolve conflicts
+
+You are running the evaluation phase of the current Wheat sprint. This is the honesty phase — where claims meet data.
+
+Read CLAUDE.md for sprint context and claims.json for all existing claims.
+
+## Process
+
+1. **Run the compiler first**:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+   Identify conflicts, weak evidence areas, and coverage gaps.
+
+2. **Evaluate systematically**: For each topic with weak or conflicting evidence:
+   - Run benchmarks, cost calculations, feature comparisons
+   - Test prototypes against real conditions
+   - Pull production metrics from connected tools if available
+   - Cross-reference claims against each other
+
+3. **Resolve conflicts**: When evaluation produces a clear answer:
+   - Update the winning claim's evidence tier
+   - Mark the losing claim as `superseded` with `resolved_by`
+   - Add new evaluation claims (evidence: "tested") if needed
+
+4. **Generate comparison dashboard**: Create `evidence/<topic-or-sprint-slug>.html` — a dashboard-style HTML page showing:
+   - Side-by-side comparisons with real numbers
+   - Conflict resolutions with evidence
+   - Data tables, charts (CSS-only), metrics
+
+## Claim updates
+
+Evaluation claims use evidence tier `tested` or `production`:
+
+```json
+{
+  "id": "e001",
+  "type": "factual",
+  "topic": "<what was evaluated>",
+  "content": "<measured result — always include numbers>",
+  "source": {
+    "origin": "evaluation",
+    "artifact": "evidence/<slug>.html",
+    "connector": null
+  },
+  "evidence": "tested",
+  "status": "active",
+  "phase_added": "evaluate",
+  "timestamp": "<ISO timestamp>",
+  "conflicts_with": [],
+  "resolved_by": null,
+  "tags": []
+}
+```
+
+Update `meta.phase` to "evaluate" in claims.json.
+
+## Run the compiler again
+
+```bash
+npx @grainulation/wheat compile --summary
+```
+
+Verify that conflicts are resolved. If the compiler still shows blockers, tell the user what remains.
+
+## Git commit
+
+Stage claims.json and all new/changed files.
+
+Commit: `wheat: /evaluate — resolved <conflict details>, added <claim IDs>`
+
+## Tell the user
+
+- Show the compilation status (ready or still blocked)
+- Summarize what was evaluated and key findings
+- Point them to the comparison dashboard HTML
+- If ready: suggest `/brief` to compile the decision document
+- If blocked: explain what conflicts remain and how to resolve them
+
+$ARGUMENTS

package/templates/commands/feedback.md

@@ -0,0 +1,60 @@
+# /feedback — Incorporate stakeholder input
+
+You are processing feedback from stakeholders for this Wheat sprint. Feedback introduces new claims (usually constraints or direction changes) that may trigger re-evaluation.
+
+Read CLAUDE.md and claims.json for context.
+
+## Process
+
+1. **Parse the feedback**: The user's argument contains stakeholder input. This could be:
+   - A new constraint ("CTO says prioritize speed over cost")
+   - A correction ("the compliance team says we need SOC2 Type II, not Type I")
+   - A direction change ("skip the custom build option, focus on Auth0 vs Clerk")
+   - A question ("what about latency in EU regions?")
+
+2. **Create claims**: Each piece of feedback becomes a claim:
+
+```json
+{
+  "id": "f001",
+  "type": "constraint|feedback",
+  "topic": "<relevant topic>",
+  "content": "<the feedback, attributed>",
+  "source": {
+    "origin": "stakeholder",
+    "artifact": null,
+    "connector": null
+  },
+  "evidence": "stated",
+  "status": "active",
+  "phase_added": "feedback",
+  "timestamp": "<ISO timestamp>",
+  "conflicts_with": [],
+  "resolved_by": null,
+  "tags": ["<stakeholder name or role>"]
+}
+```
+
+3. **Check for conflicts**: Does this feedback contradict existing claims? If a stakeholder says "budget is $10K max" but existing research shows a solution costing $15K, that's a conflict. Mark it.
+
+4. **Run the compiler**:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+
+5. **Update CLAUDE.md** if the feedback changes constraints or audience.
+
+## Git commit
+
+Stage claims.json, CLAUDE.md, and any changed files.
+
+Commit: `wheat: /feedback "<summary>" — added <claim IDs>`
+
+## Tell the user
+
+- Confirm what feedback was captured as claims
+- Show any new conflicts introduced
+- If compilation is now blocked, explain what needs re-evaluation
+- Suggest next steps: `/research` for new questions, `/evaluate` to re-test, `/brief` to recompile
+
+$ARGUMENTS

package/templates/commands/handoff.md

@@ -0,0 +1,53 @@
+# /handoff — Package Sprint for Transfer
+
+You are generating a self-contained briefing optimized for a **successor** — someone who needs to continue this sprint, not a stakeholder making a decision. Read CLAUDE.md, claims.json, and compilation.json.
+
+## Key distinction from other output commands
+
+| Command | Audience | Optimized for |
+|---------|----------|---------------|
+| `/brief` | Decision-makers | "What should we do?" |
+| `/present` | External audiences | Persuasion |
+| `/status` | Current researcher | Snapshot |
+| `/handoff` | Successor | "What do I need to know to continue?" |
+
+## Process
+
+1. **Run the compiler**:
+   ```bash
+   npx @grainulation/wheat compile --summary
+   ```
+
+2. **Read all data sources**:
+   - `compilation.json` — current state
+   - `claims.json` — all claims including superseded ones (the full history)
+   - `git log --oneline claims.json` — the event log
+   - `CLAUDE.md` — sprint context and conventions
+
+3. **Build the reasoning chain**: For each topic, reconstruct the narrative:
+   - What constraint or question initiated work on this topic?
+   - What did research find?
+   - Did prototyping confirm or contradict research?
+   - Were there conflicts? How were they resolved?
+
+4. **Identify open questions**: From compilation.json:
+   - Unresolved conflicts
+   - Coverage gaps
+   - Unmitigated risks
+   - Dismissed blind spots
+
+5. **Generate the handoff document**: Create `output/handoff.md` and `output/handoff.html`.
+
+6. **Print a summary** to the terminal.
+
+## Git commit
+
+Commit: `wheat: /handoff — generated sprint handoff document`
+
+## Tell the user
+
+- Point them to `output/handoff.md` and `output/handoff.html`
+- Highlight the most important open questions
+- Suggest: `/replay` for detailed timeline, `/blind-spot` for gap analysis
+
+$ARGUMENTS