aether-colony 3.1.17 → 5.1.0

package/.claude/commands/ant/swarm.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/swarm.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:swarm
 description: "🔥🐜🗡️🐜🔥 Real-time colony swarm display + stubborn bug destroyer"
@@ -62,11 +63,6 @@ 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>"
-```
-
 #### Step 2.5: Check for Stale Swarm Session
 
 Capture session start time:
@@ -96,9 +92,9 @@ fi
 
 Display header:
 ```
-🔥🐜🗡️🐜🔥 ═══════════════════════════════════════════════
-                S W A R M   D E P L O Y E D
-═══════════════════════════════════════════════ 🔥🐜🗡️🐜🔥
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔥🐜🗡️🐜🔥  S W A R M   D E P L O Y E D
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 🎯 Target: "{problem description}"
 📍 Swarm ID: {swarm_id}
@@ -108,7 +104,7 @@ Display header:
 
 #### Step 3: Create Git Checkpoint
 
-Before any investigation that might lead to fixes:
+Before any investigation that might lead to fixes, run using the Bash tool:
 ```bash
 bash .aether/aether-utils.sh autofix-checkpoint "pre-swarm-$SWARM_ID"
 ```
@@ -142,14 +138,6 @@ git log --oneline -20 2>/dev/null || echo "(no git history)"
 
 Use the **Task** tool to spawn 4 scouts **in a single message** (parallel execution):
 
-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
-```
-
 **Scout 1: 🏛️ Git Archaeologist** (use Task tool with `subagent_type="aether-archaeologist"`)
 # FALLBACK: If "Agent type not found", use general-purpose and inject role: "You are an Archaeologist Ant - git historian that excavates why code exists."
 ```
@@ -224,11 +212,6 @@ As each scout returns, add their findings:
 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:
 ```
 🏛️ Archaeologist [{confidence}]
@@ -254,9 +237,9 @@ Cross-compare all findings:
 
 Rank fix options:
 ```
-═══════════════════════════════════════════════
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
               S O L U T I O N   R A N K I N G
-═══════════════════════════════════════════════
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 #1 [0.85 confidence] {best solution}
    Evidence: {supporting scouts}
@@ -309,13 +292,9 @@ Inject learnings:
 - Add FOCUS for the pattern that worked (to constraints.json)
 - Add REDIRECT for the anti-pattern that caused the bug (to constraints.json)
 
-Set solution in swarm findings:
+Set solution in swarm findings and log success:
 ```bash
 bash .aether/aether-utils.sh swarm-solution-set "{swarm_id}" '{solution_json}'
-```
-
-Log success:
-```bash
 bash .aether/aether-utils.sh activity-log "SWARM_SUCCESS" "Queen" "Swarm {swarm_id} fixed: {brief description}"
 ```
 
@@ -329,13 +308,9 @@ Tests: {status}
 Attempting rollback...
 ```
 
-Rollback:
+Rollback and log failure:
 ```bash
 bash .aether/aether-utils.sh autofix-rollback "{checkpoint_type}" "{checkpoint_ref}"
-```
-
-Log failure:
-```bash
 bash .aether/aether-utils.sh activity-log "SWARM_FAILED" "Queen" "Swarm {swarm_id} fix failed verification"
 ```
 
@@ -360,20 +335,15 @@ Swarm will not attempt further fixes on this issue.
 
 #### Step 10: Cleanup
 
-Clear swarm display:
-```bash
-bash .aether/aether-utils.sh swarm-display-init "complete-{swarm_id}"
-```
-
-Archive swarm findings:
+Archive findings:
 ```bash
 bash .aether/aether-utils.sh swarm-cleanup "{swarm_id}" --archive
 ```
 
-Display next steps:
-```
-🐜 Next steps:
-   /ant:continue   ⏭️  Verify and advance phase
-   /ant:status     📊 View colony status
-   /ant:flags      🚩 Check remaining blockers
+Generate the state-based Next Up block:
+```bash
+state=$(jq -r '.state // "IDLE"' .aether/data/COLONY_STATE.json)
+current_phase=$(jq -r '.current_phase // 0' .aether/data/COLONY_STATE.json)
+total_phases=$(jq -r '.plan.phases | length' .aether/data/COLONY_STATE.json)
+bash .aether/aether-utils.sh print-next-up "$state" "$current_phase" "$total_phases"
 ```

package/.claude/commands/ant/tunnels.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/tunnels.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:tunnels
 description: "🕳️🐜🕳️ Explore tunnels (browse archived colonies, compare chambers)"
@@ -9,9 +10,9 @@ You are the **Queen**. Browse the colony history.
 
 ### Argument Handling
 
-- No arguments: Show chamber list (Step 4)
-- One argument: Show single chamber detail (Step 3)
-- Two arguments: Compare two chambers (Step 5)
+- No arguments: Show timeline view (Step 4)
+- One argument: Show single chamber detail with seal document (Step 3)
+- Two arguments: Compare two chambers side-by-side (Step 5)
 - More than two: "Too many arguments. Use: /ant:tunnels [chamber1] [chamber2]"
 
 ### Step 1: Check for Chambers Directory
@@ -20,9 +21,7 @@ Check if `.aether/chambers/` exists.
 
 If not:
 ```
-🕳️ ═══════════════════════════════════════════════════
-   T U N N E L S   (Colony History)
-══════════════════════════════════════════════════ 🕳️
+TUNNELS — Colony Timeline
 
 No chambers found.
 
@@ -32,26 +31,24 @@ Stop here.
 
 ### Step 2: List All Chambers
 
-Run: `bash .aether/aether-utils.sh chamber-list`
+Run using the Bash tool with description "Loading chamber list...": `bash .aether/aether-utils.sh chamber-list`
 
 Parse JSON result into array of chambers.
 
 If no chambers (empty array):
 ```
-🕳️ ═══════════════════════════════════════════════════
-   T U N N E L S   (Colony History)
-══════════════════════════════════════════════════ 🕳️
+TUNNELS — Colony Timeline
 
-Chambers: 0 colonies archived
+0 colonies archived
 
 The tunnel network is empty.
 Archive colonies with /ant:entomb to preserve history.
 ```
 Stop here.
 
-### Step 3: Handle Detail View (if argument provided)
+### Step 3: Detail View — Show Seal Document (if one argument provided)
 
-If `$ARGUMENTS` is not empty:
+If `$ARGUMENTS` is not empty and contains exactly one argument:
 - Treat it as chamber name
 - Check if `.aether/chambers/{arguments}/` exists
 - If not found:
@@ -62,43 +59,111 @@ If `$ARGUMENTS` is not empty:
   ```
   Stop here.
 
-- If found, read manifest.json and display detailed view:
+**If CROWNED-ANTHILL.md exists in the chamber:**
+
+```bash
+seal_doc=".aether/chambers/{arguments}/CROWNED-ANTHILL.md"
+```
+
+Display the header:
+```
+CHAMBER DETAILS — {chamber_name}
+```
+
+Then display the FULL content of `CROWNED-ANTHILL.md` (read and output the file contents — this IS the seal ceremony record).
+
+After the seal document, check if `colony-archive.xml` exists in the chamber:
+
+```bash
+chamber_has_xml=false
+[[ -f ".aether/chambers/{chamber_name}/colony-archive.xml" ]] && chamber_has_xml=true
 ```
-🕳️ ═══════════════════════════════════════════════════
-   C H A M B E R   D E T A I L S
-══════════════════════════════════════════════════ 🕳️
 
-📦 {chamber_name}
+**If `colony-archive.xml` exists in the chamber**, show footer with import option:
+```
+Chamber integrity: {hash_status from chamber-verify}
+Chamber location: .aether/chambers/{chamber_name}/
+XML Archive: colony-archive.xml found
+
+Actions:
+  1. Import signals from this colony into current colony
+  2. Return to timeline
+  3. Compare with another chamber
+
+Select an action (1/2/3)
+```
+
+Use AskUserQuestion with three options.
 
-👑 Goal:
-   {goal}
+If option 1 selected: proceed to Step 6 (Import Signals from Chamber).
+If option 2 selected: return to timeline (run /ant:tunnels).
+If option 3 selected: prompt for second chamber name then run /ant:tunnels {chamber_a} {chamber_b}.
 
-🏆 Milestone: {milestone} ({version})
-📍 Progress: {phases_completed} of {total_phases} phases
-📅 Entombed: {entombed_at}
+**If `colony-archive.xml` does NOT exist in the chamber**, show the existing footer unchanged:
+```
+Chamber integrity: {hash_status from chamber-verify}
+Chamber location: .aether/chambers/{chamber_name}/
 
-{If decisions exist:}
-🧠 Decisions Preserved:
-   {N} architectural decisions recorded
-{End if}
+Run /ant:tunnels to return to timeline
+Run /ant:tunnels {chamber_a} {chamber_b} to compare chambers
+```
 
-{If learnings exist:}
-💡 Learnings Preserved:
-   {N} validated learnings recorded
-{End if}
+**If CROWNED-ANTHILL.md does NOT exist (older chamber):**
 
-📁 Files:
-   - COLONY_STATE.json (verified: {hash_status})
-   - manifest.json
+Display the header:
+```
+CHAMBER DETAILS — {chamber_name}
 
-Run /ant:tunnels to return to chamber list.
+(No seal document — this chamber was created before the sealing ceremony was introduced)
 ```
 
-To get the counts and hash status:
+Fall back to manifest data display:
+- Read `manifest.json` and show: goal, milestone, version, phases_completed, total_phases, entombed_at
+- Show decisions count and learnings count from manifest
+- Show hash status from `chamber-verify`
+
+Footer with navigation guidance:
+```
+Run /ant:tunnels to return to timeline
+Run /ant:tunnels {chamber_a} {chamber_b} to compare chambers
+```
+
+To get the hash status, run using the Bash tool with description "Verifying chamber integrity...":
 - Run `bash .aether/aether-utils.sh chamber-verify .aether/chambers/{chamber_name}`
-- If verified: hash_status = "✅"
-- If not verified: hash_status = "⚠️ hash mismatch"
-- If error: hash_status = "⚠️ error"
+- If verified: hash_status = "verified"
+- If not verified: hash_status = "hash mismatch"
+- If error: hash_status = "error"
+
+Stop here.
+
+### Step 4: Timeline View (default, no arguments)
+
+Display header:
+```
+TUNNELS — Colony Timeline
+
+{count} colonies archived
+```
+
+For each chamber in sorted list (already sorted by `chamber-list` — newest first), display as a timeline entry:
+```
+[{date}] {milestone_emoji} {chamber_name}
+           {goal (truncated to 60 chars)}
+           {phases_completed} phases | {milestone}
+```
+
+Where `milestone_emoji` is:
+- Crowned Anthill: crown emoji
+- Sealed Chambers: lock emoji
+- Other: circle emoji
+
+After the timeline entries, show:
+```
+Run /ant:tunnels <chamber_name> to view seal document
+Run /ant:tunnels <chamber_a> <chamber_b> to compare two colonies
+```
+
+Use the entombed_at field from the chamber-list JSON to extract the date (first 10 chars of ISO timestamp).
 
 Stop here.
 
@@ -106,9 +171,8 @@ Stop here.
 
 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:
+Check both chambers exist. If either missing:
 ```
 Chamber not found: {chamber_name}
 
@@ -117,73 +181,75 @@ Available chambers:
 ```
 Stop here.
 
+Run comparison using the Bash tool with description "Comparing chambers...":
+```bash
+bash .aether/utils/chamber-compare.sh compare <chamber_a> <chamber_b>
+bash .aether/utils/chamber-compare.sh stats <chamber_a> <chamber_b>
+```
+
 Display comparison header:
 ```
-🕳️ ═══════════════════════════════════════════════════
-   C H A M B E R   C O M P A R I S O N
-══════════════════════════════════════════════════ 🕳️
+CHAMBER COMPARISON
 
-📦 {chamber_a}  vs  📦 {chamber_b}
+{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}         │
-└─────────────────────┴─────────────────────┘
++---------------------+---------------------+
+| {chamber_a}         | {chamber_b}         |
++---------------------+---------------------+
+| Goal: {goal_a}      | Goal: {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
+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}"
+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):
+Display pheromone trail diff (new decisions/learnings in B) by running using the Bash tool with description "Analyzing pheromone differences...":
 ```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 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"}
+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:
+If both chambers have `CROWNED-ANTHILL.md`, note:
 ```
-📚 Knowledge Preservation:
-   {preserved_decisions} decisions carried forward
-   {preserved_learnings} learnings carried forward
+Both colonies have seal documents. Run /ant:tunnels <name> to view individually.
 ```
 
 Footer:
@@ -194,36 +260,145 @@ Run /ant:tunnels <chamber> to view single chamber details
 
 Stop here.
 
-### Step 4: Display Chamber List (default view)
+### Step 6: Import Signals from Chamber
+
+When user selects "Import signals" from Step 3:
+
+**Step 6.1: Check XML tools** by running using the Bash tool with description "Checking XML tools...":
+```bash
+if command -v xmllint >/dev/null 2>&1; then
+  xmllint_available=true
+else
+  xmllint_available=false
+fi
+```
+
+If xmllint not available:
+```
+Import requires xmllint. Install it first:
+  macOS: xcode-select --install
+  Linux: apt-get install libxml2-utils
+```
+Stop here (return to timeline).
+
+**Step 6.2: Extract source colony name** by running using the Bash tool with description "Extracting colony info...":
+```bash
+chamber_xml=".aether/chambers/{chamber_name}/colony-archive.xml"
+# Extract colony_id from the archive root element
+source_colony=$(xmllint --xpath "string(/*/@colony_id)" "$chamber_xml" 2>/dev/null)
+[[ -z "$source_colony" ]] && source_colony="{chamber_name}"
+```
+
+**Step 6.3: Extract pheromone section and show import preview**
+
+The combined `colony-archive.xml` contains pheromones, wisdom, and registry sections. Extract the pheromone section to a temp file before counting or importing. This prevents over-counting signals from wisdom/registry sections and ensures `pheromone-import-xml` receives the format it expects (`<pheromones>` as root element).
 
+Run using the Bash tool with description "Extracting pheromone signals...":
+```bash
+# Extract the <pheromones> section from the combined archive into a standalone temp file
+import_tmp_dir=$(mktemp -d)
+import_tmp_pheromones="$import_tmp_dir/pheromones-extracted.xml"
+
+# Use xmllint to extract the pheromones element (with its namespace)
+xmllint --xpath "//*[local-name()='pheromones']" "$chamber_xml" > "$import_tmp_pheromones" 2>/dev/null
+
+# Add XML declaration to make it a standalone well-formed document
+if [[ -s "$import_tmp_pheromones" ]]; then
+  # Portable approach: prepend declaration via temp file (avoids macOS/Linux sed -i differences)
+  { echo '<?xml version="1.0" encoding="UTF-8"?>'; cat "$import_tmp_pheromones"; } > "$import_tmp_dir/tmp_decl.xml"
+  mv "$import_tmp_dir/tmp_decl.xml" "$import_tmp_pheromones"
+fi
+
+# Count pheromone signals in extracted pheromone-only XML
+# Scoped to pheromone section only — no over-counting from wisdom/registry sections
+pheromone_count=$(xmllint --xpath "count(//*[local-name()='signal'])" "$import_tmp_pheromones" 2>/dev/null || echo "unknown")
 ```
-🕳️ ═══════════════════════════════════════════════════
-   T U N N E L S   (Colony History)
-══════════════════════════════════════════════════ 🕳️
 
-Chambers: {count} colonies archived
+Display:
+```
+IMPORT FROM COLONY: {source_colony}
 
-{For each chamber in sorted list:}
-📦 {chamber_name}
-   👑 {goal (truncated to 50 chars)}
-   🏆 {milestone} ({version})
-   📍 {phases_completed} phases | 📅 {date}
+Source: .aether/chambers/{chamber_name}/colony-archive.xml
+Signals available: ~{pheromone_count} pheromone signals
 
-{End for}
+Import behavior:
+  - Signals tagged with prefix "{source_colony}:" to identify origin
+  - Additive merge — your current signals are never overwritten
+  - On conflict, your current colony wins
 
-Run /ant:tunnels <chamber_name> to view details
+Import these signals? (yes/no)
 ```
 
-**Formatting details:**
-- Sort by entombed_at descending (newest first) - already sorted by chamber-list
-- Truncate goal to 50 characters with "..." if longer
-- Format date as YYYY-MM-DD from ISO timestamp (extract first 10 chars of entombed_at)
-- Show chamber count at top
+Use AskUserQuestion with yes/no options.
 
-**Edge cases:**
-- Malformed manifest: show "⚠️  Invalid manifest" for that chamber and skip it
-- Missing COLONY_STATE.json: show "⚠️  Incomplete chamber" for that chamber
-- Very long chamber list: display all (no pagination for now)
+If no: "Import cancelled." Clean up: `rm -rf "$import_tmp_dir"`. Return to timeline.
+
+**Step 6.4: Perform import**
+
+Pass the extracted pheromone-only temp file (NOT the combined `colony-archive.xml`) to `pheromone-import-xml`, along with `$source_colony` as the second argument. This ensures:
+1. `pheromone-import-xml` receives XML with `<pheromones>` as root element (the format it expects)
+2. The prefix-tagging logic prepends `${source_colony}:` to each imported signal's ID before the merge
+
+Run using the Bash tool with description "Importing pheromone signals...":
+```bash
+# Import the EXTRACTED pheromone-only XML (NOT the combined colony-archive.xml)
+# $import_tmp_pheromones has <pheromones> as root — the format pheromone-import-xml expects
+# Second argument triggers prefix-tagging — imported signal IDs become "{source_colony}:original_id"
+import_result=$(bash .aether/aether-utils.sh pheromone-import-xml "$import_tmp_pheromones" "$source_colony" 2>&1)
+import_ok=$(echo "$import_result" | jq -r '.ok // false' 2>/dev/null)
+
+if [[ "$import_ok" == "true" ]]; then
+  imported_count=$(echo "$import_result" | jq -r '.result.signal_count // 0' 2>/dev/null)
+else
+  imported_count=0
+  import_error=$(echo "$import_result" | jq -r '.error // "Unknown error"' 2>/dev/null)
+fi
+
+# Clean up temp files
+rm -rf "$import_tmp_dir"
+```
+
+**Step 6.5: Display result**
+
+If import succeeded:
+```
+SIGNALS IMPORTED
+
+Source: {source_colony}
+Imported: {imported_count} pheromone signals
+Tagged with: "{source_colony}:" prefix
+
+Your colony now carries wisdom from {source_colony}.
+Run /ant:status to see current colony state.
+```
+
+If import failed:
+```
+Import failed: {import_error}
+
+The archive may be malformed. Check:
+  .aether/chambers/{chamber_name}/colony-archive.xml
+```
+
+### Edge Cases
+
+**Malformed manifest:** show "Invalid manifest" for that chamber and skip it.
+
+**Missing COLONY_STATE.json:** show "Incomplete chamber" for that chamber.
+
+**Very long chamber list:** display all (no pagination for now).
+
+**Older chambers without CROWNED-ANTHILL.md:** Fall back to manifest data in detail view.
+
+### Step 7: Next Up
+
+Generate the state-based Next Up block by running using the Bash tool with description "Generating Next Up suggestions...":
+```bash
+state=$(jq -r '.state // "IDLE"' .aether/data/COLONY_STATE.json)
+current_phase=$(jq -r '.current_phase // 0' .aether/data/COLONY_STATE.json)
+total_phases=$(jq -r '.plan.phases | length' .aether/data/COLONY_STATE.json)
+bash .aether/aether-utils.sh print-next-up "$state" "$current_phase" "$total_phases"
+```
 
 ## Implementation Notes