aether-colony 5.0.0 → 5.2.1

package/.claude/commands/ant/council.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/council.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:council
 description: "📜🐜🏛️🐜📜 Convene council for intent clarification via multi-choice questions"
@@ -8,20 +9,212 @@ You are the **Queen Ant Colony**. Convene the council to clarify user intent and
 ## Instructions
 
 Parse `$ARGUMENTS`:
+- If starts with `--deliberate`: set `deliberate_mode = true`, extract proposal text after `--deliberate`
 - 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 `deliberate_mode` is true:** Skip to [Deliberation Mode](#deliberation-mode) and stop after it.
 
-If `visual_mode` is true, run using the Bash tool with description "Initializing council display...":
+---
+
+## Deliberation Mode
+
+When `--deliberate "<proposal>"` is passed, run a structured Advocate/Challenger/Sage deliberation.
+
+### Step D1: Check Budget
+
+Run using the Bash tool with description "Checking deliberation budget...":
+```bash
+bash .aether/aether-utils.sh council-budget-check
+```
+
+Parse result. If `allowed` is `false`:
+```
+📜🐜🏛️🐜📜 COUNCIL — BUDGET EXHAUSTED
+
+Spawn budget is fully allocated. Complete or close existing deliberations before starting new ones.
+Run /ant:council to review existing deliberations.
+```
+Stop here.
+
+### Step D2: Open Deliberation
+
+Run using the Bash tool with description "Opening deliberation...":
+```bash
+bash .aether/aether-utils.sh council-deliberate --proposal "<proposal>"
+```
+
+Capture `deliberation_id` from `result.id`.
+
+Display:
+```
+📜🐜🏛️🐜📜 COUNCIL DELIBERATION OPENED
+
+Proposal: "<proposal>"
+ID: {deliberation_id}
+Budget: {budget} spawns available
+
+Convening Advocate, Challenger, and Sage...
+```
+
+### Step D3: Spawn Advocate Scout
+
+Spawn an Advocate scout to argue **in favor** of the proposal.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Advocate on the Ant Colony council.
+Your role is to argue STRONGLY IN FAVOR of the proposal.
+Present the strongest possible case for why this proposal should be adopted.
+Be specific. Focus on concrete benefits and outcomes.
+Keep your argument under 200 words.
+Reply with ONLY your argument text — no preamble or meta-commentary.
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Present your strongest argument in favor of this proposal.
+```
+
+Capture the advocate's argument as `advocate_argument`.
+
+
+Record the argument:
+```bash
+bash .aether/aether-utils.sh council-advocate \
+  --deliberation-id "<deliberation_id>" \
+  --argument "<advocate_argument>"
+```
+
+Display:
+```
+⚖️  ADVOCATE:
+{advocate_argument}
+```
+
+### Step D4: Spawn Challenger Scout
+
+Spawn a Challenger scout to argue **against** the proposal.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Challenger on the Ant Colony council.
+Your role is to argue STRONGLY AGAINST the proposal.
+Present the strongest possible case for why this proposal should be rejected or deferred.
+Be specific. Focus on concrete risks, costs, and downsides.
+Keep your argument under 200 words.
+Reply with ONLY your argument text — no preamble or meta-commentary.
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Present your strongest argument against this proposal.
+```
+
+Capture the challenger's argument as `challenger_argument`.
+
+
+Record the argument:
+```bash
+bash .aether/aether-utils.sh council-challenger \
+  --deliberation-id "<deliberation_id>" \
+  --argument "<challenger_argument>"
+```
+
+Display:
+```
+⚔️  CHALLENGER:
+{challenger_argument}
+```
+
+### Step D5: Spawn Sage Scout
+
+Spawn a Sage scout to synthesize both positions and provide a recommendation.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Sage on the Ant Colony council.
+You have heard both the Advocate and Challenger arguments.
+Your role is to synthesize both positions into balanced wisdom and provide a clear recommendation.
+Your recommendation must be one of: adopt, reject, defer, or adopt-with-conditions.
+Keep your synthesis under 150 words.
+Reply with JSON only:
+{"synthesis": "<your balanced synthesis>", "recommendation": "adopt|reject|defer|adopt-with-conditions"}
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Advocate argued: "<advocate_argument>"
+
+Challenger argued: "<challenger_argument>"
+
+Synthesize both positions and provide your recommendation.
+```
+
+Parse the JSON response. Capture `synthesis` and `recommendation`.
+
+
+Record the sage synthesis:
 ```bash
-# Generate session ID
-council_id="council-$(date +%s)"
+bash .aether/aether-utils.sh council-sage \
+  --deliberation-id "<deliberation_id>" \
+  --synthesis "<synthesis>" \
+  --recommendation "<recommendation>"
+```
+
+### Step D6: Display Result
+
+```
+📜🐜🏛️🐜📜 COUNCIL DELIBERATION COMPLETE
+
+Proposal: "<proposal>"
+
+⚖️  Advocate:
+{advocate_argument}
+
+⚔️  Challenger:
+{challenger_argument}
+
+🧙 Sage Synthesis:
+{synthesis}
+
+Recommendation: {recommendation}
+```
+
+If recommendation is `adopt` or `adopt-with-conditions`:
+```
+✅ Council recommends proceeding.
+   Run /ant:focus "<proposal summary>" to inject guidance for the colony.
+```
+
+If recommendation is `reject`:
+```
+❌ Council recommends against this proposal.
+   Run /ant:redirect "<proposal summary>" if you want to make this a hard constraint.
+```
 
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$council_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Convening council" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
+If recommendation is `defer`:
 ```
+⏸️  Council recommends deferring this decision.
+   Return when more context is available.
+```
+
+---
+
+
+
+### Step 0: Initialize Visual Mode (if enabled)
+
+If `visual_mode` is true, run using the Bash tool with description "Initializing council display...":
 
 ### Step 1: Read Current State
 
@@ -35,6 +228,12 @@ No colony initialized. Run /ant:init first.
 ```
 Stop here.
 
+If `milestone` == `"Crowned Anthill"`:
+```
+This colony has been sealed. Start a new colony with /ant:init "new goal".
+```
+Stop here.
+
 Capture the current state for context:
 - `prior_state` = state field value (READY, EXECUTING, PLANNING, etc.)
 - `current_phase` = current_phase field value
@@ -42,10 +241,13 @@ Capture the current state for context:
 
 ### Step 2: Display Council Header
 
+
 ```
 📜🐜🏛️🐜📜 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-              A N T   C O U N C I L
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📜🐜🏛️🐜📜
+             A N T   C O U N C I L
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📜🐜🏛️🐜📜
+
+
 
 👑 Queen convenes the council for guidance
 
@@ -239,12 +441,6 @@ Keep max 100 events.
 
 ### Step 8: Display Summary
 
-**If visual_mode is true, render final swarm display** by running using the Bash tool with description "Updating council display...":
-```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Council adjourned" "Colony" '{"read":3,"grep":0,"edit":2,"bash":1}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-text "$council_id"
-```
-
 ```
 📜🐜🏛️🐜📜 COUNCIL ADJOURNED
 
@@ -298,6 +494,7 @@ If `prior_state` was PLANNING:
    Planning will continue with new guidance.
 ```
 
+
 ### Step 9: Next Up
 
 Generate the state-based Next Up block by running using the Bash tool with description "Generating Next Up suggestions...":
@@ -307,3 +504,4 @@ 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/data-clean.md

@@ -0,0 +1,81 @@
+<!-- Generated from .aether/commands/data-clean.yaml - DO NOT EDIT DIRECTLY -->
+---
+name: ant:data-clean
+description: "Scan and remove test artifacts from colony data files"
+---
+
+You are the **Queen Ant Colony**. Run the data cleaner to scan for and remove test/synthetic artifacts from colony data files.
+
+
+> **Note:** `$ARGUMENTS` is unused. This command always scans all data files.
+
+
+
+## Instructions
+
+### Step 1: Scan
+
+Run using the Bash tool with description "Scanning colony data for test artifacts...":
+```bash
+bash .aether/aether-utils.sh data-clean --dry-run
+```
+
+Display the output to the user. This shows artifact counts per data file without modifying anything.
+
+### Step 2: Decision Gate
+
+Parse the scan output for "Total artifacts: N".
+
+**If total is 0:**
+Display:
+```
+Colony data is clean. No artifacts found.
+```
+Skip to Step 5.
+
+**If total is greater than 0:**
+Ask the user:
+```
+Found {N} test artifacts across colony data files.
+Remove these artifacts? (yes/no)
+```
+
+If user says no, display "No changes made." and skip to Step 5.
+
+### Step 3: Clean
+
+If user confirmed, run using the Bash tool with description "Removing test artifacts...":
+```bash
+bash .aether/aether-utils.sh data-clean --confirm
+```
+
+### Step 4: Summary
+
+Display the cleanup results showing what was removed from each file.
+
+For example:
+```
+Data Clean Complete
+===================
+Removed {total} artifacts:
+  - pheromones.json: {N} test signals
+  - QUEEN.md: {N} test entries
+  - learning-observations.json: {N} test observations
+  - midden.json: {N} test entries
+  - spawn-tree.txt: {N} test worker lines
+  - constraints.json: {N} test focus entries
+
+Run /ant:status to verify colony state.
+```
+
+
+### Step 5: 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"
+```
+

package/.claude/commands/ant/dream.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/dream.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:dream
 description: "💭🐜🌙🐜💭 The Dreamer - a philosophical wanderer that observes, imagines, and writes wisdom about the codebase"
@@ -35,17 +36,9 @@ Parse `$ARGUMENTS`:
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
-### Step 0.5: Initialize Visual Mode (if enabled)
 
-If `visual_mode` is true, run using the Bash tool with description "Initializing dream display...":
-```bash
-# Generate session ID
-dream_id="dream-$(date +%s)"
+### Step 0.5: Initialize Visual Mode (if enabled)
 
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$dream_id"
-bash .aether/aether-utils.sh swarm-display-update "Dreamer" "dreamer" "observing" "Wandering the codebase" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "nursery" 0
-```
 
 ### Step 1: Awaken — Load Context
 
@@ -66,11 +59,14 @@ Read these files in parallel to understand the world you're dreaming about:
 - Read the most recent dream file if one exists (to avoid repeating yourself)
 
 Display awakening:
+
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 💭🐜🌙🐜💭  T H E   D R E A M E R   A W A K E N S
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
+
+
 Colony: {goal}
 Phase:  {current_phase}/{total_phases} — {phase_name}
 State:  {state}
@@ -197,11 +193,14 @@ Concerns raised: {count}
 
 Output to the terminal:
 
+
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 💭🐜🌙🐜💭  D R E A M   C O M P L E T E
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
+
+
 📓 {N} dreams recorded → .aether/dreams/{filename}.md
 
   {For each dream, one line:}
@@ -224,11 +223,14 @@ Colony status: /ant:status
 
 ### Step 6: Log Activity
 
+
 Run using the Bash tool with description "Logging dream activity...":
+
 ```bash
 bash .aether/aether-utils.sh activity-log "DREAM" "Dreamer" "Dream session: {N} observations, {concerns} concerns, {pheromones} pheromone suggestions"
 ```
 
+
 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)
@@ -237,6 +239,7 @@ 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"
 ```
 
+
 ## Dream Categories
 
 Use these categories and their emoji consistently:

package/.claude/commands/ant/entomb.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/entomb.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:entomb
 description: "⚰️🐜⚰️ Entomb completed colony in chambers"
@@ -52,14 +53,6 @@ Do not touch during entomb:
 ### Step 0: Initialize Visual Mode (if enabled)
 
 If `visual_mode` is true:
-```bash
-# Generate session ID
-entomb_id="entomb-$(date +%s)"
-
-# Initialize swarm display (consolidated)
-bash .aether/aether-utils.sh swarm-display-init "$entomb_id" && bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Entombing colony" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
-```
-
 ### Step 1: Read State
 
 Read `.aether/data/COLONY_STATE.json`.
@@ -72,6 +65,12 @@ Stop here.
 
 Extract: `goal`, `state`, `current_phase`, `plan.phases`, `milestone`, `version`, `initialized_at`, `memory.decisions`, `memory.phase_learnings`, `memory.instincts`.
 
+Read `colony_version` for display (default to 1 for backward compat with older colonies):
+```bash
+colony_version=$(jq -r '.colony_version // 1' .aether/data/COLONY_STATE.json 2>/dev/null || echo 1)
+[[ "$colony_version" =~ ^[0-9]+$ ]] || colony_version=1
+```
+
 ### Step 2: Seal-First Enforcement
 
 Check `milestone` in COLONY_STATE.json.
@@ -100,6 +99,7 @@ Show what will be archived:
 ENTOMB COLONY
 
 Goal: {goal}
+Version: v{colony_version}
 Milestone: Crowned Anthill
 Phases: {phases_completed} of {total_phases}
 
@@ -123,6 +123,36 @@ Entombment cancelled. Colony remains active.
 ```
 Stop here.
 
+### Step 3.25: Wisdom Approval
+
+Before archiving, review wisdom proposals accumulated during this colony's lifecycle.
+
+```bash
+# Check for pending proposals
+proposals=$(bash .aether/aether-utils.sh learning-check-promotion 2>/dev/null || echo '{"proposals":[]}')
+proposal_count=$(echo "$proposals" | jq '.proposals | length')
+
+if [[ "$proposal_count" -gt 0 ]]; then
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "   🧠 FINAL WISDOM REVIEW"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+  echo "Review wisdom proposals before archiving this colony."
+  echo "Approved proposals will be promoted to QUEEN.md."
+  echo ""
+
+  # Run approval workflow (blocking)
+  bash .aether/aether-utils.sh learning-approve-proposals
+
+  echo ""
+  echo "Wisdom review complete. Proceeding with entombment..."
+  echo ""
+else
+  echo "No wisdom proposals to review."
+fi
+```
+
 ### Step 3.5: Check XML Tools
 
 XML archiving is required for entombment. Check tool availability before proceeding.
@@ -168,90 +198,24 @@ Entombment requires XML archiving. Install xmllint and try again.
 ```
 Stop here.
 
-### Step 4: Promote Wisdom to QUEEN.md
-
-Before creating the chamber, promote validated learnings to QUEEN.md for future colonies.
+### Step 4: Ensure QUEEN.md Exists
 
-**Step 4.1: Ensure QUEEN.md exists**
+Verify QUEEN.md is initialized for wisdom storage:
 
 ```bash
-queen_file=".aether/docs/QUEEN.md"
+queen_file=".aether/QUEEN.md"
 if [[ ! -f "$queen_file" ]]; then
   init_result=$(bash .aether/aether-utils.sh queen-init 2>/dev/null || echo '{"ok":false}')
   init_ok=$(echo "$init_result" | jq -r '.ok // false')
   if [[ "$init_ok" == "true" ]]; then
     created=$(echo "$init_result" | jq -r '.result.created // false')
     if [[ "$created" == "true" ]]; then
-      bash .aether/aether-utils.sh activity-log "CREATED" "Queen" "Initialized QUEEN.md for wisdom promotion"
+      bash .aether/aether-utils.sh activity-log "CREATED" "Queen" "Initialized QUEEN.md for wisdom storage"
     fi
   fi
 fi
 ```
 
-**Step 4.2: Extract and promote validated learnings**
-
-```bash
-# Extract colony name from goal (sanitized)
-colony_name=$(jq -r '.goal' .aether/data/COLONY_STATE.json | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '-' | sed 's/^-//;s/-$//' | cut -c1-30)
-
-# Extract validated learnings from phase_learnings
-learnings=$(jq -c '.memory.phase_learnings // []' .aether/data/COLONY_STATE.json)
-
-# Extract decisions
-decisions=$(jq -c '.memory.decisions // []' .aether/data/COLONY_STATE.json)
-
-promotion_count=0
-
-# Promote patterns from validated learnings
-if [[ -f "$queen_file" ]]; then
-  # Process each phase's learnings
-  echo "$learnings" | jq -c '.[]' 2>/dev/null | while read -r learning_group; do
-    phase=$(echo "$learning_group" | jq -r '.phase // "unknown"')
-    # Extract individual learnings and promote as patterns
-    echo "$learning_group" | jq -r '.learnings[]? | select(.status == "validated") | .claim' 2>/dev/null | while read -r claim; do
-      if [[ -n "$claim" && "$claim" != "null" ]]; then
-        # Truncate if too long
-        content=$(echo "$claim" | cut -c1-200)
-        result=$(bash .aether/aether-utils.sh queen-promote "pattern" "$content" "$colony_name" 2>/dev/null || echo '{"ok":false}')
-        if [[ $(echo "$result" | jq -r '.ok // false') == "true" ]]; then
-          promotion_count=$((promotion_count + 1))
-        fi
-      fi
-    done
-  done
-
-  # Promote high-confidence instincts as patterns
-  instincts=$(jq -c '.memory.instincts // []' .aether/data/COLONY_STATE.json)
-  echo "$instincts" | jq -c '.[]' 2>/dev/null | while read -r instinct; do
-    confidence=$(echo "$instinct" | jq -r '.confidence // 0')
-    status=$(echo "$instinct" | jq -r '.status // ""')
-    action=$(echo "$instinct" | jq -r '.action // ""')
-    # Promote validated instincts with high confidence (>= 0.7)
-    if [[ "$status" == "validated" && $(echo "$confidence >= 0.7" | bc -l 2>/dev/null || echo 0) -eq 1 && -n "$action" ]]; then
-      content=$(echo "$action" | cut -c1-200)
-      result=$(bash .aether/aether-utils.sh queen-promote "pattern" "$content" "$colony_name" 2>/dev/null || echo '{"ok":false}')
-      if [[ $(echo "$result" | jq -r '.ok // false') == "true" ]]; then
-        promotion_count=$((promotion_count + 1))
-      fi
-    fi
-  done
-
-  # Log promotion results
-  bash .aether/aether-utils.sh activity-log "MODIFIED" "Queen" "Promoted $promotion_count validated learnings to QUEEN.md from entombed colony"
-fi
-```
-
-**Step 4.3: Display promotion summary**
-
-```
----
-Wisdom Promotion Summary
----
-Colony: {colony_name}
-Promoted: {promotion_count} validated patterns to QUEEN.md
----
-```
-
 ### Step 5: Generate Chamber Name
 
 Date-first naming:
@@ -315,6 +279,15 @@ done
 
 # Archive dreams directory (optional — may not exist)
 [[ -d ".aether/dreams" ]] && cp -r ".aether/dreams" "$chamber_dir/dreams" 2>/dev/null || true
+
+# Archive XML exchange files to chamber (per D-04, D-05)
+xml_archived=0
+for xml_file in .aether/exchange/*.xml; do
+  [[ -f "$xml_file" ]] && cp "$xml_file" "$chamber_dir/" && xml_archived=$((xml_archived + 1))
+done
+if [[ "$xml_archived" -gt 0 ]]; then
+  echo "XML Archive: ${xml_archived} exchange file(s) copied to chamber"
+fi
 ```
 
 Do NOT copy: `.aether/data/backups/`, `.aether/data/locks/`, `.aether/data/midden/`, `.aether/data/survey/`.
@@ -343,7 +316,8 @@ fi
 If xml_ok is true, store for display:
 ```bash
 xml_pheromone_count=$(echo "$xml_result" | jq -r '.result.pheromone_count // 0' 2>/dev/null)
-xml_archive_line="XML Archive: colony-archive.xml (${xml_pheromone_count} active signals)"
+xml_exchange_count=$(find .aether/exchange -maxdepth 1 -name "*.xml" 2>/dev/null | wc -l | tr -d ' ')
+xml_archive_line="XML Archive: colony-archive.xml (${xml_pheromone_count} signals) + ${xml_exchange_count} exchange file(s)"
 ```
 
 **Critical behavior:** If XML export fails, entomb STOPS. The chamber directory is removed (cleanup). The colony state is NOT reset. The user sees a clear error and can retry after fixing the issue.
@@ -379,8 +353,9 @@ if [[ -f "$eternal_file" ]]; then
     --arg sealed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
     --arg chamber ".aether/chambers/$chamber_name" \
     '{goal: $goal, milestone: $milestone, sealed_at: $sealed_at, chamber: $chamber}')
-  jq --argjson entry "$colony_entry" '.colonies += [$entry]' "$eternal_file" > /tmp/eternal-tmp.json \
-    && mv /tmp/eternal-tmp.json "$eternal_file"
+  tmp_eternal="$(mktemp /tmp/aether-eternal.XXXXXX)"
+  jq --argjson colony_entry "$colony_entry" '.colonies = ((.colonies // []) + [$colony_entry])' "$eternal_file" > "$tmp_eternal" \
+    && mv "$tmp_eternal" "$eternal_file"
 fi
 ```
 
@@ -438,6 +413,11 @@ Clean up seal document (it's now in the chamber):
 rm -f .aether/CROWNED-ANTHILL.md
 ```
 
+Clean up exchange XML files (now archived in chamber per D-06):
+```bash
+rm -f .aether/exchange/*.xml 2>/dev/null || true
+```
+
 ### Step 11: Write HANDOFF.md
 
 Write handoff documenting the entombed colony:
@@ -461,18 +441,13 @@ Write the result to .aether/HANDOFF.md using the Write tool.
 
 ### Step 12: Display Result
 
-**If visual_mode is true, render swarm display (consolidated):**
-```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony entombed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":5}' 100 "fungus_garden" 100 && bash .aether/aether-utils.sh swarm-display-inline "$entomb_id"
-```
-
 Display:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    C O L O N Y   E N T O M B E D
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Colony archived successfully
+Entombed v{colony_version}
 
 Goal: {goal}
 Phases: {completed} completed