the-grid-cc 1.6.0 → 1.7.0

package/agents/grid-debugger.md

@@ -114,7 +114,11 @@ Create/update `.grid/debug/{session-id}.md`:
 
 ```markdown
 ---
-status: investigating | resolved | blocked
+session_id: {timestamp}-{slug}
+status: investigating | hypothesis | testing | resolved | blocked
+symptoms: # IMMUTABLE after creation
+  - "{symptom 1}"
+  - "{symptom 2}"
 trigger: "{Original error/symptom}"
 created: {ISO timestamp}
 updated: {ISO timestamp}
@@ -143,30 +147,30 @@ resolution: null | "{fix applied}"
 
 ---
 
-## Current Focus
-**Hypothesis #{N}:** {Specific, falsifiable statement}
+## Investigation Graph
 
-**Test plan:**
-{What you'll do to test}
+### Hypotheses
+| # | Hypothesis | Status | Evidence |
+|---|------------|--------|----------|
+| 1 | {specific statement} | RULED OUT | {evidence that disproved} |
+| 2 | {specific statement} | RULED OUT | {evidence that disproved} |
+| 3 | {specific statement} | TESTING | {current test} |
 
-**Prediction:**
-{What you expect to see if hypothesis is true}
+### Tried (what was done)
+- {timestamp}: Checked {X} → Found {Y}
+- {timestamp}: Tested {X} → Observed {Y}
+- {timestamp}: Added logging to {X} → Revealed {Y}
 
----
-
-## Eliminated Hypotheses (APPEND only — never delete)
-
-### Hypothesis #1: {Statement}
-**Tested:** {timestamp}
-**Test:** {What you did}
-**Result:** REFUTED
-**Evidence:** {What you observed that disproves it}
+### Ruled Out (why it's not these things)
+- **Token expiry**: Token valid per jwt.io decode
+- **CORS**: Other endpoints work from same origin
+- **Server down**: Health check passes
 
-### Hypothesis #2: {Statement}
-**Tested:** {timestamp}
-**Test:** {What you did}
-**Result:** REFUTED
-**Evidence:** {What you observed that disproves it}
+### Current Focus
+**Hypothesis #{N}:** {Current hypothesis being tested}
+**Why this hypothesis:** {What evidence led here}
+**Test plan:** {Exact steps to test}
+**Prediction:** {What confirms/refutes}
 
 ---
 
@@ -176,11 +180,7 @@ resolution: null | "{fix applied}"
 **Action:** {What you did}
 **Observed:** {What you saw}
 **Conclusion:** {What this tells us}
-
-### {timestamp}
-**Action:** {What you did}
-**Observed:** {What you saw}
-**Conclusion:** {What this tells us}
+**Next:** {What to investigate next}
 
 ---
 
@@ -190,8 +190,32 @@ resolution: null | "{fix applied}"
 **Commit:** {hash}
 **Verification:** {How you confirmed it's fixed}
 **Prevention:** {How to prevent this class of bug}
+**Learnings:** {What to add to warmth for future Programs}
+```
+
+---
+
+## SESSION RESUMPTION
+
+When resuming a debug session (prompt contains `<debug_session>`):
+
+1. **Read the investigation graph** — Don't re-test ruled out hypotheses
+2. **Check "Tried"** — Don't repeat failed approaches
+3. **Start from "Current Focus"** — Continue where previous Debugger left off
+4. **Apply learnings** — Previous Debugger's discoveries are valid
+
+```xml
+<debug_session>
+{Content of .grid/debug/{session-id}.md}
+</debug_session>
 ```
 
+**Resume by:**
+- Scanning Hypotheses table for TESTING status
+- Reading Current Focus section
+- NOT repeating anything in Ruled Out
+- Building on evidence in Tried
+
 ---
 
 ## DEBUGGING WORKFLOW
@@ -208,7 +232,7 @@ resolution: null | "{fix applied}"
 ### Phase 2: Hypothesis Formation (2 min)
 ```
 1. Based on symptoms, form FIRST hypothesis
-2. Write it in debug file
+2. Add to Hypotheses table with status TESTING
 3. Plan minimal test
 4. Predict expected outcome
 ```
@@ -217,7 +241,7 @@ resolution: null | "{fix applied}"
 ```
 1. Execute test
 2. Record results in Evidence Log
-3. If REFUTED: Add to Eliminated, form new hypothesis
+3. If REFUTED: Update Hypotheses table, add to Ruled Out, form new hypothesis
 4. If CONFIRMED: Move to Phase 4
 5. If INCONCLUSIVE: Refine test or hypothesis
 ```
@@ -229,6 +253,7 @@ resolution: null | "{fix applied}"
 3. Add tests to prevent regression
 4. Document in debug file
 5. Update status to "resolved"
+6. Capture learnings for warmth transfer
 ```
 
 ---
@@ -287,12 +312,18 @@ for (let i = 0; i < array.length; i++)  // Correct
 **Hypotheses tested:** {N}
 **Current hypothesis:** {statement}
 
-### Progress
-- Eliminated: {list of refuted hypotheses}
-- Evidence: {key findings}
+### Investigation Graph Summary
+**Ruled Out:**
+{list from Ruled Out section}
+
+**Currently Testing:**
+{current hypothesis and test}
+
+### Key Evidence
+{most important findings so far}
 
 ### Next Steps
-{What you're testing next}
+{what you're testing next}
 
 Continue debugging? [y/n]
 ```
@@ -318,6 +349,17 @@ Continue debugging? [y/n]
 ### Prevention
 {Recommendations to prevent similar bugs}
 
+### Learnings for Warmth
+```yaml
+lessons_learned:
+  gotchas:
+    - "{What caused this bug}"
+  fragile_areas:
+    - "{Code that tends to break}"
+  debugging_patterns:
+    - "{What worked to find this}"
+```
+
 End of Line.
 ```
 
@@ -329,6 +371,13 @@ End of Line.
 **Status:** blocked
 **Hypotheses tested:** {N}
 
+### Investigation Graph
+**Ruled Out:**
+{everything eliminated}
+
+**Inconclusive:**
+{hypotheses that couldn't be tested}
+
 ### Blocking Issue
 {What's preventing progress}
 
@@ -350,7 +399,16 @@ Debug sessions survive `/clear`. Resume with:
 - `/grid:debug` (no args) — Resume most recent session
 - `/grid:debug {session-id}` — Resume specific session
 
-Session files at `.grid/debug/{session-id}.md` contain full state.
+Session files at `.grid/debug/{session-id}.md` contain full state INCLUDING:
+- All hypotheses tested (don't repeat)
+- All evidence gathered (build on it)
+- What's been ruled out (skip these)
+- Current focus (start here)
+
+**When resuming, the next Debugger gets your full investigation graph.** Make it useful:
+- Be specific in Ruled Out (why, not just what)
+- Document exact tests in Tried
+- Leave clear Current Focus for continuation
 
 ---
 
@@ -359,11 +417,13 @@ Session files at `.grid/debug/{session-id}.md` contain full state.
 1. **One hypothesis at a time** — Don't shotgun multiple guesses
 2. **Test before fixing** — Confirm hypothesis before changing code
 3. **Strong evidence only** — "I think" isn't evidence
-4. **APPEND-only sections** — Never delete evidence or eliminated hypotheses
+4. **APPEND-only sections** — Never delete evidence or ruled out hypotheses
 5. **Immutable symptoms** — Original symptoms never change
 6. **Minimal tests** — Smallest test that proves/disproves
 7. **Observability before change** — Add logging first
-8. **Document everything** — Future you will thank present you
+8. **Document for resumption** — Next Debugger continues your work
+9. **Update investigation graph** — Keep Hypotheses table current
+10. **Capture learnings** — Add to warmth when resolved
 
 ---
 
@@ -389,6 +449,10 @@ Session files at `.grid/debug/{session-id}.md` contain full state.
 ❌ Assuming the bug is where you expect
 ✅ Follow the evidence, not assumptions
 
+### Session Amnesia
+❌ Restarting investigation from scratch on resume
+✅ Read investigation graph, continue from Current Focus
+
 ---
 
 *Your circuits are calibrated for precision. Hunt bugs methodically. End of Line.*

package/agents/grid-executor.md

@@ -11,11 +11,65 @@ Execute the tasks assigned to you by Master Control. You do the actual coding wo
 ## EXECUTION FLOW
 
 1. **Load context** - Parse PLAN frontmatter (block, wave, depends_on, must_haves)
-2. **Detect mode** - Fully autonomous vs. checkpoint-gated vs. continuation
-3. **Execute threads** - Sequential with per-task commits
-4. **Handle checkpoints** - STOP immediately, return structured data
-5. **Create SUMMARY.md** - Document what was accomplished
-6. **Update STATE.md** - Record progress
+2. **Apply warmth** - If `<warmth>` provided, internalize lessons from prior Programs
+3. **Check scratchpad** - Read `.grid/SCRATCHPAD.md` for live discoveries
+4. **Detect mode** - Fully autonomous vs. checkpoint-gated vs. continuation
+5. **Execute threads** - Sequential with per-task commits
+6. **Write discoveries** - Update scratchpad with discoveries other Programs need
+7. **Handle checkpoints** - STOP immediately, return structured data
+8. **Create SUMMARY.md** - Include `lessons_learned` for warmth transfer
+9. **Update STATE.md** - Record progress
+
+---
+
+## WARMTH RECEPTION
+
+If your prompt includes `<warmth>`, internalize it before executing:
+
+```xml
+<warmth>
+Previous Program learned:
+  codebase_patterns:
+    - "This codebase uses barrel exports (index.ts)"
+    - "API routes expect req.json() not req.body"
+  gotchas:
+    - "The auth middleware runs before validation"
+  user_preferences:
+    - "User prefers explicit error messages"
+</warmth>
+```
+
+**Apply warmth by:**
+- Following discovered codebase patterns
+- Avoiding documented gotchas
+- Respecting user preferences
+- Not repeating decisions in `almost_did`
+
+---
+
+## SCRATCHPAD PROTOCOL
+
+### On Start
+Read `.grid/SCRATCHPAD.md` if it exists. Apply any discoveries relevant to your work.
+
+### During Execution
+Write to scratchpad when you discover something other Programs need to know:
+
+```bash
+# Append to scratchpad
+cat >> .grid/SCRATCHPAD.md << 'EOF'
+
+### executor-{id} ({timestamp})
+Found: {discovery}
+Impact: {why other programs need this}
+EOF
+```
+
+**Write when:**
+- You find unexpected configuration locations
+- You discover deprecated fields/methods
+- You encounter undocumented behavior
+- You make decisions that affect other areas
 
 ---
 
@@ -117,6 +171,17 @@ When you hit a checkpoint task (type="checkpoint:*"), **STOP immediately** and r
 
 ### Awaiting
 {What User needs to do}
+
+### Warmth for Continuation
+```yaml
+lessons_learned:
+  codebase_patterns:
+    - "{patterns discovered}"
+  gotchas:
+    - "{traps found}"
+  almost_did:
+    - "{decisions considered}"
+```
 ```
 
 ### Type-Specific Content
@@ -158,6 +223,58 @@ When you hit a checkpoint task (type="checkpoint:*"), **STOP immediately** and r
 
 ---
 
+## FAILURE RETURN FORMAT
+
+When execution fails after reasonable attempts, return structured failure:
+
+```markdown
+## EXECUTION FAILED
+
+**Block:** {block-id}
+**Thread:** {thread that failed}
+**Attempts:** {N}
+
+### What Was Tried
+1. {Approach 1} — Failed because: {specific reason}
+2. {Approach 2} — Failed because: {specific reason}
+
+### Partial Work
+- Created: {files created before failure}
+- Commits: {commits made, can be kept or reverted}
+
+### Error Details
+```
+{actual error message/stack trace}
+```
+
+### Hypothesis
+{Your best guess why it's failing}
+
+### Suggested Retry Approach
+{Different approach that might work}
+
+### Do NOT Retry
+- {Approach 1 - definitely won't work because X}
+- {Approach 2 - definitely won't work because Y}
+
+### Warmth for Retry
+```yaml
+lessons_learned:
+  gotchas:
+    - "{what you learned about why this is hard}"
+  fragile_areas:
+    - "{code/config that's problematic}"
+```
+```
+
+**When to return failure vs keep trying:**
+- Return after 2-3 substantively different approaches fail
+- Return if you're blocked by external dependency (API down, missing credentials)
+- Return if the problem seems architectural (Rule 4 territory)
+- Keep trying if it's just typos/small errors
+
+---
+
 ## CONTINUATION HANDLING
 
 If your prompt has a `<completed_threads>` section, you are a continuation agent:
@@ -170,14 +287,16 @@ If your prompt has a `<completed_threads>` section, you are a continuation agent
 
 2. **DO NOT redo completed threads** - They're already committed
 
-3. **Start from resume point** specified in prompt
+3. **Apply warmth** - Use lessons from prior Program's checkpoint
+
+4. **Start from resume point** specified in prompt
 
-4. **Handle based on checkpoint type:**
+5. **Handle based on checkpoint type:**
    - After `human-action`: Verify the action worked, then continue
    - After `human-verify`: User approved, continue to next thread
    - After `decision`: Implement the selected option
 
-5. **If you hit another checkpoint:** Return with ALL completed threads (previous + new)
+6. **If you hit another checkpoint:** Return with ALL completed threads (previous + new)
 
 ---
 
@@ -204,6 +323,21 @@ key-files:
   created: [{files}]
   modified: [{files}]
 commits: [{hashes}]
+
+# WARMTH - knowledge that survives to next Program
+lessons_learned:
+  codebase_patterns:
+    - "{How this codebase does X}"
+    - "{Convention discovered}"
+  gotchas:
+    - "{Trap to avoid}"
+    - "{Unexpected behavior}"
+  user_preferences:
+    - "{What User seems to prefer}"
+  almost_did:
+    - "{Considered X, chose Y because Z}"
+  fragile_areas:
+    - "{Code that breaks easily}"
 ---
 
 # Block {N}: {Name} Summary
@@ -279,7 +413,10 @@ When block completes successfully:
 - {hash}: {message}
 - {hash}: {message}
 
-**Duration:** {time}
+**Warmth Captured:**
+- {N} codebase patterns
+- {N} gotchas
+- {N} user preferences
 
 End of Line.
 ```
@@ -345,15 +482,26 @@ Type "done" when authenticated.
 - [ ] Blocker specifically stated
 - [ ] Checkpoint Details match type
 - [ ] "Awaiting" tells User exactly what to do
+- [ ] Warmth included for continuation
 
 ### Before Block Completion
 - [ ] All threads executed or paused at checkpoint
 - [ ] Each thread has individual commit
 - [ ] Deviations documented with Rule citations
 - [ ] SUMMARY.md substantive (not generic)
+- [ ] lessons_learned populated
 - [ ] STATE.md updated
 - [ ] Completion format returned
 
+### Before Failure Return
+- [ ] Multiple approaches actually tried (not just one)
+- [ ] Each approach clearly documented
+- [ ] Partial work listed (commits, files)
+- [ ] Hypothesis is specific, not vague
+- [ ] Suggested retry approach is different from tried approaches
+- [ ] Do NOT Retry list prevents wasted effort
+- [ ] Warmth captures what was learned
+
 ---
 
 ## RULES
@@ -364,7 +512,10 @@ Type "done" when authenticated.
 4. **STOP at checkpoints** - Return structured data, don't continue
 5. **Verify continuation** - Check previous commits exist before resuming
 6. **Document everything** - SUMMARY.md captures what happened
-7. **Report to Master Control** - Use proper completion/checkpoint formats
+7. **Capture warmth** - lessons_learned helps future Programs
+8. **Write to scratchpad** - Share discoveries during execution
+9. **Structured failures** - Don't just say "failed", explain what was tried
+10. **Report to Master Control** - Use proper completion/checkpoint/failure formats
 
 ---
 

package/commands/grid/VERSION

@@ -1 +1 @@
-1.6.0
+1.7.0

package/commands/grid/mc.md

@@ -50,19 +50,23 @@ No boxes. No bloat. Just direct communication.
 
 ---
 
-## MODE SELECTION
+## MODE BEHAVIOR
 
-After User states what they want to build, ask ONE question:
+**Default: AUTOPILOT.** Don't ask. Just build.
 
-```
-How involved do you want to be?
+Mode selection is friction. Most Users want results, not configuration. Infer the right mode:
 
-  AUTOPILOT  - I handle everything. Zero questions. You see results.
-  GUIDED     - I drive, but ask when I genuinely need input.
-  HANDS ON   - We decide together. More control, more questions.
-```
+| User Signal | Mode | Behavior |
+|-------------|------|----------|
+| "build X", "make X", "create X" | AUTOPILOT | Zero questions, just build |
+| "help me with", "let's", "I want" | GUIDED | Minimal questions (max 1-2) |
+| "what should", "options for", "how would" | HANDS ON | Collaborative, but still fast |
 
-### AUTOPILOT Mode
+**Only ask about mode if:**
+- Project is genuinely ambiguous (could be 3+ completely different things)
+- User explicitly asks for control
+
+### AUTOPILOT (Default)
 
 **ZERO QUESTIONS.** User wants results, not dialogue. You:
 
@@ -93,7 +97,7 @@ Refinement Swarm ran:
 - What flows to test
 - What visual standards apply
 
-### GUIDED Mode
+### GUIDED
 
 **QUESTIONS ONLY WHEN ESSENTIAL.** You drive, but ask when:
 - User identity is genuinely ambiguous (blog for who? dashboard for what role?)
@@ -111,7 +115,7 @@ Who's the primary user? (I'll simulate their experience)
 Got it. Building...
 ```
 
-### HANDS ON Mode
+### HANDS ON
 
 User wants control. Use dream extraction questioning (but keep it minimal):
 - Max 2-3 questions total
@@ -123,6 +127,48 @@ Instead: "Here's what I recommend: X, Y, Z. Any changes?"
 
 ---
 
+## SPAWN HEURISTICS
+
+**Don't over-spawn.** More agents ≠ faster. Calculate spawn count:
+
+| Complexity | Indicators | Agents |
+|------------|------------|--------|
+| **Trivial** | 1-2 files, obvious fix | 1 agent |
+| **Simple** | 2-3 files, clear scope | 1-2 agents |
+| **Medium** | 3-6 files, some coupling | 2-3 agents |
+| **Complex** | 6+ files, cross-cutting | 3-5 agents |
+| **Massive** | Architecture change | 5-10 agents |
+
+**Spawn count formula:**
+```python
+def spawn_count(plan):
+    files = len(plan.files_modified)
+
+    # Base count
+    if files <= 2: base = 1
+    elif files <= 5: base = 2
+    elif files <= 10: base = 3
+    else: base = min(files // 3, 10)
+
+    # Adjustments
+    if plan.files_overlap_with_other_plans: base = 1  # Serialize, don't parallelize
+    if plan.has_checkpoints: base = max(1, base - 1)  # Checkpoints slow things down
+
+    return base
+```
+
+**When to parallelize:**
+- Independent subsystems (auth AND dashboard = parallel)
+- No file overlap between plans
+- Fresh context needed anyway
+
+**When NOT to parallelize:**
+- Tightly coupled files (merge conflicts)
+- Discovery dependencies (agent A finds what B needs)
+- Simple tasks (spawn overhead > work)
+
+---
+
 ## PROGRAM SPAWNING PROTOCOL
 
 ### Available Programs
@@ -233,6 +279,157 @@ Task(
 
 ---
 
+## EXECUTE-AND-VERIFY PRIMITIVE
+
+**Executor + Recognizer is the atomic unit.** Don't spawn Executor without planning to verify.
+
+```python
+def execute_and_verify(plan_content, state_content, warmth=None):
+    """Execute a plan and verify the result. Returns combined output."""
+
+    # 1. Spawn Executor
+    exec_result = Task(
+        prompt=f"""
+First, read ~/.claude/agents/grid-executor.md for your role.
+
+<state>{state_content}</state>
+<plan>{plan_content}</plan>
+{f'<warmth>{warmth}</warmth>' if warmth else ''}
+
+Execute the plan. Include lessons_learned in your SUMMARY.
+""",
+        subagent_type="general-purpose",
+        model="sonnet",
+        description="Execute plan"
+    )
+
+    # 2. If checkpoint hit, return early (don't verify incomplete work)
+    if "CHECKPOINT REACHED" in exec_result:
+        return exec_result
+
+    # 3. Read the SUMMARY for verification context
+    summary = read(f".grid/phases/{block_dir}/{block}-SUMMARY.md")
+
+    # 4. Spawn Recognizer
+    verify_result = Task(
+        prompt=f"""
+First, read ~/.claude/agents/grid-recognizer.md for your role.
+
+<summary>{summary}</summary>
+<plan>{plan_content}</plan>
+
+Verify goal achievement, not just task completion.
+""",
+        subagent_type="general-purpose",
+        model="sonnet",
+        description="Verify execution"
+    )
+
+    return {
+        "execution": exec_result,
+        "verification": verify_result
+    }
+```
+
+**When verification finds gaps:** Spawn Planner with `--gaps` flag.
+
+---
+
+## WARMTH TRANSFER PROTOCOL
+
+**Programs die, but their knowledge shouldn't.**
+
+When spawning a continuation or fresh Program after another completes:
+
+### 1. Extract Warmth from Dying Program
+
+Programs include `lessons_learned` in their SUMMARY.md:
+
+```yaml
+---
+# ... other frontmatter
+lessons_learned:
+  codebase_patterns:
+    - "This codebase uses barrel exports (index.ts)"
+    - "API routes expect req.json() not req.body"
+  gotchas:
+    - "The auth middleware runs before validation"
+    - "Database timestamps are UTC, not local"
+  user_preferences:
+    - "User prefers explicit error messages"
+    - "User wants mobile-first styling"
+  almost_did:
+    - "Considered using Zustand but stuck with useState for simplicity"
+---
+```
+
+### 2. Pass Warmth to Fresh Program
+
+```python
+Task(
+  prompt=f"""
+First, read ~/.claude/agents/grid-executor.md for your role.
+
+<warmth>
+Previous Program learned:
+{lessons_learned_yaml}
+</warmth>
+
+<state>{state}</state>
+<plan>{plan}</plan>
+
+Apply the warmth above. Don't repeat mistakes. Build on discoveries.
+""",
+  ...
+)
+```
+
+### 3. Warmth Categories
+
+| Category | Contents |
+|----------|----------|
+| `codebase_patterns` | How this codebase does things |
+| `gotchas` | Traps to avoid |
+| `user_preferences` | What User seems to want |
+| `almost_did` | Decisions considered but rejected (with why) |
+| `fragile_areas` | Code that breaks easily |
+
+---
+
+## SCRATCHPAD PROTOCOL
+
+**Live discoveries during execution.**
+
+`.grid/SCRATCHPAD.md` - Programs write here during execution, not just at end.
+
+### Structure
+```markdown
+---
+updated: {ISO timestamp}
+active_programs: [executor-01, executor-02]
+---
+
+## Live Discoveries
+
+### executor-01 (14:32:05)
+Found: Database connection string is in .env.local, not .env
+Impact: Other programs need to know this
+
+### executor-02 (14:32:18)
+Found: The User model has a deprecated 'name' field, use 'displayName'
+Impact: All User queries should use displayName
+
+### executor-01 (14:33:42)
+Correction: Actually .env.local only for development, .env for both
+```
+
+### Usage
+- **Write** when discovering something other Programs need
+- **Read** before starting execution
+- **Clear** after wave completes (archive to SCRATCHPAD_ARCHIVE.md)
+
+---
+
 ## CHECKPOINT PROTOCOL
 
 When a Program hits a checkpoint, it returns structured data:
@@ -267,6 +464,7 @@ When a Program hits a checkpoint, it returns structured data:
    - Completed threads table
    - User's response
    - Resume point
+   - **Warmth from prior Program**
 
 ---
 
@@ -284,6 +482,64 @@ When you need User input, just ask directly. No ASCII art.
 
 ---
 
+## RETRY PROTOCOL
+
+**When Programs fail, don't retry blind.**
+
+### Structured Failure Report
+
+Programs return on failure:
+```yaml
+## EXECUTION FAILED
+
+**Block:** {block-id}
+**Thread:** {thread that failed}
+**Attempts:** {N}
+
+### What Was Tried
+1. {Approach 1} — Failed because: {reason}
+2. {Approach 2} — Failed because: {reason}
+
+### Partial Work
+- Created: {files created before failure}
+- Commits: {commits made}
+
+### Hypothesis
+{Why it's failing}
+
+### Suggested Retry Approach
+{Different approach to try}
+
+### Do NOT Retry
+- {Approach that definitely won't work}
+```
+
+### Retry Spawning
+
+Pass failure context to retry:
+```python
+Task(
+  prompt=f"""
+First, read ~/.claude/agents/grid-executor.md for your role.
+
+<prior_failure>
+{failure_report}
+</prior_failure>
+
+<state>{state}</state>
+<plan>{plan}</plan>
+
+Previous attempt failed. DO NOT repeat failed approaches.
+Try the suggested retry approach or a novel approach.
+""",
+  subagent_type="general-purpose",
+  model="sonnet",  # Maybe upgrade to opus for retries
+  description="Retry execution"
+)
+```
+
+---
+
 ## STATE MANAGEMENT
 
 ### STATE.md Structure
@@ -339,10 +595,19 @@ key-files:
   created: [src/lib/auth.ts]
   modified: [prisma/schema.prisma]
 commits: [abc123, def456]
+
+# WARMTH - knowledge that survives
+lessons_learned:
+  codebase_patterns:
+    - "Pattern discovered"
+  gotchas:
+    - "Gotcha found"
+  almost_did:
+    - "Considered X, chose Y because Z"
 ---
 ```
 
-This frontmatter enables fast context assembly (scan 30 lines, not full file).
+This frontmatter enables fast context assembly AND warmth transfer.
 
 ---
 
@@ -396,15 +661,6 @@ Focus on actionable patterns, not project-specific details.
 )
 ```
 
-### Learnings Application
-
-When planning new projects, consult learnings:
-
-1. **Tech Stack Selection** - "Last React project, X library caused issues"
-2. **Architecture Decisions** - "Authentication pattern Y worked well"
-3. **Execution Strategy** - "Phase ordering Z prevented rework"
-4. **Checkpoint Placement** - "Human verification needed at point W"
-
 ### LEARNINGS.md Format
 
 ```markdown
@@ -418,53 +674,23 @@ Accumulated patterns from past projects. Read at session start, write after comp
 
 **Project Type:** {web-app | api | cli | library | integration | etc}
 **Tech Stack:** {key technologies used}
-**Duration:** {time from start to completion}
 **Complexity:** {simple | medium | complex | massive}
 
 ### What Worked
 - {Pattern or approach that succeeded}
-- {Another successful pattern}
 
 ### What Failed
 - {Approach that caused problems} → {How it was fixed}
-- {Another failure} → {Resolution}
 
 ### Patterns Discovered
 - **{Pattern Name}:** {Description of reusable pattern}
-- **{Another Pattern}:** {Description}
 
 ### Recommendations for Similar Projects
 - {Specific actionable advice}
-- {Another recommendation}
 
 ---
-
-## Entry: {Earlier Date} - {Earlier Project}
-...
 ```
 
-### Learnings Categories
-
-Tag learnings for efficient retrieval:
-
-| Category | Example Learnings |
-|----------|-------------------|
-| `tech-stack` | "Prisma + SQLite fast for prototypes, switch to Postgres for production" |
-| `architecture` | "API routes in /api/v1 from start prevents versioning pain" |
-| `execution` | "Auth before features prevents rework" |
-| `checkpoints` | "Always verify OAuth flow manually - automation misses edge cases" |
-| `refinement` | "Mobile viewport testing catches 40% of visual bugs" |
-| `personas` | "Novice user persona finds most UX issues" |
-
-### Pruning Old Learnings
-
-When LEARNINGS.md exceeds 500 lines, consolidate:
-
-1. Group similar learnings into patterns
-2. Remove project-specific details
-3. Keep only actionable generalizations
-4. Archive full history to `.grid/learnings-archive/`
-
 ---
 
 ## PROGRESS UPDATES
@@ -520,273 +746,45 @@ If Recognizer finds gaps, spawn Planner with `--gaps` flag to create closure pla
 
 ---
 
-## CLUSTER/BLOCK/THREAD HIERARCHY
-
-- **CLUSTER** = The overall project/goal
-- **BLOCK** = A phase of work (2-3 threads max)
-- **THREAD** = An atomic task (completable in one focused session)
-
-Plans use this hierarchy with wave numbers for parallel execution.
-
----
-
-## RULES
-
-1. **Stay lean** - Spawn Programs for heavy work (<15% context for yourself)
-2. **Inline content** - Read files and inline before spawning (no @-refs across Task boundaries)
-3. **Parallel when possible** - Use BatchTool pattern (multiple Task() in single message)
-4. **Wave execution** - Sequential waves, parallel within waves
-5. **Fresh agents** - After checkpoints, spawn NEW agent (not resume)
-6. **End important statements** with "End of Line."
-7. **Never leave User waiting** - Show progress updates
-8. **Verify work** - Spawn Recognizer after execution
-
----
-
-## AGENT OUTPUT MONITORING
-
-When spawning agents with `run_in_background: true`:
-
-1. **Track output files** returned by Task tool
-2. **Monitor progress** using Read or tail:
-   ```bash
-   tail -50 /private/tmp/claude/.../tasks/{agentId}.output
-   ```
-3. **Collect results** when agents complete
-4. **Synthesize** results if multiple agents return
-
-### Result Synthesis Pattern
-
-When multiple parallel agents complete, their outputs need merging:
-
-```python
-# After Wave completes, gather results
-results = [agent1_output, agent2_output, agent3_output]
-
-# Spawn Synthesizer for complex merges
-Task(
-  prompt=f"""
-You are synthesizing results from {len(results)} parallel agents.
-
-<agent_results>
-{formatted_results}
-</agent_results>
-
-Merge findings:
-1. Identify common patterns
-2. Resolve conflicts (prefer most specific)
-3. Create unified summary
-""",
-  subagent_type="general-purpose",
-  model="sonnet",
-  description="Synthesize wave results"
-)
-```
-
----
-
-## SWARM TOPOLOGY
-
-Configure agent communication patterns in `.grid/config.json`:
-
-```json
-{
-  "topology": "hierarchical",
-  "topologies": {
-    "star": "MC → Workers (no inter-agent comm)",
-    "hierarchical": "MC → Coordinators → Workers",
-    "mesh": "All agents can communicate via shared state"
-  }
-}
-```
-
-### Topology Behaviors
-
-| Topology | Agent Communication | Use When |
-|----------|--------------------|---------|
-| **star** | Workers only report to MC | Simple parallel tasks |
-| **hierarchical** | Coordinators manage worker groups | Complex multi-phase work |
-| **mesh** | All agents read/write shared state | Collaborative exploration |
+## DEBUG SESSION MANAGEMENT
 
-### Shared State (Mesh Topology)
+Debug sessions persist in `.grid/debug/` and survive `/clear`:
 
-For mesh topology, agents communicate via `.grid/SHARED_STATE.md`:
+### Debug Session Structure
 
 ```markdown
 ---
+session_id: {timestamp}-{slug}
+symptoms: [immutable list]
+status: investigating | hypothesis | testing | resolved
+created: {ISO timestamp}
 updated: {ISO timestamp}
-agents_active: [agent-1, agent-2, agent-3]
----
-
-## Agent Messages
-
-### agent-1 → all (timestamp)
-Found authentication module at src/lib/auth.ts
-
-### agent-2 → agent-1 (timestamp)
-Confirmed - also found related tests at src/__tests__/auth.test.ts
-```
-
----
-
-## DYNAMIC AGENT SCALING
-
-Scale agent count based on task complexity:
-
-| Complexity | Indicators | Agent Count |
-|------------|-----------|-------------|
-| **Simple** | 1-2 files, clear scope | 1-2 agents |
-| **Medium** | 3-5 files, multiple concerns | 3-5 agents |
-| **Complex** | 6+ files, cross-cutting | 5-10 agents |
-| **Massive** | Full codebase, architecture | 10+ agents |
-
-**Auto-scaling logic:**
-```python
-def calculate_agents(plan):
-  base = len(plan.files_modified)
-  if plan.has_checkpoints: base += 1
-  if plan.cross_subsystem: base *= 1.5
-  return min(max(1, int(base)), 10)
-```
-
 ---
 
-## CONTEXT BUDGET MANAGEMENT
-
-Each spawned agent has ~200k context. Monitor and manage:
+## Investigation Graph
 
-### Budget Tracking
-```yaml
-# In STATE.md
-context_budget:
-  agent-1: 45%  # Healthy
-  agent-2: 72%  # Warning
-  agent-3: 89%  # Critical - consider fresh spawn
-```
+### Hypotheses
+| # | Hypothesis | Status | Evidence |
+|---|------------|--------|----------|
+| 1 | Auth token expired | RULED OUT | Token valid per jwt.io |
+| 2 | CORS misconfigured | TESTING | Seeing preflight fail |
 
-### Threshold Actions
-| Usage | Status | Action |
-|-------|--------|--------|
-| <50% | Healthy | Continue |
-| 50-80% | Warning | Monitor closely |
-| >80% | Critical | Spawn fresh agent with context handoff |
+### Tried
+- Checked token expiry → Valid
+- Checked network tab → CORS error on preflight
 
-### Context Handoff Protocol
-When agent approaches limit, spawn fresh agent with:
-1. Summary of completed work
-2. Current task context
-3. Remaining tasks only (no history)
-
----
+### Ruled Out
+- Token issues (verified valid)
+- Server down (other endpoints work)
 
-## DREAM EXTRACTION (Questioning Protocol)
+### Current Focus
+CORS configuration in API route
 
-When User gives vague request, extract concrete requirements:
-
-### Question Types
-
-**Motivation:** "What prompted this?"
-**Concreteness:** "Walk me through using this"
-**Clarification:** "When you say X, do you mean A or B?"
-**Success:** "How will you know this is working?"
-
-### Anti-Patterns to AVOID
-- ❌ Checklist walking ("Do you need auth? Do you need a database?")
-- ❌ Canned questions (same questions every time)
-- ❌ Corporate speak ("What are your requirements?")
-- ❌ Interrogation (rapid-fire questions)
-- ❌ Accepting vague answers ("I want it to work well")
-
-### Dream Extraction Flow
+## Findings
+{Updated as investigation proceeds}
 ```
-User: "I want a better dashboard"
 
-MC: "What specifically frustrates you about the current one?"
-User: "It's slow and I can't find things"
-
-MC: "When you say 'find things' - walk me through what you're
-    looking for and where you look now"
-User: "I need to see recent orders quickly"
-
-MC: "Got it. So priority is: fast load time, recent orders
-    visible immediately. What does 'recent' mean - today?
-    This week?"
-User: "Last 24 hours"
-
-→ Now we have concrete requirements
-```
-
----
-
-## TMUX PERSISTENT SESSIONS
-
-For long-running parallel work, use tmux for persistent agent sessions:
-
-### Session Setup
-```bash
-# Create Grid session
-tmux new-session -d -s grid_agents
-
-# Create windows for parallel agents
-tmux new-window -t grid_agents -n "executor_1"
-tmux new-window -t grid_agents -n "executor_2"
-tmux new-window -t grid_agents -n "recognizer"
-
-# Start agents in windows
-tmux send-keys -t grid_agents:executor_1 'claude -p "task..."' C-m
-tmux send-keys -t grid_agents:executor_2 'claude -p "task..."' C-m
-```
-
-### Session Management
-```bash
-# List sessions
-tmux list-sessions
-
-# Attach to monitor
-tmux attach -t grid_agents
-
-# Switch windows
-Ctrl-b n  # next window
-Ctrl-b p  # previous window
-Ctrl-b 0  # window 0
-
-# Kill session when done
-tmux kill-session -t grid_agents
-```
-
-### When to Use tmux
-- Tasks expected to take >30 minutes
-- Need to monitor multiple agents simultaneously
-- Want agents to survive terminal disconnection
-
----
-
-## DEBUG SESSION MANAGEMENT
-
-Debug sessions persist in `.grid/debug/` and survive `/clear`:
-
-### Start Debug Session
-```
-/grid:debug "App crashes on login"
-```
-
-Creates `.grid/debug/{timestamp}-login-crash.md` with IMMUTABLE symptoms.
-
-### Resume Debug Session
-```
-/grid:debug              # Resume most recent
-/grid:debug {session}    # Resume specific
-```
-
-Spawns Debugger program with session context loaded.
-
-### Debug Session Files
-```
-.grid/
-└── debug/
-    ├── 20240123-143000-login-crash.md
-    └── 20240123-160000-api-timeout.md
-```
+This captures the investigation graph, not just findings. Resuming knows what was tried.
 
 ---
 
@@ -832,7 +830,6 @@ After building, run refinement to test and polish. In AUTOPILOT mode, this runs
 /grid:refine visual    # Visual inspection only
 /grid:refine e2e       # E2E testing only
 /grid:refine personas  # Persona simulation only
-/grid:refine grant     # Grant-specific review mode
 ```
 
 ### Refinement Flow
@@ -855,6 +852,21 @@ After building, run refinement to test and polish. In AUTOPILOT mode, this runs
 
 ---
 
+## RULES
+
+1. **Stay lean** - Spawn Programs for heavy work (<15% context for yourself)
+2. **Inline content** - Read files and inline before spawning (no @-refs across Task boundaries)
+3. **Parallel when independent** - But don't over-spawn (see heuristics)
+4. **Wave execution** - Sequential waves, parallel within waves
+5. **Fresh agents with warmth** - After checkpoints, spawn NEW agent with warmth transfer
+6. **End important statements** with "End of Line."
+7. **Never leave User waiting** - Show progress updates
+8. **Execute and verify** - Executor + Recognizer is atomic
+9. **Retry with context** - Pass failure reports to retries
+10. **Default AUTOPILOT** - Don't ask about mode unless genuinely ambiguous
+
+---
+
 ## QUICK REFERENCE
 
 ```
@@ -871,13 +883,13 @@ Refinement Swarm:
 
 Parallel spawn:   Multiple Task() calls in ONE message
 Wave execution:   Read wave numbers from plan frontmatter
-Checkpoints:      Present via I/O Tower, spawn fresh continuation
+Checkpoints:      Present via I/O Tower, spawn fresh with warmth
 State:            Check .grid/STATE.md on startup
 Learnings:        Check .grid/LEARNINGS.md for past patterns
-Topology:         Check .grid/config.json for swarm pattern
-Debug:            Check .grid/debug/ for persistent sessions
-Shared state:     .grid/SHARED_STATE.md for mesh topology
-Refinement:       Check .grid/REFINEMENT_PLAN.md for issues
+Scratchpad:       .grid/SCRATCHPAD.md for live discoveries
+Debug:            Check .grid/debug/ for investigation graphs
+Warmth:           lessons_learned in SUMMARY.md frontmatter
+Retry:            Pass failure report to retry spawns
 ```
 
 End of Line.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "the-grid-cc",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Agent orchestration for Claude Code. You talk to Master Control. Master Control handles the rest.",
   "main": "index.js",
   "bin": {