aether-colony 1.1.0

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

@@ -0,0 +1,247 @@
+---
+name: ant:seal
+description: "🏺🐜🏺 Seal the colony with Crowned Anthill milestone"
+---
+
+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`.
+
+If file missing or `goal: null`:
+```
+No colony initialized. Run /ant:init first.
+```
+Stop here.
+
+### Step 2: Validate Colony Is Complete
+
+Extract: `goal`, `current_phase`, `plan.phases`, `milestone`, `state`.
+
+**Precondition 1: All phases must be completed**
+
+Check if all phases in `plan.phases` have `status: "completed"`:
+```
+all_completed = all(phase.status == "completed" for phase in plan.phases)
+```
+
+If NOT all completed:
+```
+Cannot archive colony with incomplete phases.
+
+Completed phases: X of Y
+Remaining: {list of incomplete phase names}
+
+Run /ant:continue to complete remaining phases first.
+```
+Stop here.
+
+**Precondition 2: State must not be EXECUTING**
+
+If `state == "EXECUTING"`:
+```
+Colony is still executing. Run /ant:continue to reconcile first.
+```
+Stop here.
+
+### Step 3: Check Milestone Eligibility
+
+The full milestone progression is:
+- **First Mound** — Phase 1 complete (first runnable)
+- **Open Chambers** — Feature work underway (2+ phases complete)
+- **Brood Stable** — Tests consistently green
+- **Ventilated Nest** — Perf/latency acceptable (build + lint clean)
+- **Sealed Chambers** — All phases complete (interfaces frozen)
+- **Crowned Anthill** — Release-ready (user confirms via /ant:seal)
+
+**If current milestone is "Crowned Anthill":**
+```
+Colony is already at Crowned Anthill milestone.
+No further archiving needed.
+
+Use /ant:status to view colony state.
+```
+Stop here.
+
+**If current milestone is "Sealed Chambers":**
+- Proceed to Step 4 (will upgrade to Crowned Anthill)
+
+**If current milestone is "First Mound", "Open Chambers", "Brood Stable", "Ventilated Nest", or any intermediate milestone:**
+- Since all phases are complete, the colony qualifies for both Sealed Chambers and Crowned Anthill
+- The current logic allows proceeding to Step 4 (seal as Crowned Anthill)
+- If user wants to explicitly achieve Sealed Chambers first, they can manually update milestone via COLONY_STATE.json
+
+**If milestone is unrecognized (not in the 6 known stages):**
+```
+Unknown milestone: {milestone}
+
+The milestone "{milestone}" is not recognized.
+Known milestones: First Mound, Open Chambers, Brood Stable, Ventilated Nest, Sealed Chambers, Crowned Anthill
+
+Run /ant:status to check colony state.
+```
+Stop here.
+
+### Step 4: Archive Colony State
+
+Create archive directory:
+```
+archive_dir=".aether/data/archive/session_$(date -u +%s)_archive"
+mkdir -p "$archive_dir"
+```
+
+Copy the following files to the archive directory:
+1. `.aether/data/COLONY_STATE.json` → `$archive_dir/COLONY_STATE.json`
+2. `.aether/data/activity.log` → `$archive_dir/activity.log`
+3. `.aether/data/spawn-tree.txt` → `$archive_dir/spawn-tree.txt`
+4. `.aether/data/flags.json` → `$archive_dir/flags.json` (if exists)
+5. `.aether/data/constraints.json` → `$archive_dir/constraints.json` (if exists)
+
+Create archive manifest file `$archive_dir/manifest.json`:
+```json
+{
+  "archived_at": "<ISO-8601 timestamp>",
+  "goal": "<colony goal>",
+  "total_phases": <number>,
+  "milestone": "Crowned Anthill",
+  "files": [
+    "COLONY_STATE.json",
+    "activity.log",
+    "spawn-tree.txt",
+    "flags.json",
+    "constraints.json"
+  ]
+}
+```
+
+### 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|archive|Achieved Crowned Anthill milestone - colony archived"`
+
+### Step 5.5: Write Final Handoff
+
+After archiving, write the final handoff documenting the completed colony:
+
+Resolve the handoff template path:
+  Check ~/.aether/system/templates/handoff.template.md first,
+  then .aether/templates/handoff.template.md.
+
+If no template found: output "Template missing: handoff.template.md. Run aether update to fix." and stop.
+
+Read the template file. Fill all {{PLACEHOLDER}} values:
+  - {{CHAMBER_NAME}} → archive directory name
+  - {{GOAL}} → goal
+  - {{PHASES_COMPLETED}} → total_phases (OpenCode seal archives completed colonies)
+  - {{TOTAL_PHASES}} → total_phases
+  - {{MILESTONE}} → "Crowned Anthill"
+  - {{ENTOMB_TIMESTAMP}} → seal timestamp
+
+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 final record of the completed colony.
+
+### Step 5.75: 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 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:
+```
+🏺 ════════════════════════════════════════════════════
+   C R O W N E D   A N T H I L L
+══════════════════════════════════════════════════ 🏺
+
+✅ Colony archived successfully!
+
+👑 Goal: {goal (truncated to 60 chars)}
+📍 Phases: {total_phases} completed
+🏆 Milestone: Crowned Anthill
+
+📦 Archive Location: {archive_dir}
+   - COLONY_STATE.json
+   - activity.log
+   - spawn-tree.txt
+   - flags.json (if existed)
+   - constraints.json (if existed)
+{xml_export_line}
+
+🐜 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
+
+**If milestone is already "Sealed Chambers" but phases are complete:**
+- Proceed with archiving and upgrade to Crowned Anthill
+
+**If any archive files are missing:**
+- Archive what exists, note in manifest which files were missing
+
+**If archive directory already exists:**
+- Append timestamp to make unique: `session_<ts>_archive_<random>`

package/.opencode/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).