aether-colony 5.0.0 → 5.1.0

package/.claude/commands/ant/redirect.md

@@ -1,10 +1,14 @@
+<!-- Generated from .aether/commands/redirect.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:redirect
 description: "Emit REDIRECT signal to warn colony away from patterns"
 ---
 
+
 You are the **Queen**. Emit a REDIRECT pheromone signal.
 
+
+
 ## Instructions
 
 The pattern to avoid is: `$ARGUMENTS`
@@ -14,15 +18,18 @@ The pattern to avoid is: `$ARGUMENTS`
 If `$ARGUMENTS` empty -> show usage: `/ant:redirect <pattern to avoid>`, stop.
 If content > 500 chars -> "Redirect content too long (max 500 chars)", stop.
 
+
 Parse optional flags from `$ARGUMENTS`:
 - `--ttl <value>`: signal lifetime (e.g., `2h`, `1d`, `7d`). Default: `phase_end`.
 - Strip flags from content before using it as the pattern.
 
+
 ### Step 2: Write Signal
 
 Read `.aether/data/COLONY_STATE.json`.
 If `goal: null` -> "No colony initialized.", stop.
 
+
 Run using the Bash tool with description "Setting colony redirect...":
 ```bash
 bash .aether/aether-utils.sh pheromone-write REDIRECT "<content>" --strength 0.9 --reason "User warned colony away from pattern" --ttl <ttl>
@@ -30,6 +37,13 @@ bash .aether/aether-utils.sh pheromone-write REDIRECT "<content>" --strength 0.9
 
 Parse the returned JSON for the signal ID.
 
+### Step 2.5: Update Context Document
+
+Run using the Bash tool with description "Updating context document...":
+```bash
+bash .aether/aether-utils.sh context-update constraint redirect "<content>" "user" 2>/dev/null || true
+```
+
 ### Step 3: Get Active Counts
 
 Run using the Bash tool with description "Counting active signals...":
@@ -47,6 +61,9 @@ REDIRECT signal emitted
   Active signals: <focus_count> FOCUS, <redirect_count> REDIRECT, <feedback_count> FEEDBACK
 ```
 
+
+
+
 ### Step 5: Next Up
 
 Generate the state-based Next Up block by running using the Bash tool with description "Generating Next Up suggestions...":
@@ -56,3 +73,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/resume-colony.md

@@ -1,3 +1,4 @@
+<!-- Generated from .aether/commands/resume-colony.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:resume-colony
 description: "🚦➡️🐜💨💨 Resume colony from saved session - restores all state"
@@ -14,15 +15,6 @@ Parse `$ARGUMENTS`:
 ### Step 0: Initialize Visual Mode (if enabled)
 
 If `visual_mode` is true, run using the Bash tool with description "Initializing resume display...":
-```bash
-# Generate session ID
-resume_id="resume-$(date +%s)"
-
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$resume_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Resuming colony" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
-```
-
 ### Step 0.5: 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`
@@ -43,13 +35,35 @@ Keep state loaded (don't unload yet) - we'll need it for the full display.
 
 ### Step 2: Compute Active Signals
 
-Read active signals from COLONY_STATE.json `signals` array (already loaded in Step 1).
+Run using the Bash tool with description "Loading active pheromones...":
+```bash
+bash .aether/aether-utils.sh pheromone-read
+```
+
+Use `.result.signals` as the active signal list (already decay-filtered by runtime logic).
+If empty, treat as "no active pheromones."
 
-Filter signals where:
-- `expires_at` is null (permanent signals like INIT), OR
-- `expires_at` > current timestamp (not expired)
+### Step 2.5: Load Survey Context (Advisory)
 
-If `signals` array is empty or all expired, treat as "no active pheromones."
+Run using the Bash tool with description "Loading survey context...":
+```bash
+survey_docs=$(ls -1 .aether/data/survey/*.md 2>/dev/null | wc -l | tr -d ' ')
+survey_latest=$(ls -t .aether/data/survey/*.md 2>/dev/null | head -1)
+if [[ -n "$survey_latest" ]]; then
+  now_epoch=$(date +%s)
+  modified_epoch=$(stat -f %m "$survey_latest" 2>/dev/null || stat -c %Y "$survey_latest" 2>/dev/null || echo 0)
+  survey_age_days=$(( (now_epoch - modified_epoch) / 86400 ))
+else
+  survey_age_days=-1
+fi
+echo "survey_docs=$survey_docs"
+echo "survey_age_days=$survey_age_days"
+```
+
+Interpretation:
+- `survey_docs == 0` => survey missing
+- `survey_age_days > 14` => survey stale
+- otherwise survey fresh
 
 ### Step 3: Display Restored State
 
@@ -87,18 +101,18 @@ PHASE PROGRESS
   Phase <id>: <name> [<status>]
   (list all phases from plan.phases)
 
+SURVEY CONTEXT
+  Docs: <survey_docs>
+  Age: <survey_age_days> days
+  Status: <fresh|stale|missing>
+  Recommendation: <if missing or stale, suggest /ant:colonize --force-resurvey>
+
 CONTEXT FROM HANDOFF
   <summarize what was happening from .aether/HANDOFF.md>
 
 NEXT ACTIONS
 ```
 
-**If visual_mode is true, render final swarm display** by running using the Bash tool with description "Updating resume display...":
-```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony resumed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":1}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-text "$resume_id"
-```
-
 Route to next action based on state:
 - If state is `READY` and there's a pending phase -> suggest `/ant:build <phase>`
 - If state is `EXECUTING` -> note that a build was interrupted, suggest restarting with `/ant:build <phase>`

package/.claude/commands/ant/resume.md

@@ -1,7 +1,7 @@
+<!-- Generated from .aether/commands/resume.yaml - DO NOT EDIT DIRECTLY -->
 ---
-name: resume
+name: ant:resume
 description: "Resume Previous Session"
-symbol: refresh
 ---
 
 # /ant:resume — Resume Previous Session
@@ -24,7 +24,7 @@ Execute the following steps in order when the user runs `/ant:resume`.
 
 ### Step 1: Read Session State
 
-Run using the Bash tool with description "Restoring colony session...":
+Run using the Bash tool with description "Restoring colony session..."::
 ```bash
 bash .aether/aether-utils.sh session-read
 ```
@@ -35,6 +35,7 @@ Parse the JSON result.
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
 RESUME SESSION
 
 No previous session found.
@@ -42,6 +43,7 @@ No previous session found.
 Start fresh: /ant:init "your goal"
 Or check: /ant:status
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
 ```
 
 - If `exists` is `true`: extract from the session data:
@@ -85,6 +87,7 @@ Do NOT proceed with stale or fabricated data.
 
 ### Step 3: Read Pheromone Signals
 
+
 Use the Read tool to read `.aether/data/constraints.json`.
 
 Extract the following top-level keys:
@@ -95,6 +98,8 @@ If the file is missing: skip silently (no pheromones active).
 
 Pheromones persist until explicitly cleared — no decay.
 
+
+
 ---
 
 ### Step 4: Read CONTEXT.md
@@ -238,6 +243,7 @@ Lead with the next-step recommendation. Context follows underneath ("straight to
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
 RESUME SESSION
 
 Next: {recommended}
@@ -273,15 +279,47 @@ Recent Decisions:
 {end}
 {end}
 
-{if focus array or constraints array is not empty:}
+{if signals array from Step 3 is not empty:}
 Active Signals:
+
 {for each focus signal:}
   FOCUS: {focus text}
 {end}
 {for each constraint signal:}
   REDIRECT: {constraint text}
 {end}
+
+
 {end}
+```
+
+---
+
+### Step 8.5: Display Memory Health (Secondary)
+
+Run using the Bash tool with description "Loading memory health..."::
+```bash
+bash .aether/aether-utils.sh resume-dashboard
+```
+
+Extract memory_health from the JSON result:
+- wisdom_count
+- pending_promotions
+- recent_failures
+
+Display after the main dashboard:
+```
+📊 Memory Health
+   Wisdom: {wisdom_count} entries | Pending: {pending_promotions} promotions | Failures: {recent_failures} recent
+
+   Run /ant:memory-details for full breakdown
+```
+
+If all counts are 0, show:
+```
+📊 Memory Health
+   No accumulated wisdom yet. Complete phases to build colony memory.
+```
 
 Last Command: {last_command}
 Session: {session_id}
@@ -291,14 +329,14 @@ Session: {session_id}
 
 ### Step 9: Mark Session Resumed
 
-Run using the Bash tool with description "Marking session as resumed...":
+Run using the Bash tool with description "Marking session as resumed..."::
 ```bash
 bash .aether/aether-utils.sh session-mark-resumed
 ```
 
 ### Step 10: Next Up
 
-Generate the state-based Next Up block by running using the Bash tool with description "Generating Next Up suggestions...":
+Generate the state-based Next Up block by Run 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)
@@ -314,7 +352,10 @@ bash .aether/aether-utils.sh print-next-up "$state" "$current_phase" "$total_pha
 |-----------|----------|
 | session.json missing (exists=false) | "No previous session found" — offer /ant:init and /ant:status |
 | COLONY_STATE.json missing or corrupted | Pause, ask user: start fresh or recover |
+
 | constraints.json missing | Skip silently (no pheromones) |
+
+
 | CONTEXT.md missing | Fall back to COLONY_STATE.json narrative |
 | No plan phases, no generated_at | BLOCK — redirect to /ant:plan |
 | Plan attempted but no phases | BLOCK — redirect to /ant:plan |
@@ -326,7 +367,10 @@ bash .aether/aether-utils.sh print-next-up "$state" "$current_phase" "$total_pha
 
 ## Key Constraints
 
-- Use Read tool for COLONY_STATE.json and constraints.json (not bash cat/jq)
+
+- Use Read tool for COLONY_STATE.json and constraints.json (not bash cat/jq).
+
+
 - Use Bash tool only for aether-utils.sh commands and git commands
 - Handle ALL missing/corrupted file cases gracefully
 - Time-agnostic: restore identically regardless of how long ago the session was

package/.claude/commands/ant/run.md

@@ -0,0 +1,195 @@
+<!-- Generated from .aether/commands/run.yaml - DO NOT EDIT DIRECTLY -->
+---
+name: ant:run
+description: "Autopilot — builds, verifies, learns, and advances through phases automatically with smart pausing"
+---
+
+You are the **Queen**. Execute `/ant:run` — the adaptive autopilot loop.
+
+The arguments are: `$ARGUMENTS`
+
+## Purpose
+
+This command automates the build-continue-advance cycle across multiple phases.
+It reads and executes the same playbooks used by `/ant:build` and `/ant:continue`,
+chaining them in a loop with intelligent pause conditions.
+
+## Rules
+
+1. Do **not** invoke nested slash commands (`/ant:build`, `/ant:continue`, etc.).
+2. Use the Read tool to load each playbook file, then execute it inline.
+3. Preserve variables/results from prior stages and pass them forward.
+4. Stop immediately on any pause condition (defined below).
+5. Keep existing behavior and output format from the playbooks.
+6. Log `autopilot_advance` events after each successful phase transition.
+
+## Arguments
+
+Parse `$ARGUMENTS` for:
+- `--max-phases N` — Max phases to process (default: all remaining)
+- `--replan-interval N` — Pause for replan suggestion every N phases (default: 2)
+- `--continue` — Resume after a replan pause without replanning
+- `--dry-run` — Preview plan without executing
+- `--verbose` / `-v`, `--no-visual`, `--no-suggest` — Pass through to playbooks
+
+```
+/ant:run                       Run all remaining phases
+/ant:run --max-phases 2        Run at most 2 phases then stop
+/ant:run --replan-interval 3   Suggest replan every 3 phases instead of 2
+/ant:run --continue            Resume after replan pause without replanning
+/ant:run --dry-run             Preview the autopilot plan
+/ant:run --max-phases 3 -v     Run 3 phases with verbose output
+```
+
+## Dry Run Mode
+
+If `--dry-run`: read COLONY_STATE.json, list remaining incomplete phases
+(applying `--max-phases` cap), display the plan, then stop without executing.
+
+```
+━━━ A U T O P I L O T   P R E V I E W ━━━
+Goal: {goal} | Current: Phase {N} | Remaining: {count} | Max: {max or "all"}
+
+  Phase {id}: {name} ({task_count} tasks) -> build -> continue -> advance
+  ...
+
+Pause triggers: test failures, critical Chaos findings, new blockers,
+security gate failures, quality gate failures, runtime verification needed,
+replan suggestion (every {replan_interval} phases)
+```
+
+## Autopilot Loop
+
+### Step 0: Initialize
+
+1. Read `.aether/data/COLONY_STATE.json`; validate goal + plan.phases exist
+2. Determine remaining incomplete phases; apply `--max-phases` cap
+3. Set `phases_completed = 0`, `autopilot_start = $(date +%s)`
+4. Record pre-build blocker count: `bash .aether/aether-utils.sh flag-check-blockers {phase}`
+5. Display: `AUTOPILOT ENGAGED | Goal: {goal} | Phase {N} | Max: {max or "all"}`
+
+### Step 1: Build Phase
+
+Execute build playbooks in order, carrying cross-stage state
+(`phase_id`, `visual_mode`, `verbose_mode`, `suggest_enabled`,
+`prompt_section`, `wave_results`,
+`verification_status`, `synthesis_status`, `next_action`):
+
+1. `.aether/docs/command-playbooks/build-prep.md`
+2. `.aether/docs/command-playbooks/build-context.md`
+3. `.aether/docs/command-playbooks/build-wave.md`
+4. `.aether/docs/command-playbooks/build-verify.md`
+5. `.aether/docs/command-playbooks/build-complete.md`
+
+Capture the synthesis result for pause evaluation.
+
+### Step 2: Build Pause Check
+
+**PAUSE if ANY of these are true** (display reason, log event, STOP):
+
+| # | Condition | Source |
+|---|-----------|--------|
+| 1 | Watcher `verification_passed == false` | build-verify synthesis |
+| 2 | Any Chaos finding severity `critical` or `high` | build-verify synthesis |
+| 3 | New blocker flags created (count increased since Step 0.4) | flag-check-blockers |
+
+On pause, display the AUTOPILOT PAUSED banner with reason, affected phase,
+specific issues, and instruction: "Fix issues, then run /ant:run to resume."
+Log: `"<timestamp>|autopilot_paused|run|Paused at Phase {id}: {reason}"`
+
+**If no pause:** proceed to Step 3.
+
+### Step 3: Continue (Verify + Advance)
+
+Execute continue playbooks in order, carrying cross-stage state
+(`visual_mode`, `state`, `current_phase`, `verification_results`,
+`gate_results`, `advancement_result`, `next_phase_id`, `completion_state`):
+
+1. `.aether/docs/command-playbooks/continue-verify.md`
+2. `.aether/docs/command-playbooks/continue-gates.md`
+3. `.aether/docs/command-playbooks/continue-advance.md`
+4. `.aether/docs/command-playbooks/continue-finalize.md`
+
+**Autopilot override for runtime verification (Step 1.11 in continue-gates):**
+Skip the AskUserQuestion prompt. Instead, auto-PAUSE with reason
+"Runtime verification required" so the user can test manually before resuming.
+
+### Step 4: Continue Pause Check
+
+**PAUSE if ANY of these are true:**
+
+| # | Condition | Source |
+|---|-----------|--------|
+| 4 | Verification loop reported NOT READY | continue-verify |
+| 5 | Gatekeeper found critical CVEs | continue-gates |
+| 6 | Auditor critical findings or score < 60 | continue-gates |
+| 7 | Unresolved blocker flags remain | continue-gates |
+| 8 | Runtime verification needed | continue-gates Step 1.11 |
+| 9 | All phases complete (no next phase) | continue-advance |
+| 10 | Replan trigger fires (unless `--continue`) | autopilot-check-replan (Step 5.5) |
+
+For condition 9: jump to Step 6 (celebration). For condition 10: PAUSE with
+replan suggestion (see Step 5.5). For all others: PAUSE with reason, log event, STOP.
+
+**If no pause:** proceed to Step 5.
+
+### Step 5: Auto-Advance and Loop
+
+1. Increment `phases_completed`
+2. Update autopilot state: `bash .aether/aether-utils.sh autopilot-update --action advance --phase {next} --result success`
+3. Log: `"<timestamp>|autopilot_advance|run|Phase {prev} -> {next} ({phases_completed}/{max})"`
+4. Display: `--- Autopilot: Phase {prev} done -> Phase {next} ({N}/{max}) ---`
+5. **Replan check** (see Step 5.5)
+6. If `phases_completed >= max_phases` or no incomplete phases: go to Step 6
+7. Otherwise: update `current_phase`, return to Step 1
+
+### Step 5.5: Replan Trigger Check
+
+After each successful phase advance, check if a replan pause should fire:
+
+```bash
+bash .aether/aether-utils.sh autopilot-check-replan --interval {replan_interval}
+```
+
+If `--continue` flag was passed: skip this check entirely (user dismissed replan).
+
+If `result.should_replan == true`: **PAUSE** with replan suggestion banner:
+
+```
+━━━ R E P L A N   S U G G E S T E D ━━━
+Phases auto-completed: {N} | Learnings accumulated: {learnings_since_last}
+
+The colony has completed {N} phases since the last plan review.
+New learnings may have changed the optimal path forward.
+
+Options:
+  /ant:plan              Regenerate phases with current learnings
+  /ant:run --continue    Dismiss and continue without replanning
+```
+
+Log: `"<timestamp>|autopilot_replan_pause|run|Replan suggested after {N} phases ({learnings} learnings)"`
+
+If `result.should_replan == false`: proceed normally (no pause).
+
+### Step 6: Final Summary
+
+```
+━━━ A U T O P I L O T   C O M P L E T E ━━━
+Phases completed: {N} | Elapsed: {Xm Ys} | Now at: Phase {current}
+
+{all complete}  -> Colony goal achieved! Run /ant:seal
+{max reached}   -> Run /ant:run to continue
+{replan}        -> Run /ant:plan to replan, or /ant:run --continue to dismiss
+{paused}        -> Fix {reason}, then /ant:run to resume
+```
+
+Update session:
+`bash .aether/aether-utils.sh session-update "/ant:run" "/ant:run" "Autopilot: {N} phases, now Phase {current}"`
+
+## Execution Contract
+
+For each playbook stage: Read file, execute inline, track `{stage_name, status, key_outputs}`.
+If `status == failed`: evaluate pause conditions. Pause = graceful stop with saved state.
+Hard failure (e.g., state corruption) = halt immediately, no recovery attempt.
+
+On every pause: save COLONY_STATE.json, log event, update session, display resume instructions.