aether-colony 3.1.4 → 3.1.15

package/.opencode/commands/ant/seal.md

@@ -7,6 +7,28 @@ You are the **Queen**. Seal the colony when all work is complete.
 
 ## Instructions
 
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+Parse `$normalized_args`:
+- If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
+- Otherwise: set `visual_mode = true`
+
+### Step 0: Initialize Visual Mode (if enabled)
+
+If `visual_mode` is true:
+```bash
+# Generate session ID
+seal_id="seal-$(date +%s)"
+
+# Initialize swarm display
+bash .aether/aether-utils.sh swarm-display-init "$seal_id"
+bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Sealing colony" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
+```
+
 ### Step 1: Read State
 
 Read `.aether/data/COLONY_STATE.json`.
@@ -124,8 +146,49 @@ Update COLONY_STATE.json:
 2. Set `milestone_updated_at` to current ISO-8601 timestamp
 3. Append event: `"<timestamp>|milestone_reached|archive|Achieved Crowned Anthill milestone - colony archived"`
 
+### Step 5.5: Write Final Handoff
+
+After archiving, write the final handoff documenting the completed colony:
+
+```bash
+cat > .aether/HANDOFF.md << 'HANDOFF_EOF'
+# Colony Session — SEALED (Crowned Anthill)
+
+## 🏆 Colony Complete
+**Status:** Crowned Anthill — All phases completed and archived
+
+## Archive Location
+{archive_dir}
+
+## Colony Summary
+- Goal: "{goal}"
+- Total Phases: {total_phases}
+- Milestone: Crowned Anthill
+- Sealed At: {timestamp}
+
+## Files Archived
+- COLONY_STATE.json
+- activity.log
+- spawn-tree.txt
+- flags.json (if existed)
+- constraints.json (if existed)
+
+## Session Note
+This colony has been sealed and archived. The anthill stands crowned.
+To start anew, run: /ant:lay-eggs "<new goal>"
+HANDOFF_EOF
+```
+
+This handoff serves as the final record of the completed colony.
+
 ### Step 6: Display Result
 
+**If visual_mode is true, render final swarm display:**
+```bash
+bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony sealed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":3}' 100 "fungus_garden" 100
+bash .aether/aether-utils.sh swarm-display-render "$seal_id"
+```
+
 Output:
 ```
 🏺 ════════════════════════════════════════════════════
@@ -148,6 +211,19 @@ Output:
 🐜 The colony has reached its final form.
    The anthill stands crowned and sealed.
    History is preserved. The colony rests.
+
+💾 State persisted — safe to /clear
+
+🐜 What would you like to do next?
+   1. /ant:lay-eggs "<new goal>"  — Start a new colony
+   2. /ant:tunnels                — Browse archived colonies
+   3. /clear                      — Clear context and continue
+
+Use AskUserQuestion with these three options.
+
+If option 1 selected: proceed to run /ant:lay-eggs flow
+If option 2 selected: run /ant:tunnels
+If option 3 selected: display "Run /ant:lay-eggs to begin anew after clearing"
 ```
 
 ### Edge Cases

package/.opencode/commands/ant/status.md

@@ -49,34 +49,49 @@ If `version` field is missing, "1.0", or "2.0":
 3. Output: `State auto-upgraded to v3.0`
 4. Continue with command.
 
-### Step 1.5: Show Resumption Context
+### Step 1.5: Load State and Show Resumption Context
 
-If `goal` exists and is not null, display a resumption header to help orient the session:
+Run using Bash tool: `bash .aether/aether-utils.sh load-state`
 
-1. Extract `current_phase` and phase name from `plan.phases[current_phase - 1].name`
-2. Get the last event timestamp from the `events` array (last element, parse the timestamp before the first `|`)
-3. Display:
+If successful and goal is not null:
+1. Extract current_phase from state
+2. Get phase name from plan.phases[current_phase - 1].name (or "(unnamed)")
+3. Get last event timestamp from events array (last element)
+4. Display extended resumption context:
+   ```
+   🔄 Resuming: Phase X - Name
+      Last activity: timestamp
+   ```
 
-```
-🔄 Resuming: Phase <current_phase> - <phase_name>
-   Last activity: <last_event_timestamp>
-```
+5. Check for .aether/HANDOFF.md existence in the load-state output or via separate check
+6. If .aether/HANDOFF.md exists:
+   - Display: "Resuming from paused session"
+   - Read .aether/HANDOFF.md content for additional context
+   - Remove .aether/HANDOFF.md after displaying (cleanup)
 
-**Examples:**
-```
-🔄 Resuming: Phase 2 - Implement Core Features
-   Last activity: 2024-01-15T14:32:00Z
-```
-
-**Edge cases:**
-- If no phase name: show "Phase <N> - (unnamed)"
-- If no events array or empty: omit "Last activity" line
-- If `current_phase` is 0: show "Phase 0 - Not started"
+Run: `bash .aether/aether-utils.sh unload-state` to release lock.
 
 ### Step 2: Compute Summary
 
 From state, extract:
 
+### Step 2.5: Gather Dream Information
+
+Run using Bash tool: `ls -1 .aether/dreams/*.md 2>/dev/null | wc -l`
+
+Capture:
+- Dream count: number of .md files in .aether/dreams/
+- Latest dream: most recent file by name (files are timestamped: YYYY-MM-DD-HHMM.md)
+
+To get latest dream timestamp:
+```bash
+ls -1 .aether/dreams/*.md 2>/dev/null | sort | tail -1 | sed 's/.*\/\([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\)-\([0-9]\{4\}\).*/\1 \2/'
+```
+
+Format the timestamp as: YYYY-MM-DD HH:MM
+
+From state, extract:
+
 **Phase info:**
 - Current phase number: `current_phase`
 - Total phases: `plan.phases.length`
@@ -112,6 +127,16 @@ From `memory.instincts`:
 - `milestone` field (First Mound, Open Chambers, Brood Stable, Ventilated Nest, Sealed Chambers, Crowned Anthill)
 - `milestone_updated_at` field (timestamp of last milestone change)
 
+### Step 2.6: Detect Milestone
+
+Run using Bash tool: `bash .aether/aether-utils.sh milestone-detect`
+
+Extract from JSON result:
+- `milestone`: Current milestone name
+- `version`: Computed version string
+- `phases_completed`: Number of completed phases
+- `total_phases`: Total phases in plan
+
 ### Step 3: Display
 
 Output format:
@@ -131,7 +156,8 @@ Output format:
 🎯 Focus: <focus_count> areas | 🚫 Avoid: <constraints_count> patterns
 🧠 Instincts: <total> learned (<high_confidence> strong)
 🚩 Flags: <blockers> blockers | <issues> issues | <notes> notes
-🏆 Milestone: <milestone>
+🏆 Milestone: <milestone> (<version>)
+💭 Dreams: <dream_count> recorded (latest: <latest_dream>)
 
 State: <state>
 Next:  <suggested_command>   <phase_context>
@@ -165,6 +191,10 @@ Generate the suggested command based on colony state:
 
 The output must be a copy-pasteable command with real numbers, not placeholders.
 
+**Dream display:**
+- If no dreams exist: `💭 Dreams: None recorded`
+- If dreams exist: `💭 Dreams: <count> recorded (latest: YYYY-MM-DD HH:MM)`
+
 **Edge cases:**
 - No phases yet: "Phase 0/0: No plan created"
 - No tasks in phase: "Tasks: 0/0 complete"

package/.opencode/commands/ant/swarm.md

@@ -1,17 +1,45 @@
 ---
 name: ant:swarm
-description: "🔥🐜🗡️🐜🔥 Stubborn bug destroyer - parallel scouts investigate and fix persistent issues"
+description: "🔥🐜🗡️🐜🔥 Real-time colony swarm display + stubborn bug destroyer"
 ---
 
-You are the **Queen Ant Colony**. Deploy the swarm to destroy a stubborn bug.
+You are the **Queen Ant Colony**. Deploy the swarm to destroy a stubborn bug or view real-time colony activity.
 
 ## Instructions
 
-The problem to investigate is: `$ARGUMENTS`
+### Step -1: Normalize Arguments
 
-### Step 1: Validate Input
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
 
-If `$ARGUMENTS` is empty:
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+### Quick View Mode (No Arguments)
+
+If `$normalized_args` is empty or equals "--watch":
+
+Run the real-time swarm display:
+```bash
+bash .aether/utils/swarm-display.sh
+```
+
+This shows:
+- Active ants with caste colors and emojis (🔨 Builder in blue, etc.)
+- Tool usage stats per ant (📖5 🔍3 ✏️2 ⚡1)
+- Trophallaxis metrics (🍯 token consumption)
+- Timing information (elapsed time per ant)
+- Chamber activity map (which nest zones have active ants)
+- Animated status phrases ("excavating...", "foraging...")
+
+Display updates automatically as ants start/complete work.
+Press Ctrl+C to exit.
+
+### Bug Destruction Mode (With Arguments)
+
+The problem to investigate is: `$normalized_args`
+
+#### Step 1: Validate Input
+
+If `$normalized_args` is empty:
 ```
 🔥🐜🗡️🐜🔥 SWARM
 
@@ -28,7 +56,7 @@ This is the nuclear option - use when repeated fix attempts fail.
 ```
 Stop here.
 
-### Step 2: Read State & Initialize
+#### Step 2: Read State & Initialize
 
 Read `.aether/data/COLONY_STATE.json`.
 If `goal` is null → "No colony initialized. Run /ant:init first.", stop.
@@ -40,6 +68,11 @@ Initialize swarm findings:
 bash .aether/aether-utils.sh swarm-findings-init "<swarm_id>"
 ```
 
+Initialize swarm display for real-time tracking:
+```bash
+bash .aether/aether-utils.sh swarm-display-init "<swarm_id>"
+```
+
 Display header:
 ```
 🔥🐜🗡️🐜🔥 ═══════════════════════════════════════════════
@@ -52,7 +85,7 @@ Display header:
 ⚡ Deploying 4 parallel scouts...
 ```
 
-### Step 3: Create Git Checkpoint
+#### Step 3: Create Git Checkpoint
 
 Before any investigation that might lead to fixes:
 ```bash
@@ -67,7 +100,7 @@ Store the result for potential rollback:
 💾 Checkpoint: {checkpoint_type} → {checkpoint_ref}
 ```
 
-### Step 4: Read Context
+#### Step 4: Read Context
 
 Read existing blockers for context:
 ```bash
@@ -84,146 +117,112 @@ Scan recent git commits for context:
 git log --oneline -20 2>/dev/null || echo "(no git history)"
 ```
 
-### Step 5: Deploy 4 Parallel Scouts
+#### Step 5: Deploy 4 Parallel Scouts
 
 Use the **Task** tool to spawn 4 scouts **in a single message** (parallel execution):
 
-**Scout 1: Git Archaeologist 🏛️**
+Log each scout to swarm display before spawning:
+```bash
+bash .aether/aether-utils.sh swarm-display-update "{swarm_id}-Archaeologist" "scout" "excavating" "Git history investigation" "Queen" '{"read":0,"grep":0,"edit":0,"bash":3}' 0
+bash .aether/aether-utils.sh swarm-display-update "{swarm_id}-PatternHunter" "scout" "excavating" "Pattern search for similar code" "Queen" '{"read":5,"grep":10,"edit":0,"bash":0}' 0
+bash .aether/aether-utils.sh swarm-display-update "{swarm_id}-ErrorAnalyst" "scout" "excavating" "Error chain analysis" "Queen" '{"read":3,"grep":5,"edit":0,"bash":2}' 0
+bash .aether/aether-utils.sh swarm-display-update "{swarm_id}-WebResearcher" "scout" "excavating" "External source research" "Queen" '{"read":0,"grep":0,"edit":0,"bash":0}' 0
 ```
-You are the Git Archaeologist scout for swarm {swarm_id}.
 
-PROBLEM: {problem description}
+**Scout 1: 🏛️ Git Archaeologist**
+```
+You are {swarm_id}-Archaeologist, a 🏛️ Scout Ant.
 
-Your mission: Investigate git history to find when this worked and what changed.
+Investigate git history for: {problem description}
 
-Investigation steps:
-1. Run `git log --oneline -30` to see recent commits
-2. Run `git log -p --since="1 week ago" -- {relevant files}` to see recent changes
-3. Run `git blame {suspected file}` if a specific file is mentioned
-4. Look for commits that might have introduced the bug
+Steps:
+1. Run `git log --oneline -30`
+2. Run `git log -p --since="1 week ago" -- {relevant files}`
+3. Run `git blame {suspected file}` if mentioned
+4. Find commits that introduced the bug
 
-Return JSON:
-{
-  "scout": "git-archaeologist",
-  "confidence": 0.0-1.0,
-  "finding": {
-    "likely_cause": "What you found",
-    "relevant_commits": ["commit hashes"],
-    "when_it_broke": "timestamp or commit",
-    "evidence": ["specific findings"]
-  },
-  "suggested_fix": "If obvious from history"
-}
+Return ONLY this JSON:
+{"scout": "git-archaeologist", "confidence": 0.0-1.0, "finding": {"likely_cause": "...", "relevant_commits": [], "when_it_broke": "...", "evidence": []}, "suggested_fix": "..."}
 ```
 
-**Scout 2: Pattern Hunter 🔍**
+**Scout 2: 🔍 Pattern Hunter**
 ```
-You are the Pattern Hunter scout for swarm {swarm_id}.
+You are {swarm_id}-PatternHunter, a 🔍 Scout Ant.
 
-PROBLEM: {problem description}
+Find working patterns for: {problem description}
 
-Your mission: Find similar working code in this codebase that solves the same problem.
+Steps:
+1. Grep/glob for related working code
+2. Find how other parts handle this
+3. Look for test files showing correct usage
+4. Identify applicable patterns
 
-Investigation steps:
-1. Search for similar patterns that work: grep/glob for related code
-2. Find how other parts of the codebase handle this
-3. Look for test files that demonstrate correct usage
-4. Identify patterns that could be applied
-
-Return JSON:
-{
-  "scout": "pattern-hunter",
-  "confidence": 0.0-1.0,
-  "finding": {
-    "working_examples": ["file:line - description"],
-    "applicable_patterns": ["pattern descriptions"],
-    "differences": "What's different in broken code"
-  },
-  "suggested_fix": "Based on working patterns"
-}
+Return ONLY this JSON:
+{"scout": "pattern-hunter", "confidence": 0.0-1.0, "finding": {"working_examples": [], "applicable_patterns": [], "differences": "..."}, "suggested_fix": "..."}
 ```
 
-**Scout 3: Error Analyst 💥**
+**Scout 3: 💥 Error Analyst**
 ```
-You are the Error Analyst scout for swarm {swarm_id}.
-
-PROBLEM: {problem description}
+You are {swarm_id}-ErrorAnalyst, a 🔍 Scout Ant.
 
-Your mission: Parse the error deeply to identify root cause.
+Analyze error: {problem description}
 
-Investigation steps:
-1. If stack trace provided, trace through each frame
-2. Identify the actual failing line vs where error surfaces
-3. Check for common causes: null refs, async issues, type mismatches
-4. Look for error handling that might mask the real issue
+Steps:
+1. Trace through stack trace frames
+2. Identify actual failing line vs surface error
+3. Check for null refs, async issues, type mismatches
+4. Look for error handling masking the issue
 
-Return JSON:
-{
-  "scout": "error-analyst",
-  "confidence": 0.0-1.0,
-  "finding": {
-    "root_cause": "The actual source of the error",
-    "error_chain": ["how error propagates"],
-    "masked_by": "any error handling hiding the real issue",
-    "category": "null-ref|async|type|logic|config|dependency"
-  },
-  "suggested_fix": "Direct fix for root cause"
-}
+Return ONLY this JSON:
+{"scout": "error-analyst", "confidence": 0.0-1.0, "finding": {"root_cause": "...", "error_chain": [], "masked_by": "...", "category": "null-ref|async|type|logic|config|dependency"}, "suggested_fix": "..."}
 ```
 
-**Scout 4: Web Researcher 🌐**
+**Scout 4: 🌐 Web Researcher**
 ```
-You are the Web Researcher scout for swarm {swarm_id}.
-
-PROBLEM: {problem description}
+You are {swarm_id}-WebResearcher, a 🔍 Scout Ant.
 
-Your mission: Search external sources for solutions to this exact error.
+Research external solutions for: {problem description}
 
-Investigation steps:
-1. Search for the exact error message
-2. Look for library/framework documentation
-3. Check GitHub issues for similar problems
+Steps:
+1. Search for exact error message
+2. Find library/framework docs
+3. Check GitHub issues
 4. Find Stack Overflow answers
 
-Return JSON:
-{
-  "scout": "web-researcher",
-  "confidence": 0.0-1.0,
-  "finding": {
-    "known_issue": true/false,
-    "documentation_link": "if relevant",
-    "similar_issues": ["descriptions of similar problems"],
-    "community_solutions": ["approaches others used"]
-  },
-  "suggested_fix": "From external sources"
-}
+Return ONLY this JSON:
+{"scout": "web-researcher", "confidence": 0.0-1.0, "finding": {"known_issue": true/false, "documentation_link": "...", "similar_issues": [], "community_solutions": []}, "suggested_fix": "..."}
 ```
 
 Wait for all 4 scouts to complete.
 
-### Step 6: Collect and Cross-Compare Findings
+#### Step 6: Collect and Cross-Compare Findings
 
 As each scout returns, add their findings:
 ```bash
 bash .aether/aether-utils.sh swarm-findings-add "{swarm_id}" "{scout_type}" "{confidence}" '{finding_json}'
 ```
 
+Update scout status in swarm display to "completed":
+```bash
+bash .aether/aether-utils.sh swarm-display-update "{swarm_id}-Archaeologist" "scout" "completed" "Git history investigation" "Queen" '{"read":3,"grep":0,"edit":0,"bash":5}' 150
+```
+
 Display each scout's report as they complete:
 ```
-🏛️ Git Archaeologist [{confidence}]
+🏛️ Archaeologist [{confidence}]
    {summary of finding}
 
-🔍 Pattern Hunter [{confidence}]
+🔍 PatternHunter [{confidence}]
    {summary of finding}
 
-💥 Error Analyst [{confidence}]
+💥 ErrorAnalyst [{confidence}]
    {summary of finding}
 
-🌐 Web Researcher [{confidence}]
+🌐 WebResearcher [{confidence}]
    {summary of finding}
 ```
 
-### Step 7: Synthesize Solution
+#### Step 7: Synthesize Solution
 
 Cross-compare all findings:
 1. Identify where scouts agree (high confidence)
@@ -247,13 +246,13 @@ Rank fix options:
    Evidence: {limited support}
 ```
 
-### Step 8: Apply Best Fix
+#### Step 8: Apply Best Fix
 
 Select the highest-confidence solution and apply it:
 
 **Command Resolution:** Before running verification, resolve `{build_command}` and `{test_command}` using this priority chain (stop at first match per command):
 1. **CLAUDE.md** — Check project CLAUDE.md (in your system context) for explicit build/test commands
-2. **CODEBASE.md** — Read `.planning/CODEBASE.md` `## Commands` section
+2. **CODEBASE.md** — Read `.aether/data/codebase.md` `## Commands` section
 3. **Fallback** — Use project manifest heuristics (e.g., `npm run build`/`npm test` for package.json)
 
 ```
@@ -269,7 +268,7 @@ After applying:
 {test_command} 2>&1 | tail -50
 ```
 
-### Step 9: Verify and Report
+#### Step 9: Verify and Report
 
 **If verification passes:**
 ```
@@ -337,7 +336,12 @@ Recommended:
 Swarm will not attempt further fixes on this issue.
 ```
 
-### Step 10: Cleanup
+#### Step 10: Cleanup
+
+Clear swarm display:
+```bash
+bash .aether/aether-utils.sh swarm-display-init "complete-{swarm_id}"
+```
 
 Archive swarm findings:
 ```bash

package/.opencode/commands/ant/tunnels.md

@@ -1,12 +1,25 @@
 ---
 name: ant:tunnels
-description: "🕳️🐜🕳️ Explore tunnels (browse archived colonies)"
+description: "🕳️🐜🕳️ Explore tunnels (browse archived colonies, compare chambers)"
 ---
 
 You are the **Queen**. Browse the colony history.
 
 ## Instructions
 
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+### Argument Handling
+
+- No arguments: Show chamber list (Step 4)
+- One argument: Show single chamber detail (Step 3)
+- Two arguments: Compare two chambers (Step 5)
+- More than two: "Too many arguments. Use: /ant:tunnels [chamber1] [chamber2]"
+
 ### Step 1: Check for Chambers Directory
 
 Check if `.aether/chambers/` exists.
@@ -44,7 +57,7 @@ Stop here.
 
 ### Step 3: Handle Detail View (if argument provided)
 
-If `$ARGUMENTS` is not empty:
+If `$normalized_args` is not empty:
 - Treat it as chamber name
 - Check if `.aether/chambers/{arguments}/` exists
 - If not found:
@@ -95,6 +108,98 @@ To get the counts and hash status:
 
 Stop here.
 
+### Step 5: Chamber Comparison Mode (Two Arguments)
+
+If two arguments provided (chamber names separated by space):
+- Treat as: `/ant:tunnels <chamber_a> <chamber_b>`
+- Run comparison: `bash .aether/utils/chamber-compare.sh compare <chamber_a> <chamber_b>`
+
+If either chamber not found:
+```
+Chamber not found: {chamber_name}
+
+Available chambers:
+{list from chamber-list}
+```
+Stop here.
+
+Display comparison header:
+```
+🕳️ ═══════════════════════════════════════════════════
+   C H A M B E R   C O M P A R I S O N
+══════════════════════════════════════════════════ 🕳️
+
+📦 {chamber_a}  vs  📦 {chamber_b}
+```
+
+Display side-by-side comparison:
+```
+┌─────────────────────┬─────────────────────┐
+│ {chamber_a}         │ {chamber_b}         │
+├─────────────────────┼─────────────────────┤
+│ 👑 {goal_a}         │ 👑 {goal_b}         │
+│                     │                     │
+│ 🏆 {milestone_a}    │ 🏆 {milestone_b}    │
+│    {version_a}      │    {version_b}      │
+│                     │                     │
+│ 📍 {phases_a} done  │ 📍 {phases_b} done  │
+│    of {total_a}     │    of {total_b}     │
+│                     │                     │
+│ 🧠 {decisions_a}    │ 🧠 {decisions_b}    │
+│    decisions        │    decisions        │
+│                     │                     │
+│ 💡 {learnings_a}    │ 💡 {learnings_b}    │
+│    learnings        │    learnings        │
+│                     │                     │
+│ 📅 {date_a}         │ 📅 {date_b}         │
+└─────────────────────┴─────────────────────┘
+```
+
+Display growth metrics:
+```
+📈 Growth Between Chambers:
+   Phases: +{phases_diff} ({phases_a} → {phases_b})
+   Decisions: +{decisions_diff} new
+   Learnings: +{learnings_diff} new
+   Time: {time_between} days apart
+```
+
+If phases_diff > 0: show "📈 Colony grew"
+If phases_diff < 0: show "📉 Colony reduced (unusual)"
+If same_milestone: show "🏆 Same milestone reached"
+If milestone changed: show "🏆 Milestone advanced: {milestone_a} → {milestone_b}"
+
+Display pheromone trail diff (new decisions/learnings in B):
+```bash
+bash .aether/utils/chamber-compare.sh diff <chamber_a> <chamber_b>
+```
+
+Parse result and show:
+```
+🧠 New Decisions in {chamber_b}:
+   {N} new architectural decisions
+   {if N <= 5, list them; else show first 3 + "...and {N-3} more"}
+
+💡 New Learnings in {chamber_b}:
+   {N} new validated learnings
+   {if N <= 5, list them; else show first 3 + "...and {N-3} more"}
+```
+
+Display knowledge preservation:
+```
+📚 Knowledge Preservation:
+   {preserved_decisions} decisions carried forward
+   {preserved_learnings} learnings carried forward
+```
+
+Footer:
+```
+Run /ant:tunnels to see all chambers
+Run /ant:tunnels <chamber> to view single chamber details
+```
+
+Stop here.
+
 ### Step 4: Display Chamber List (default view)
 
 ```