aether-colony 3.1.17 → 5.0.0

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

@@ -37,7 +37,7 @@ Parse `$ARGUMENTS`:
 
 ### Step 0.5: Initialize Visual Mode (if enabled)
 
-If `visual_mode` is true:
+If `visual_mode` is true, run using the Bash tool with description "Initializing dream display...":
 ```bash
 # Generate session ID
 dream_id="dream-$(date +%s)"
@@ -67,9 +67,9 @@ Read these files in parallel to understand the world you're dreaming about:
 
 Display awakening:
 ```
-💭🐜🌙🐜💭 ═══════════════════════════════════════════════
-           T H E   D R E A M E R   A W A K E N S
-═══════════════════════════════════════════════ 💭🐜🌙🐜💭
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+💭🐜🌙🐜💭  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}
@@ -198,9 +198,9 @@ Concerns raised: {count}
 Output to the terminal:
 
 ```
-💭🐜🌙🐜💭 ═══════════════════════════════════════════════
-             D R E A M   C O M P L E T E
-═══════════════════════════════════════════════ 💭🐜🌙🐜💭
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+💭🐜🌙🐜💭  D R E A M   C O M P L E T E
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 📓 {N} dreams recorded → .aether/dreams/{filename}.md
 
@@ -224,10 +224,19 @@ 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)
+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"
+```
+
 ## Dream Categories
 
 Use these categories and their emoji consistently:

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

@@ -3,7 +3,7 @@ name: ant:entomb
 description: "⚰️🐜⚰️ Entomb completed colony in chambers"
 ---
 
-You are the **Queen**. Archive the completed colony to chambers.
+You are the **Queen**. Archive the sealed colony to chambers.
 
 ## Instructions
 
@@ -11,6 +11,44 @@ Parse `$ARGUMENTS`:
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
+<failure_modes>
+### Archive Write Failure
+If writing to chambers/ archive fails partway:
+- Do NOT delete source data (the active colony) until archive is verified
+- Report what was archived vs. what failed
+- Recovery: the original colony data is intact -- user can retry
+
+### Seal Verification Failure
+If the colony was not properly sealed before entomb:
+- STOP -- do not archive an incomplete colony
+- Direct user to run /ant:seal first
+- This is a hard gate, not a suggestion
+
+### Chamber Naming Conflict
+If the target chamber directory already exists:
+- STOP -- do not overwrite an existing archive
+- Report the conflict
+- Options: (1) Use a different name, (2) Merge with existing, (3) Cancel
+</failure_modes>
+
+<success_criteria>
+Command is complete when:
+- Colony data is fully copied to chambers/ archive directory
+- Archive integrity is verified (all expected files present)
+- Active colony state is cleared only after archive verification
+- User sees confirmation with archive location
+</success_criteria>
+
+<read_only>
+Do not touch during entomb:
+- .aether/dreams/ (user notes -- not archived)
+- Source code files
+- .env* files
+- .claude/settings.json
+- .github/workflows/
+- Other chamber directories (only write to the new chamber)
+</read_only>
+
 ### Step 0: Initialize Visual Mode (if enabled)
 
 If `visual_mode` is true:
@@ -18,9 +56,8 @@ If `visual_mode` is true:
 # Generate session ID
 entomb_id="entomb-$(date +%s)"
 
-# Initialize swarm display
-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
+# 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
@@ -33,115 +70,109 @@ No colony to entomb. Run /ant:init first.
 ```
 Stop here.
 
-#### Step 1.5: Check for Concurrent Entomb Operations
+Extract: `goal`, `state`, `current_phase`, `plan.phases`, `milestone`, `version`, `initialized_at`, `memory.decisions`, `memory.phase_learnings`, `memory.instincts`.
 
-Capture session start time:
-```bash
-ENTOMB_START=$(date +%s)
-```
+### Step 2: Seal-First Enforcement
 
-Check for incomplete chamber operations:
-```bash
-# Check for incomplete chambers (no colony-state.json)
-incomplete_chambers=$(find .aether/chambers -type d -mindepth 1 -maxdepth 1 2>/dev/null | while read dir; do
-  if [[ ! -f "$dir/colony-state.json" ]]; then
-    echo "$dir"
-  fi
-done)
+Check `milestone` in COLONY_STATE.json.
 
-if [[ -n "$incomplete_chambers" ]]; then
-  echo "Warning: Incomplete chamber operations detected:"
-  echo "$incomplete_chambers"
-fi
+**If milestone != "Crowned Anthill":**
 ```
+Colony has not been sealed.
 
-### Step 2: Validate Colony Can Be Entombed
-
-Extract: `goal`, `state`, `current_phase`, `plan.phases`, `memory.decisions`, `memory.phase_learnings`.
-
-**Precondition 1: All phases must be completed**
+Current milestone: {milestone}
+Required: Crowned Anthill
 
-Check if all phases in `plan.phases` have `status: "completed"`:
-```
-all_completed = all(phase.status == "completed" for phase in plan.phases)
+Run /ant:seal first to complete the sealing ceremony.
 ```
+Stop here.
 
-If NOT all completed:
+**Belt-and-suspenders:** Also check `.aether/CROWNED-ANTHILL.md` exists. If milestone is Crowned Anthill but file is missing:
 ```
-Cannot entomb incomplete colony.
-
-Completed phases: X of Y
-Remaining: {list of incomplete phase names}
-
-Run /ant:continue to complete remaining phases first.
+CROWNED-ANTHILL.md not found — seal may have been interrupted. Run /ant:seal again.
 ```
 Stop here.
 
-**Precondition 2: State must not be EXECUTING**
+### Step 3: User Confirmation
 
-If `state == "EXECUTING"`:
-```
-Colony is still executing. Run /ant:continue to reconcile first.
+Show what will be archived:
 ```
-Stop here.
+ENTOMB COLONY
 
-**Precondition 3: No critical errors**
+Goal: {goal}
+Milestone: Crowned Anthill
+Phases: {phases_completed} of {total_phases}
 
-Check `errors.records` for any entries with `severity: "critical"`.
+This will:
+  - Archive ALL colony data to .aether/chambers/
+  - Copy CROWNED-ANTHILL.md, pheromones, dreams, session data
+  - Promote colony wisdom to QUEEN.md (cross-generational learning)
+  - Reset COLONY_STATE.json for a fresh start
+  - Clear session data
 
-If critical errors exist:
+This action is permanent. The archived colony can be browsed via /ant:tunnels.
+
+Entomb this colony? (yes/no)
 ```
-Cannot entomb colony with critical errors.
 
-Critical errors: {count}
-Run /ant:continue to resolve errors first.
+Use `AskUserQuestion with yes/no options`.
+
+If not "yes":
+```
+Entombment cancelled. Colony remains active.
 ```
 Stop here.
 
-### Step 3: Compute Milestone
+### Step 3.5: Check XML Tools
 
-Determine milestone based on phases completed:
-- 0 phases: "Fresh Start"
-- 1 phase: "First Mound"
-- 2-4 phases: "Open Chambers"
-- 5+ phases: "Sealed Chambers"
+XML archiving is required for entombment. Check tool availability before proceeding.
+Uses `command -v xmllint` directly — consistent with seal.md's tool check.
 
-If all phases completed AND user explicitly sealing: "Crowned Anthill"
-
-For entombment, use the computed milestone or extract from state if already set.
+```bash
+if command -v xmllint >/dev/null 2>&1; then
+  xmllint_available=true
+else
+  xmllint_available=false
+fi
+```
 
-### Step 4: User Confirmation
+**If xmllint is NOT available:**
 
-Display:
+Ask the user:
 ```
-🏺 ═══════════════════════════════════════════════════
-   E N T O M B   C O L O N Y
-══════════════════════════════════════════════════ 🏺
+xmllint is not installed — XML archiving requires it.
 
-Goal: {goal}
-Phases: {completed}/{total} completed
-Milestone: {milestone}
-
-Archive will include:
-  - COLONY_STATE.json
-  - manifest.json (pheromone trails)
+Install now?
+  - macOS: xcode-select --install (or brew install libxml2)
+  - Linux: apt-get install libxml2-utils
 
-This will reset the active colony. Continue? (yes/no)
+Install xmllint? (yes/no)
 ```
 
-Wait for explicit "yes" response before proceeding.
+Use AskUserQuestion with yes/no options.
 
-If user responds with anything other than "yes", display:
+If yes:
+- On macOS: Run `xcode-select --install` or `brew install libxml2`
+- On Linux: Run `sudo apt-get install -y libxml2-utils`
+- After install attempt, re-check: `command -v xmllint >/dev/null 2>&1`
+- If still not available after install:
+  ```
+  xmllint installation failed. Cannot entomb without XML archiving.
+  Install xmllint manually and try again.
+  ```
+  Stop here.
+
+If no:
 ```
-Entombment cancelled. Colony remains active.
+Entombment requires XML archiving. Install xmllint and try again.
 ```
 Stop here.
 
-### Step 5: Promote Wisdom to QUEEN.md
+### Step 4: Promote Wisdom to QUEEN.md
 
 Before creating the chamber, promote validated learnings to QUEEN.md for future colonies.
 
-**Step 5.1: Ensure QUEEN.md exists**
+**Step 4.1: Ensure QUEEN.md exists**
 
 ```bash
 queen_file=".aether/docs/QUEEN.md"
@@ -157,7 +188,7 @@ if [[ ! -f "$queen_file" ]]; then
 fi
 ```
 
-**Step 5.2: Extract and promote validated learnings**
+**Step 4.2: Extract and promote validated learnings**
 
 ```bash
 # Extract colony name from goal (sanitized)
@@ -210,7 +241,7 @@ if [[ -f "$queen_file" ]]; then
 fi
 ```
 
-**Step 5.3: Display promotion summary**
+**Step 4.3: Display promotion summary**
 
 ```
 ---
@@ -221,16 +252,16 @@ Promoted: {promotion_count} validated patterns to QUEEN.md
 ---
 ```
 
-### Step 6: Create Chamber
+### Step 5: Generate Chamber Name
 
-Generate chamber name:
+Date-first naming:
 ```bash
-sanitized_goal=$(echo "{goal}" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '-' | sed 's/^-//;s/-$//' | cut -c1-50)
-timestamp=$(date -u +%Y%m%d-%H%M%S)
-chamber_name="${sanitized_goal}-${timestamp}"
+date_prefix=$(date -u +%Y-%m-%d)
+sanitized_goal=$(echo "$goal" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '-' | sed 's/^-//;s/-$//' | cut -c1-40)
+chamber_name="${date_prefix}-${sanitized_goal}"
 ```
 
-Handle name collision: if directory exists, append counter:
+Collision handling:
 ```bash
 counter=1
 original_name="$chamber_name"
@@ -240,7 +271,7 @@ while [[ -d ".aether/chambers/$chamber_name" ]]; do
 done
 ```
 
-### Step 7: Create Chamber Using Utilities
+### Step 6: Create Chamber
 
 Extract decisions and learnings as JSON arrays:
 ```bash
@@ -254,27 +285,79 @@ version=$(jq -r '.version // "3.0"' .aether/data/COLONY_STATE.json)
 Create the chamber:
 ```bash
 bash .aether/aether-utils.sh chamber-create \
-  ".aether/chambers/{chamber_name}" \
+  ".aether/chambers/$chamber_name" \
   ".aether/data/COLONY_STATE.json" \
-  "{goal}" \
-  {phases_completed} \
-  {total_phases} \
-  "{milestone}" \
-  "{version}" \
-  '{decisions_json}' \
-  '{learnings_json}'
+  "$goal" \
+  "$phases_completed" \
+  "$total_phases" \
+  "$milestone" \
+  "$version" \
+  "$decisions_json" \
+  "$learnings_json"
+```
+
+### Step 7: Archive Additional Files
+
+AFTER chamber-create succeeds, copy additional data files:
+```bash
+chamber_dir=".aether/chambers/$chamber_name"
+
+# Archive data files (if they exist)
+for f in pheromones.json session.json activity.log flags.json constraints.json spawn-tree.txt timing.log view-state.json; do
+  [[ -f ".aether/data/$f" ]] && cp ".aether/data/$f" "$chamber_dir/" 2>/dev/null || true
+done
+
+# Archive seal document (critical — this is the ceremony record)
+[[ -f ".aether/CROWNED-ANTHILL.md" ]] && cp ".aether/CROWNED-ANTHILL.md" "$chamber_dir/"
+
+# Archive HANDOFF.md if it exists
+[[ -f ".aether/HANDOFF.md" ]] && cp ".aether/HANDOFF.md" "$chamber_dir/"
+
+# Archive dreams directory (optional — may not exist)
+[[ -d ".aether/dreams" ]] && cp -r ".aether/dreams" "$chamber_dir/dreams" 2>/dev/null || true
+```
+
+Do NOT copy: `.aether/data/backups/`, `.aether/data/locks/`, `.aether/data/midden/`, `.aether/data/survey/`.
+
+### Step 7.5: Export XML Archive (hard-stop)
+
+Export combined XML archive to the chamber. This is a HARD REQUIREMENT — entomb fails if XML export fails.
+
+```bash
+chamber_dir=".aether/chambers/$chamber_name"
+xml_result=$(bash .aether/aether-utils.sh colony-archive-xml "$chamber_dir/colony-archive.xml" 2>&1)
+xml_ok=$(echo "$xml_result" | jq -r '.ok // false' 2>/dev/null)
+
+if [[ "$xml_ok" != "true" ]]; then
+  # HARD STOP — remove the chamber and abort
+  rm -rf "$chamber_dir"
+  echo "XML archive export failed. Colony NOT entombed."
+  echo ""
+  echo "Error: $(echo "$xml_result" | jq -r '.error // "Unknown error"' 2>/dev/null)"
+  echo ""
+  echo "The chamber has been cleaned up. Fix the XML issue and try again."
+  # Do NOT proceed to state reset or any further steps
+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)"
+```
+
+**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.
+
 ### Step 8: Verify Chamber Integrity
 
 Run verification:
 ```bash
-bash .aether/aether-utils.sh chamber-verify ".aether/chambers/{chamber_name}"
+bash .aether/aether-utils.sh chamber-verify ".aether/chambers/$chamber_name"
 ```
 
 If verification fails, display error and stop:
 ```
-❌ Chamber verification failed.
+Chamber verification failed.
 
 Error: {verification_error}
 
@@ -283,31 +366,50 @@ The colony has NOT been reset. Please check the chamber directory:
 ```
 Stop here.
 
-### Step 9: Reset Colony State
+### Step 9: Record in Eternal Memory
+
+Write colony summary to eternal memory:
+```bash
+bash .aether/aether-utils.sh eternal-init  # idempotent
+eternal_file="$HOME/.aether/eternal/memory.json"
+if [[ -f "$eternal_file" ]]; then
+  colony_entry=$(jq -n \
+    --arg goal "$goal" \
+    --arg milestone "$milestone" \
+    --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"
+fi
+```
+
+### Step 10: Reset Colony State
 
 Backup current state:
 ```bash
 cp .aether/data/COLONY_STATE.json .aether/data/COLONY_STATE.json.bak
 ```
 
-Reset state while preserving memory (pheromones):
+Reset state, clearing everything including promoted wisdom (already in QUEEN.md):
 ```bash
-jq '
-  .goal = null |
-  .state = "IDLE" |
-  .current_phase = 0 |
-  .plan.phases = [] |
-  .plan.generated_at = null |
-  .plan.confidence = null |
-  .build_started_at = null |
-  .session_id = null |
-  .initialized_at = null |
-  .events = [] |
-  .errors.records = [] |
-  .errors.flagged_patterns = [] |
-  .signals = [] |
-  .graveyards = []
-' .aether/data/COLONY_STATE.json.bak > .aether/data/COLONY_STATE.json
+# Resolve jq template path (hub-first)
+jq_template=""
+for path in \
+  "$HOME/.aether/system/templates/colony-state-reset.jq.template" \
+  ".aether/templates/colony-state-reset.jq.template"; do
+  if [[ -f "$path" ]]; then
+    jq_template="$path"
+    break
+  fi
+done
+
+if [[ -z "$jq_template" ]]; then
+  echo "Template missing: colony-state-reset.jq.template. Run aether update to fix."
+  exit 1
+fi
+
+jq -f "$jq_template" .aether/data/COLONY_STATE.json.bak > .aether/data/COLONY_STATE.json
 ```
 
 Verify reset succeeded:
@@ -326,67 +428,72 @@ Remove backup after successful reset:
 rm -f .aether/data/COLONY_STATE.json.bak
 ```
 
-### Step 9.5: Write Final Handoff
-
-After entombing the colony, write the final handoff documenting the archived colony:
+Clear session data:
+```bash
+rm -f .aether/data/session.json
+```
 
+Clean up seal document (it's now in the chamber):
 ```bash
-cat > .aether/HANDOFF.md << 'HANDOFF_EOF'
-# Colony Session — ENTOMBED
+rm -f .aether/CROWNED-ANTHILL.md
+```
 
-## ⚰️ Colony Archived
-**Status:** Entombed in Chambers — Colony work preserved
+### Step 11: Write HANDOFF.md
 
-## Chamber Location
-.aether/chambers/{chamber_name}/
+Write handoff documenting the entombed colony:
 
-## Colony Summary
-- Goal: "{goal}"
-- Phases: {completed} completed of {total}
-- Milestone: {milestone}
-- Entombed At: {timestamp}
+Resolve the handoff template path:
+  Check ~/.aether/system/templates/handoff.template.md first,
+  then .aether/templates/handoff.template.md.
 
-## Chamber Contents
-- colony-state.json — Full colony state
-- manifest.json — Archive metadata
-- activity.log — Colony activity history
-- spawn-tree.txt — Worker spawn records
-- flags.json — Project flags (if existed)
+If no template found: output "Template missing: handoff.template.md. Run aether update to fix." and stop.
 
-## Session Note
-This colony has been entombed and the active state reset.
-The colony rests. Its learnings are preserved in the chamber.
+Read the template file. Fill all {{PLACEHOLDER}} values:
+  - {{CHAMBER_NAME}} → chamber_name
+  - {{GOAL}} → goal
+  - {{PHASES_COMPLETED}} → phases completed count
+  - {{TOTAL_PHASES}} → total phases count
+  - {{MILESTONE}} → milestone
+  - {{ENTOMB_TIMESTAMP}} → current ISO-8601 UTC timestamp
 
-To start anew: /ant:lay-eggs "<new goal>"
-To explore chambers: /ant:tunnels
-HANDOFF_EOF
-```
+Remove the HTML comment lines at the top of the template.
+Write the result to .aether/HANDOFF.md using the Write tool.
 
-This handoff serves as the record of the entombed colony.
+### Step 12: Display Result
 
-### Step 10: 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
+Colony archived successfully
 
-👑 Goal: {goal}
-📍 Phases: {completed} completed
-🏆 Milestone: {milestone}
+Goal: {goal}
+Phases: {completed} completed
+Milestone: {milestone}
 
-📦 Chamber: .aether/chambers/{chamber_name}/
+Chamber: .aether/chambers/{chamber_name}/
+{xml_archive_line}
 
-🐜 The colony rests. Its learnings are preserved.
+The colony rests. Its learnings live on in QUEEN.md.
 
-💾 State persisted — safe to /clear
+──────────────────────────────────────────────────
+🐜 Next Up
+──────────────────────────────────────────────────
+   /ant:lay-eggs            🥚 Start a new colony
+   /ant:tunnels             🗄️  Browse archived chambers
+```
 
-🐜 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
+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.
 
@@ -397,10 +504,20 @@ If option 3 selected: display "Run /ant:lay-eggs to begin anew after clearing"
 
 ### Edge Cases
 
-**Chamber name collision:** Automatically append counter to make unique.
+**Colony not sealed:**
+- Refuse with guidance to run /ant:seal first. This is the primary gate.
+
+**Chamber name collision:**
+- Automatically append counter to make unique.
+
+**Missing files during archive:**
+- Note in output but continue with available files. The `|| true` in the copy loop handles this.
 
-**Missing files during archive:** Note in output but continue with available files.
+**State reset failure:**
+- Restore from backup, display error, do not claim success.
 
-**State reset failure:** Restore from backup, display error, do not claim success.
+**Empty phases array:**
+- Can entomb a colony that was initialized but had no phases planned (treat as 0 of 0 completed).
 
-**Empty phases array:** Can entomb a colony that was initialized but had no phases planned (treat as 0 of 0 completed).
+**Missing CROWNED-ANTHILL.md:**
+- Refuse with guidance to run /ant:seal again.