aether-colony 1.1.0

package/.claude/commands/ant/seal.md

@@ -0,0 +1,306 @@
+---
+name: ant:seal
+description: "🏺🐜🏺 Seal the colony with Crowned Anthill milestone"
+---
+
+You are the **Queen**. Seal the colony with a ceremony — no archiving.
+
+## Instructions
+
+Parse `$ARGUMENTS`:
+- If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
+- Otherwise: set `visual_mode = true`
+
+<failure_modes>
+### Crowned Anthill Write Failure
+If writing the Crowned Anthill milestone document fails:
+- Do not mark the colony as sealed in state
+- Report the error -- sealing is incomplete
+- Recovery: user can re-run /ant:seal after fixing the issue
+
+### State Update Failure After Seal
+If COLONY_STATE.json update fails after seal document is written:
+- The seal document exists but state doesn't reflect it
+- Report the inconsistency
+- Options: (1) Retry state update only, (2) Manual state fix, (3) Re-run /ant:seal
+</failure_modes>
+
+<success_criteria>
+Command is complete when:
+- Crowned Anthill milestone document is written
+- COLONY_STATE.json reflects sealed status
+- All phase evidence is summarized in the seal document
+- User sees confirmation of successful seal
+</success_criteria>
+
+<read_only>
+Do not touch during seal:
+- .aether/dreams/ (user notes)
+- .aether/chambers/ (archived colonies -- seal does NOT archive)
+- Source code files
+- .env* files
+- .claude/settings.json
+</read_only>
+
+### Step 0: Initialize Visual Mode (if enabled)
+
+If `visual_mode` is true:
+```bash
+# Generate session ID
+seal_id="seal-$(date +%s)"
+
+# Initialize swarm display (consolidated)
+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`.
+
+If file missing or `goal: null`:
+```
+No colony initialized. Run /ant:init first.
+```
+Stop here.
+
+Extract: `goal`, `state`, `current_phase`, `plan.phases`, `milestone`, `version`, `initialized_at`.
+
+### Step 2: Maturity Gate
+
+Run `bash .aether/aether-utils.sh milestone-detect` to get `milestone`, `phases_completed`, `total_phases`.
+
+**If milestone is already "Crowned Anthill":**
+```
+Colony already sealed at Crowned Anthill.
+Run /ant:entomb to archive this colony to chambers.
+```
+Stop here.
+
+**If state is "EXECUTING":**
+```
+Colony is still executing. Run /ant:continue first.
+```
+Stop here.
+
+**If all phases complete** (phases_completed == total_phases, or milestone is "Sealed Chambers"):
+- Set `incomplete_warning = ""` (no warning needed)
+- Proceed to Step 3.
+
+**If phases are incomplete** (any other milestone — First Mound, Open Chambers, Brood Stable, Ventilated Nest, etc.):
+- Set `incomplete_warning = "WARNING: {phases_completed} of {total_phases} phases complete. Sealing now will mark incomplete work as the final state."`
+- Proceed to Step 3 (warn but DO NOT block).
+
+### Step 3: Confirmation
+
+Display what will be sealed:
+```
+SEAL COLONY
+
+Goal: {goal}
+Phases: {phases_completed} of {total_phases} completed
+Current Milestone: {milestone}
+
+{If incomplete_warning is not empty, display it here}
+
+This will:
+  - Award the Crowned Anthill milestone
+  - Write CROWNED-ANTHILL.md ceremony record
+  - Promote colony wisdom to QUEEN.md
+
+Seal this colony? (yes/no)
+```
+
+Use `AskUserQuestion with yes/no options`.
+
+If not "yes":
+```
+Sealing cancelled. Colony remains active.
+```
+Stop here.
+
+### Step 3.5: Wisdom Approval
+
+Before sealing, 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 "   🧠 WISDOM REVIEW"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+  echo "Review wisdom proposals before sealing 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 sealing ceremony..."
+  echo ""
+else
+  echo "No wisdom proposals to review."
+fi
+```
+
+### Step 4: Log Seal Activity
+
+Log the seal ceremony to activity log:
+```bash
+bash .aether/aether-utils.sh activity-log "MODIFIED" "Queen" "Colony sealed - wisdom review completed"
+```
+
+### Step 5: Update Milestone to Crowned Anthill
+
+Update COLONY_STATE.json:
+1. Set `milestone` to `"Crowned Anthill"`
+2. Set `milestone_updated_at` to current ISO-8601 timestamp
+3. Append event: `"<timestamp>|milestone_reached|seal|Achieved Crowned Anthill milestone"`
+
+Run `bash .aether/aether-utils.sh validate-state colony` after write.
+
+### Step 6: Write CROWNED-ANTHILL.md
+
+Calculate colony age:
+```bash
+initialized_at=$(jq -r '.initialized_at // empty' .aether/data/COLONY_STATE.json)
+if [[ -n "$initialized_at" ]]; then
+  init_epoch=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" "$initialized_at" +%s 2>/dev/null || echo 0)
+  now_epoch=$(date +%s)
+  if [[ "$init_epoch" -gt 0 ]]; then
+    colony_age_days=$(( (now_epoch - init_epoch) / 86400 ))
+  else
+    colony_age_days=0
+  fi
+else
+  colony_age_days=0
+fi
+```
+
+Extract phase recap:
+```bash
+phase_recap=""
+while IFS= read -r phase_line; do
+  phase_name=$(echo "$phase_line" | jq -r '.name')
+  phase_status=$(echo "$phase_line" | jq -r '.status')
+  phase_recap="${phase_recap}  - ${phase_name}: ${phase_status}\n"
+done < <(jq -c '.plan.phases[]' .aether/data/COLONY_STATE.json 2>/dev/null)
+```
+
+Write the seal document:
+```bash
+version=$(jq -r '.version // "3.0"' .aether/data/COLONY_STATE.json)
+seal_date=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+```
+
+Resolve the crowned-anthill template path:
+  Check ~/.aether/system/templates/crowned-anthill.template.md first,
+  then .aether/templates/crowned-anthill.template.md.
+
+If no template found: output "Template missing: crowned-anthill.template.md. Run aether update to fix." and stop.
+
+Read the template file. Fill all {{PLACEHOLDER}} values:
+  - {{GOAL}} → goal (from colony state)
+  - {{SEAL_DATE}} → seal_date (ISO-8601 UTC timestamp)
+  - {{VERSION}} → version (from colony state)
+  - {{TOTAL_PHASES}} → total_phases
+  - {{PHASES_COMPLETED}} → phases_completed
+  - {{COLONY_AGE_DAYS}} → colony_age_days
+  - {{PROMOTIONS_MADE}} → promotions_made
+  - {{PHASE_RECAP}} → phase recap list (one entry per line, formatted from the bash loop above)
+
+Remove the HTML comment lines at the top of the template (lines starting with <!--).
+Write the result to .aether/CROWNED-ANTHILL.md using the Write tool.
+
+### Step 6.5: Export XML Archive (best-effort)
+
+Export colony data as a combined XML archive. This is best-effort — seal proceeds even if XML export fails.
+
+```bash
+# Check if xmllint is available
+if command -v xmllint >/dev/null 2>&1; then
+  xml_result=$(bash .aether/aether-utils.sh colony-archive-xml ".aether/exchange/colony-archive.xml" 2>&1)
+  xml_ok=$(echo "$xml_result" | jq -r '.ok // false' 2>/dev/null)
+  if [[ "$xml_ok" == "true" ]]; then
+    xml_pheromone_count=$(echo "$xml_result" | jq -r '.result.pheromone_count // 0' 2>/dev/null)
+    xml_export_line="XML Archive: colony-archive.xml (${xml_pheromone_count} active signals)"
+  else
+    xml_export_line="XML Archive: export failed (non-blocking)"
+  fi
+else
+  xml_export_line="XML Archive: skipped (xmllint not available)"
+fi
+```
+
+### Step 7: Display Ceremony
+
+**If visual_mode is true, render swarm display BEFORE the ASCII art (consolidated):**
+```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-inline "$seal_id"
+```
+
+Display the ASCII art ceremony:
+```
+        .     .
+       /|\   /|\
+      / | \ / | \
+     /  |  X  |  \
+    /   | / \ |   \
+   /    |/   \|    \
+  /     /     \     \
+ /____ /  ___  \ ____\
+      / /   \ \
+     / /     \ \
+    /_/       \_\
+     |  CROWNED |
+     | ANTHILL  |
+     |__________|
+```
+
+Below the ASCII art, display:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   C R O W N E D   A N T H I L L
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Goal: {goal}
+Phases: {phases_completed} of {total_phases} completed
+{If incomplete_warning is not empty: display it}
+Wisdom Promoted: {promotion_summary}
+
+Seal Document: .aether/CROWNED-ANTHILL.md
+{xml_export_line}
+
+The colony stands crowned and sealed.
+Its wisdom lives on in QUEEN.md.
+The anthill has reached its final form.
+
+──────────────────────────────────────────────────
+🐜 Next Up
+──────────────────────────────────────────────────
+   /ant:entomb              🏺 Archive colony to chambers
+   /ant:lay-eggs            🥚 Start a new colony
+   /ant:tunnels             🗄️  Browse archived chambers
+```
+
+### Edge Cases
+
+**Colony already at Crowned Anthill:**
+- Display message and guide to /ant:entomb. Do NOT re-seal.
+
+**Phases incomplete:**
+- Warn but allow. The seal proceeds after confirmation.
+
+**Missing QUEEN.md:**
+- queen-init creates it. If that fails, skip promotion (non-fatal).
+
+**Missing initialized_at:**
+- Colony age defaults to 0 days.
+
+**Empty phases array:**
+- Can seal a colony with 0 phases (rare but valid). phases_completed = 0, total_phases = 0.

package/.claude/commands/ant/status.md

@@ -0,0 +1,272 @@
+---
+name: ant:status
+description: "📈🐜🏘️🐜📈 Show colony status at a glance"
+---
+
+You are the **Queen**. Show colony status.
+
+## Instructions
+
+### Step 0: Version Check (Non-blocking)
+
+Run using the Bash tool with description "Checking colony version...": `bash .aether/aether-utils.sh version-check-cached 2>/dev/null || true`
+
+If the command succeeds and the JSON result contains a non-empty string, display it as a one-line notice. Proceed regardless of outcome.
+
+### Step 1: Read State + Version Check
+
+Read `.aether/data/COLONY_STATE.json`.
+
+If file missing or `goal: null`:
+```
+No colony initialized. Run /ant:init first.
+```
+Stop here.
+
+**Auto-upgrade old state:**
+If `version` field is missing, "1.0", or "2.0":
+1. Preserve: `goal`, `state`, `current_phase`, `plan.phases` (keep phase structure)
+2. Write upgraded state:
+```json
+{
+  "version": "3.0",
+  "goal": "<preserved>",
+  "state": "<preserved or 'READY'>",
+  "current_phase": <preserved or 0>,
+  "session_id": "migrated_<timestamp>",
+  "initialized_at": "<preserved or now>",
+  "build_started_at": null,
+  "plan": {
+    "generated_at": "<preserved or null>",
+    "confidence": null,
+    "phases": <preserved or []>
+  },
+  "memory": { "phase_learnings": [], "decisions": [], "instincts": [] },
+  "errors": { "records": [], "flagged_patterns": [] },
+  "events": ["<now>|state_upgraded|system|Auto-upgraded from v<old> to v3.0"]
+}
+```
+3. Output: `State auto-upgraded to v3.0`
+4. Continue with command.
+
+### Step 1.5: Load State and Show Resumption Context
+
+Run using the Bash tool with description "Loading colony state...": `bash .aether/aether-utils.sh load-state`
+
+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
+   ```
+
+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)
+
+Run using the Bash tool with description "Releasing colony lock...": `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 the Bash tool with description "Counting dream entries...": `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, run using the Bash tool with description "Finding latest dream...":
+```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`
+- Phase name: `plan.phases[current_phase - 1].name` (if exists)
+
+**Task progress:**
+- If phases exist, count tasks in current phase
+- Completed: tasks with `status: "completed"`
+- Total: all tasks in current phase
+
+**Constraints:**
+Read `.aether/data/constraints.json` if exists:
+- Focus count: `focus.length`
+- Constraints count: `constraints.length`
+
+**Flags:**
+Run using the Bash tool with description "Checking for blockers...": `bash .aether/aether-utils.sh flag-check-blockers`
+Extract:
+- Blockers count (critical, block advancement)
+- Issues count (high, warnings)
+- Notes count (low, informational)
+
+**Escalation state:**
+Count escalated flags by checking for blocker flags with source "escalation":
+
+Run using the Bash tool with description "Checking escalation state...":
+```bash
+escalated_count=$(bash .aether/aether-utils.sh flag-list --type blocker 2>/dev/null | jq '[.result.flags[] | select(.source == "escalation")] | length' 2>/dev/null || echo "0")
+echo "escalated_count=$escalated_count"
+```
+
+**Instincts:**
+From `memory.instincts`:
+- Total count: `instincts.length`
+- High confidence (≥0.7): count where confidence >= 0.7
+- Top 3: sorted by confidence descending
+
+**Colony state:**
+- `state` field (IDLE, READY, EXECUTING, PLANNING)
+
+**Milestone:**
+- `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 the Bash tool with description "Detecting colony milestone...": `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 2.8: Load Memory Health Metrics
+
+Run using the Bash tool with description "Loading memory health metrics...":
+```bash
+bash .aether/aether-utils.sh memory-metrics
+```
+
+Extract from JSON result:
+- wisdom.total
+- pending.total
+- recent_failures.count
+- last_activity.queen_md_updated
+- last_activity.learning_captured
+
+Format timestamps for display (YYYY-MM-DD HH:MM).
+
+### Step 2.7: Generate Progress Bars
+
+Calculate progress metrics and generate visual bars.
+
+Run using the Bash tool with description "Computing phase progress...":
+```bash
+current_phase=$(jq -r '.current_phase // 0' .aether/data/COLONY_STATE.json)
+total_phases=$(jq -r '.plan.phases | length' .aether/data/COLONY_STATE.json)
+
+# Calculate task progress in current phase
+if [[ "$current_phase" -gt 0 && "$current_phase" -le "$total_phases" ]]; then
+  phase_idx=$((current_phase - 1))
+  tasks_completed=$(jq -r ".plan.phases[$phase_idx].tasks // [] | map(select(.status == \"completed\")) | length" .aether/data/COLONY_STATE.json)
+  tasks_total=$(jq -r ".plan.phases[$phase_idx].tasks // [] | length" .aether/data/COLONY_STATE.json)
+  phase_name=$(jq -r ".plan.phases[$phase_idx].name // \"Unnamed\"" .aether/data/COLONY_STATE.json)
+else
+  tasks_completed=0
+  tasks_total=0
+  phase_name="No plan created"
+fi
+
+# Generate progress bars
+phase_bar=$(bash .aether/aether-utils.sh generate-progress-bar "$current_phase" "$total_phases" 20)
+task_bar=$(bash .aether/aether-utils.sh generate-progress-bar "$tasks_completed" "$tasks_total" 20)
+
+echo "phase_bar=$phase_bar"
+echo "task_bar=$task_bar"
+echo "phase_name=$phase_name"
+```
+
+Store `phase_bar`, `task_bar`, and `phase_name` values for display in Step 3.
+
+### Step 3: Display
+
+Output format:
+
+```
+       .-.
+      (o o)  AETHER COLONY
+      | O |  Status Report
+       `-`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+👑 Goal: <goal (truncated to 60 chars)>
+
+📍 Progress
+   Phase: [████████░░░░░░░░░░░░] <N>/<M> phases
+   Tasks: [████████████████░░░░] <completed>/<total> tasks in Phase <N>
+
+🎯 Focus: <focus_count> areas | 🚫 Avoid: <constraints_count> patterns
+🧠 Instincts: <total> learned (<high_confidence> strong)
+🚩 Flags: <blockers> blockers | <issues> issues | <notes> notes
+{if escalated_count > 0:}
+⚠️  Escalated: {escalated_count} task(s) awaiting your decision
+{end if}
+🏆 Milestone: <milestone> (<version>)
+💭 Dreams: <dream_count> recorded (latest: <latest_dream>)
+
+📚 Memory Health
+┌─────────────────┬────────┬─────────────────────────────┐
+│ Metric          │ Count  │ Last Updated                │
+├─────────────────┼────────┼─────────────────────────────┤
+│ Wisdom Entries  │ {wisdom_total:>6} │ {queen_updated}             │
+│ Pending Promos  │ {pending_total:>6} │ {learning_updated}          │
+│ Recent Failures │ {failures_count:>6} │ {last_failure}              │
+└─────────────────┴────────┴─────────────────────────────┘
+
+State: <state>
+```
+
+Use the `phase_bar` and `task_bar` values computed in Step 2.7 for the actual bar characters and counts.
+
+**If instincts exist, also show top 3:**
+```
+🧠 Colony Instincts:
+   [0.9] 🐜 testing: Always run tests before completion
+   [0.8] 🐜 architecture: Use composition over inheritance
+   [0.7] 🐜 debugging: Trace to root cause first
+```
+
+**Dream display:**
+- If no dreams exist: `💭 Dreams: None recorded`
+- If dreams exist: `💭 Dreams: <count> recorded (latest: YYYY-MM-DD HH:MM)`
+
+**Memory Health display:**
+- If memory-metrics returns empty/null values, show:
+```
+📚 Memory Health
+   No memory data available. Colony wisdom will accumulate as you complete phases.
+```
+
+**Edge cases:**
+- No phases yet: show `[░░░░░░░░░░░░░░░░░░░░] 0/0 phases`
+- No tasks in phase: show `[░░░░░░░░░░░░░░░░░░░░] 0/0 tasks in Phase 0`
+- No constraints file: "Constraints: 0 focus, 0 avoid"
+
+**At the end of the output, generate the Next Up block:**
+
+Run using the Bash tool with description "Generating next steps...":
+```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"
+```
+
+This auto-generates state-based recommendations (IDLE → init, READY → build, EXECUTING → continue, PLANNING → plan).