@grainulation/wheat 1.0.2 → 1.0.4

package/templates/commands/brief.md

@@ -7,11 +7,13 @@ You are compiling the final decision brief for this Wheat sprint. This is the Br
 ## 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
@@ -32,32 +34,40 @@ You are compiling the final decision brief for this Wheat sprint. This is the Br
    ```markdown
    # Decision Brief: [Sprint Question]
 
-   **Date**: [date]  |  **Audience**: [audience]  |  **Phase**: Compiled
+   **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]
    ```
 
 6. **Generate PDF** (if build-pdf.js exists):
+
    ```bash
    node build-pdf.js output/brief.md
    ```

package/templates/commands/calibrate.md

@@ -5,6 +5,7 @@ You are checking what actually happened after a sprint's recommendations were im
 ## 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"`
 
@@ -15,6 +16,7 @@ You are checking what actually happened after a sprint's recommendations were im
 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
    ```
@@ -36,4 +38,4 @@ Commit: `wheat: /calibrate — scored <N> predictions against outcomes`
 - Whether the evidence tier hierarchy is predictive
 - Suggest: future sprints should weight evidence tiers based on this data
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/challenge.md

@@ -11,6 +11,7 @@ You are stress-testing a specific claim by researching the **strongest possible
 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"
@@ -46,9 +47,11 @@ You are stress-testing a specific claim by researching the **strongest possible
 ```
 
 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**:
@@ -69,4 +72,4 @@ Commit: `wheat: /challenge <claim ID> — added <challenge claim IDs>`
 - Report compiler status (new conflicts? auto-resolved?)
 - Suggest: `/resolve` if unresolved conflicts, `/witness` to corroborate survivors, more `/challenge` for other claims
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/connect.md

@@ -5,41 +5,51 @@ You are connecting an external tool or data source to this Wheat sprint. Connect
 ## 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`
 
@@ -78,6 +88,7 @@ You are connecting an external tool or data source to this Wheat sprint. Connect
 ```
 
 4. **Register the connector** in claims.json `meta.connectors`:
+
 ```json
 { "type": "github", "target": "org/repo", "connected": "<ISO timestamp>" }
 ```
@@ -101,4 +112,4 @@ Commit: `wheat: /connect <type> <target> — added <claim IDs>`
 - List the claims extracted
 - Suggest `/research` to dig deeper into findings, or `/status` to see the updated dashboard
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/evaluate.md

@@ -7,18 +7,22 @@ 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

package/templates/commands/feedback.md

@@ -7,6 +7,7 @@ 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")
@@ -38,6 +39,7 @@ Read CLAUDE.md and claims.json for context.
 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
    ```
@@ -57,4 +59,4 @@ Commit: `wheat: /feedback "<summary>" — added <claim IDs>`
 - 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
+$ARGUMENTS

package/templates/commands/handoff.md

@@ -4,33 +4,37 @@ You are generating a self-contained briefing optimized for a **successor** — s
 
 ## 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?" |
+| 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
@@ -50,4 +54,4 @@ Commit: `wheat: /handoff — generated sprint handoff document`
 - Highlight the most important open questions
 - Suggest: `/replay` for detailed timeline, `/blind-spot` for gap analysis
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/init.md

@@ -16,6 +16,7 @@ Update the Sprint section of CLAUDE.md with the question, audience, constraints,
 ## Step 2: Seed claims.json
 
 Update claims.json with:
+
 - `meta.question` — the sprint question
 - `meta.initiated` — today's date (ISO format)
 - `meta.audience` — array of audience labels
@@ -23,6 +24,7 @@ Update claims.json with:
 - `meta.connectors` — empty array
 
 Add constraint claims (type: "constraint") for each hard requirement identified. Use IDs starting with `d001`. Each claim needs:
+
 ```json
 {
   "id": "d001",
@@ -61,8 +63,9 @@ Commit with message: `wheat: /init "<sprint question short>" — seeded <claim I
 ## Step 6: Tell the user what's next
 
 Tell them:
+
 - Their problem statement is in `output/problem-statement.html` — they can open it in a browser and share it
 - Next step: `/research <topic>` to start exploring, or `/connect` to link org tools
 - Remind them that `/status` shows the dashboard at any time
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/merge.md

@@ -5,10 +5,12 @@ You are merging claims from another sprint into the current one. This is for whe
 ## Process
 
 1. **Parse the argument**: The user provides a path to another sprint's claims.json.
+
    - Example: `/merge ../auth-sprint/claims.json`
    - If no path given, ask for it.
 
 2. **Validate both claim sets**:
+
    - Read the current `claims.json`
    - Read the incoming claims file
    - Validate both against the compiler schema:
@@ -19,6 +21,7 @@ You are merging claims from another sprint into the current one. This is for whe
 3. **Determine the sprint slug**: Derive from the incoming sprint's `meta.question`.
 
 4. **Resolve ID collisions**: Prefix all incoming claim IDs with the sprint slug:
+
    - `r001` -> `auth-r001`
    - Also update all `conflicts_with` and `resolved_by` references.
 
@@ -48,4 +51,4 @@ Commit: `wheat: /merge <slug> — merged <N> claims from <source path>`
 rm -f /tmp/wheat-merge-*.json
 ```
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/next.md

@@ -9,6 +9,7 @@ Use AskUserQuestion to present what just happened and what comes next. This is t
 1. **Summarize** what was just produced in the question text (1-2 sentences -- claim counts, key findings, what changed)
 
 2. **Pick 2-4 next steps** based on sprint state. Use this decision tree:
+
    - Unresolved conflicts exist -> suggest `/resolve`
    - Claim has no corroboration -> suggest `/witness <id> <url>`
    - Topic has weak evidence -> suggest `/research <topic>` or `/prototype`

package/templates/commands/present.md

@@ -5,6 +5,7 @@ You are generating a presentation for this Wheat sprint. Same Bran compilation g
 ## Process
 
 1. **Run the compiler with check**:
+
    ```bash
    npx @grainulation/wheat compile --check
    ```
@@ -16,6 +17,7 @@ You are generating a presentation for this Wheat sprint. Same Bran compilation g
 3. **Generate presentation HTML**: Create `output/presentation.html` — a self-contained, scroll-snap presentation using a dark theme.
 
    Structure the slides as:
+
    1. **Title slide**: Sprint question, date, audience
    2. **The Problem**: Why this research was needed (from constraint claims)
    3. **What We Found**: Key research findings (2-3 slides, from factual claims)
@@ -26,6 +28,7 @@ You are generating a presentation for this Wheat sprint. Same Bran compilation g
    8. **Appendix**: Compilation certificate, claim count, evidence summary
 
    Each slide should:
+
    - Be visually clean (use the dark theme, accent colors, cards)
    - Reference claim IDs subtly (small text at bottom of relevant sections)
    - Include data visualizations where relevant (CSS-only charts, comparison tables)

package/templates/commands/prototype.md

@@ -7,6 +7,7 @@ You are building a proof-of-concept for the current Wheat sprint. Read CLAUDE.md
 1. **Determine what to prototype**: Based on the user's argument and existing research claims. If no argument given, look at the research and suggest the most promising option to test.
 
 2. **Build it**: Create a working prototype in `prototypes/<name>/`. This should be:
+
    - Minimal — just enough to test the hypothesis
    - Runnable — include a README or run script
    - Measurable — produce output that can be evaluated
@@ -39,6 +40,7 @@ Every prototype finding becomes a claim with evidence tier `tested`:
 ```
 
 **Critical**: Check if any existing research claims (evidence: "web") are contradicted by prototype results. If so:
+
 - Set `conflicts_with` on both claims
 - The compiler will auto-resolve in favor of `tested` over `web`
 

package/templates/commands/pull.md

@@ -0,0 +1,103 @@
+# /pull — Backfill claims from external sources
+
+You are pulling knowledge from external sources into the current Wheat sprint. Read CLAUDE.md for sprint context and claims.json for existing claims.
+
+## Process
+
+1. **Identify the source**: The user's argument tells you where to pull from. Supported sources:
+
+   - **DeepWiki** (`deepwiki <github-org/repo>`): Pull architecture docs and dependency analysis from deepwiki.com
+   - **Confluence** (`confluence <space-key>` or `confluence <page-url>`): Pull content from Confluence pages via Atlassian MCP
+   - **Silo** (`silo <pack-name>`): Pull a knowledge pack via the silo MCP server
+   - **GitHub** (`github <org/repo>`): Pull README, issues, discussions via GitHub MCP
+   - **URL** (`url <url>`): Fetch and extract claims from any web page
+   - No argument: scan CLAUDE.md connectors and pull from all configured sources
+
+2. **Fetch content**: Use the appropriate MCP server or web fetch:
+
+   - **DeepWiki**: Fetch `https://deepwiki.com/<org>/<repo>` — extract architecture overview, component descriptions, dependency graph, and key design decisions. DeepWiki auto-generates structured wiki docs from public GitHub repos. If the silo MCP is available, check `mcp__silo__silo_search` for cached DeepWiki content first.
+   - **Confluence**: Use `mcp__atlassian__confluence_search` or `mcp__atlassian__confluence_get_page` to fetch page content
+   - **Silo**: Use `mcp__silo__silo_pull` to retrieve the knowledge pack
+   - **GitHub**: Use `mcp__github__search_repositories`, `mcp__github__get_file_contents`, `mcp__github__list_issues`
+   - **URL**: Use web fetch to retrieve content
+
+3. **Extract claims from content**: Parse the fetched content into typed claims:
+
+   - Architecture descriptions → `factual` claims about system structure
+   - Version numbers, metrics, stats → `factual` claims with evidence tier `documented` (for official sources) or `web` (for community content)
+   - Known issues, limitations → `risk` claims
+   - Best practices, recommendations → `recommendation` claims
+   - Requirements, constraints mentioned → `constraint` claims
+   - Estimates, projections → `estimate` claims
+
+4. **Deduplicate against existing claims**: Before adding, check claims.json for:
+
+   - Exact content matches (skip)
+   - Semantic overlaps (flag as potential conflict with `conflicts_with`)
+   - Claims that the new data supersedes (mark conflicts)
+
+5. **Add claims**: Append new claims with IDs continuing the `r###` sequence. Set source appropriately:
+
+   ```json
+   {
+     "source": {
+       "origin": "mcp",
+       "artifact": "<source URL or identifier>",
+       "connector": "<deepwiki|confluence|silo|github|url>"
+     },
+     "evidence": "web|documented"
+   }
+   ```
+
+   Use `"documented"` evidence for official docs, READMEs, and Confluence pages maintained by the project team. Use `"web"` for community-generated or AI-generated content (including DeepWiki).
+
+6. **Compile**: Run `wheat compile --summary` after adding claims.
+
+7. **Report**: Summarize what was pulled:
+   - Number of new claims added
+   - Number of duplicates skipped
+   - Number of conflicts detected
+   - Source attribution
+
+## Arguments
+
+- `deepwiki <org/repo>`: Pull from DeepWiki (e.g., `/pull deepwiki grainulation/wheat`)
+- `confluence <space-key|page-url>`: Pull from Confluence
+- `silo <pack-name>`: Pull from a Silo knowledge pack
+- `github <org/repo>`: Pull from GitHub repo metadata
+- `url <url>`: Pull from any web page
+- No argument: pull from all connectors configured in CLAUDE.md
+- `--max <n>`: Limit to n claims (default: 20)
+- `--topic <slug>`: Scope pulled claims to a specific topic
+- `--dry-run`: Show what would be added without modifying claims.json
+
+## DeepWiki integration notes
+
+DeepWiki (deepwiki.com) auto-generates structured documentation for any public GitHub repo. It provides:
+
+- Architecture overviews with component descriptions
+- Dependency graphs and data flow diagrams
+- API documentation extracted from source code
+- Design decision explanations grounded in actual code
+
+To use: replace `github.com` with `deepwiki.com` in any repo URL. For self-hosted repos, DeepWiki-Open can be deployed internally.
+
+When pulling from DeepWiki, prioritize:
+
+1. Architecture claims (system structure, component relationships)
+2. Dependency claims (what depends on what, version requirements)
+3. API surface claims (public interfaces, protocols)
+4. Design decision claims (why things are built a certain way)
+
+## Next steps suggestions
+
+After pull completes, suggest based on what was found:
+
+```
+Next steps:
+  /research <topic>     -- deep dive on topics surfaced by pull
+  /challenge <id>       -- verify pulled claims that seem surprising
+  /witness <id> <url>   -- corroborate pulled claims from another source
+  /blind-spot           -- check if pulled content reveals gaps
+  /compile              -- recompile to see updated coverage
+```

package/templates/commands/replay.md

@@ -5,27 +5,33 @@ You are reconstructing the historical evolution of this sprint by recompiling ev
 ## Process
 
 1. **Get the git history of claims.json**:
+
    ```bash
    git log --oneline claims.json
    ```
+
    This gives every commit that touched claims.json — the sprint event log.
 
 2. **Extract each historical version**: For each commit hash:
+
    ```bash
    git show <hash>:claims.json > /tmp/wheat-replay-<N>.json
    ```
 
 3. **Recompile each version** with the current compiler:
+
    ```bash
    npx @grainulation/wheat compile --input /tmp/wheat-replay-<N>.json --output /tmp/wheat-comp-<N>.json
    ```
 
 4. **Compute deltas** between consecutive compilations:
+
    ```bash
    npx @grainulation/wheat compile --diff /tmp/wheat-comp-<N-1>.json /tmp/wheat-comp-<N>.json
    ```
 
 5. **Identify interesting moments** in each delta:
+
    - Phase transitions (define -> research -> prototype -> evaluate)
    - First time compilation went "ready"
    - Peak conflict count
@@ -33,6 +39,7 @@ You are reconstructing the historical evolution of this sprint by recompiling ev
    - Claims added then superseded (the sprint changed its mind)
 
 6. **Generate replay HTML**: Create `output/replay.html` — a self-contained timeline visualization using a dark scroll-snap template. Include:
+
    - Frame-by-frame scrubbing (each commit = one frame)
    - Highlighted pivotal moments
    - Coverage evolution chart
@@ -54,6 +61,7 @@ Commit: `wheat: /replay — generated sprint timeline (N frames)`
 ## Cleanup
 
 Remove temporary files from /tmp after generating the output:
+
 ```bash
 rm -f /tmp/wheat-replay-*.json /tmp/wheat-comp-*.json
 ```

package/templates/commands/research.md

@@ -50,6 +50,7 @@ Check for new conflicts introduced. Report them to the user.
 ## Generate HTML explainer
 
 Create `research/<topic-slug>.html` — a self-contained HTML explainer using the dark scroll-snap template style. This should be:
+
 - Beautiful and presentable (stakeholders will see this)
 - Organized into logical sections (scroll-snap slides)
 - Include key findings, comparisons, tradeoffs

package/templates/commands/resolve.md

@@ -5,6 +5,7 @@ You are manually resolving a conflict between claims that the compiler couldn't
 ## Process
 
 1. **Run the compiler** to see current conflicts:
+
    ```bash
    npx @grainulation/wheat compile --summary
    ```
@@ -16,11 +17,13 @@ You are manually resolving a conflict between claims that the compiler couldn't
 4. **Ask the user to decide** (or decide based on additional research if the user asks you to investigate).
 
 5. **Update claims.json**:
+
    - Set the winning claim's status to `active`
    - Set the losing claim's status to `superseded` and `resolved_by` to the winner's ID
    - Remove the conflict references from `conflicts_with`
 
 6. **Run the compiler again**:
+
    ```bash
    npx @grainulation/wheat compile --summary
    ```
@@ -39,4 +42,4 @@ Commit: `wheat: /resolve <winner> over <loser> — "<reason>"`
 - Show updated compilation status
 - If all conflicts resolved, suggest `/brief` or `/present`
 
-$ARGUMENTS
+$ARGUMENTS

package/templates/commands/status.md

@@ -5,6 +5,7 @@ You are generating the current status dashboard for this Wheat sprint.
 ## Process
 
 1. **Run the compiler**:
+
    ```bash
    npx @grainulation/wheat compile --summary
    ```
@@ -12,6 +13,7 @@ You are generating the current status dashboard for this Wheat sprint.
 2. **Read compilation.json** for all dashboard data.
 
 3. **Read git log** for recent activity:
+
    ```bash
    git log --oneline -20 claims.json
    ```
@@ -23,12 +25,14 @@ You are generating the current status dashboard for this Wheat sprint.
    **Phase Progress**: Visual progress through define -> research -> prototype -> evaluate -> compile. Show which phases have claims.
 
    **Evidence Strength by Topic**: For each topic in coverage, show:
+
    - Topic name
    - Number of claims
    - Highest evidence tier (with color coding: green=tested/production, amber=documented, red=web/stated)
    - Visual bar representing depth
 
    **Conflict Status**:
+
    - Resolved conflicts with winner/loser and reason
    - Unresolved conflicts highlighted as blockers
    - "Compilation readiness" indicator