aether-colony 5.3.2 → 5.4.0

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

@@ -49,7 +49,7 @@ 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 ━━━
+━━━ 🤖 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
@@ -68,9 +68,9 @@ replan suggestion (every {replan_interval} phases)
    - If `milestone` == `"Crowned Anthill"`: output "This colony has been sealed. Start a new colony with `/ant:init \"new goal\"`." and stop
 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}`
+4. Record pre-build blocker count: `aether flag-check-blockers {phase}`
 5. If `--headless` flag is present:
-   - Run: `bash .aether/aether-utils.sh autopilot-set-headless true`
+   - Run: `aether autopilot-set-headless true`
    - Display: `Headless mode: ON — interactive prompts will be queued as pending decisions`
 6. Display: `AUTOPILOT ENGAGED | Goal: {goal} | Phase {N} | Max: {max or "all"}`
 
@@ -107,7 +107,7 @@ Log: `"<timestamp>|autopilot_paused|run|Paused at Phase {id}: {reason}"`
 visual checkpoint prompt would normally be shown to the user, instead queue it as
 a pending decision:
 ```bash
-bash .aether/aether-utils.sh pending-decision-add \
+aether pending-decision-add \
   --title "Visual checkpoint: Phase {id}" \
   --type "checkpoint" \
   --description "{checkpoint_description}" \
@@ -136,7 +136,7 @@ Skip the AskUserQuestion prompt. Instead, auto-PAUSE with reason
 **Headless override for runtime verification:** If headless mode is active and
 runtime verification would normally pause, queue as a pending decision instead:
 ```bash
-bash .aether/aether-utils.sh pending-decision-add \
+aether pending-decision-add \
   --title "Runtime verification needed: Phase {id}" \
   --type "runtime-verification" \
   --description "Manual testing required before advancing past Phase {id}" \
@@ -167,7 +167,7 @@ replan suggestion (see Step 5.5). For all others: PAUSE with reason, log event,
 ### 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`
+2. Update autopilot state: `aether 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)
@@ -179,7 +179,7 @@ replan suggestion (see Step 5.5). For all others: PAUSE with reason, log event,
 After each successful phase advance, check if a replan pause should fire:
 
 ```bash
-bash .aether/aether-utils.sh autopilot-check-replan --interval {replan_interval}
+aether autopilot-check-replan --interval {replan_interval}
 ```
 
 If `--continue` flag was passed: skip this check entirely (user dismissed replan).
@@ -187,7 +187,7 @@ 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 ━━━
+━━━ 🔄 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.
@@ -205,7 +205,7 @@ 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 ━━━
+━━━ ✅ 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
@@ -220,7 +220,7 @@ Pending decisions: {N} — run `pending-decision-list` to review
 ```
 
 Update session:
-`bash .aether/aether-utils.sh session-update "/ant:run" "/ant:run" "Autopilot: {N} phases, now Phase {current}"`
+`aether session-update --command "/ant:run" --worker "/ant:run" --summary "Autopilot: {N} phases, now Phase {current}"`
 
 ## Execution Contract
 

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

@@ -60,7 +60,7 @@ Extract: `goal`, `state`, `current_phase`, `plan.phases`, `milestone`, `version`
 
 ### Step 2: Maturity Gate
 
-Run `bash .aether/aether-utils.sh milestone-detect` to get `milestone`, `phases_completed`, `total_phases`.
+Run `aether milestone-detect` to get `milestone`, `phases_completed`, `total_phases`.
 
 **If milestone is already "Crowned Anthill":**
 ```
@@ -122,8 +122,8 @@ phases_completed=$(jq '[.plan.phases[] | select(.status == "completed")] | lengt
 
 if [[ "$phases_completed" -ge 3 ]]; then
   # Generate Sage name and dispatch
-  sage_name=$(bash .aether/aether-utils.sh generate-ant-name "sage")
-  bash .aether/aether-utils.sh spawn-log "Queen" "sage" "$sage_name" "Colony analytics review"
+  sage_name=$(aether generate-ant-name --caste "sage")
+  aether spawn-log --name "Queen" --caste "sage" --id "$sage_name" --description "Colony analytics review"
 
   # Display spawn notification
   echo ""
@@ -162,7 +162,7 @@ Work:
 
 **IMPORTANT:** You are strictly read-only. Do not modify any files.
 
-Log activity: bash .aether/aether-utils.sh activity-log "ANALYZING" "{sage_name}" "description"
+Log activity: aether activity-log "ANALYZING" "{sage_name}" "description"
 
 Return ONLY this JSON (no other text):
 {{
@@ -195,7 +195,7 @@ After spawn, extract from response: `key_findings`, `trends`, `recommendations`
 
 Log completion and update swarm display:
 ```bash
-bash .aether/aether-utils.sh spawn-complete "$sage_name" "completed" "Analytics review complete"
+aether spawn-complete --id "$sage_name" --status "completed" --summary "Analytics review complete"
 ```
 
 **Display Sage completion line:**
@@ -207,7 +207,7 @@ bash .aether/aether-utils.sh spawn-complete "$sage_name" "completed" "Analytics
 **Log high-priority recommendations to midden (non-blocking):**
 For each recommendation with priority <= 2:
 ```bash
-bash .aether/aether-utils.sh midden-write "analytics" "Sage recommendation (P{priority}): {action}" "sage"
+aether midden-write "analytics" "Sage recommendation (P{priority}): {action}" "sage"
 ```
 
 **Display insights summary:**
@@ -242,7 +242,7 @@ if [[ -f "$obs_file" ]]; then
     colony=$(echo "$encoded" | base64 -d | jq -r '.colonies[0] // "unknown"')
     [[ -z "$content" ]] && continue
 
-    result=$(bash .aether/aether-utils.sh learning-promote-auto "$wisdom_type" "$content" "$colony" "learning" 2>/dev/null || echo '{}')
+    result=$(aether learning-promote-auto "$wisdom_type" "$content" "$colony" "learning" 2>/dev/null || echo '{}')
     was_promoted=$(echo "$result" | jq -r '.result.promoted // false' 2>/dev/null || echo "false")
     if [[ "$was_promoted" == "true" ]]; then
       auto_promoted_count=$((auto_promoted_count + 1))
@@ -257,7 +257,7 @@ fi
 # --- END Batch auto-promotion ---
 
 # Check for pending proposals
-proposals=$(bash .aether/aether-utils.sh learning-check-promotion 2>/dev/null || echo '{"proposals":[]}')
+proposals=$(aether learning-check-promotion 2>/dev/null || echo '{"proposals":[]}')
 proposal_count=$(echo "$proposals" | jq '.proposals | length')
 
 if [[ "$proposal_count" -gt 0 ]]; then
@@ -271,7 +271,7 @@ if [[ "$proposal_count" -gt 0 ]]; then
   echo ""
 
   # Run approval workflow (blocking)
-  bash .aether/aether-utils.sh learning-approve-proposals
+  aether learning-approve-proposals
 
   echo ""
   echo "Wisdom review complete. Proceeding with sealing ceremony..."
@@ -321,7 +321,7 @@ for encoded in $high_conf_instincts; do
   [[ -n "$repo_domain_tags" ]] && promote_args+=(--domain "$repo_domain_tags")
 
   # Call hive-promote which orchestrates abstract + store
-  result=$(bash .aether/aether-utils.sh "${promote_args[@]}" 2>/dev/null || echo '{}')
+  result=$(aether "${promote_args[@]}" 2>/dev/null || echo '{}')
   was_promoted=$(echo "$result" | jq -r '.result.action // "skipped"' 2>/dev/null || echo "skipped")
 
   if [[ "$was_promoted" == "promoted" || "$was_promoted" == "merged" ]]; then
@@ -341,7 +341,7 @@ Proceed to Step 4 regardless of hive promotion results — hive promotion is str
 
 Log the seal ceremony to activity log:
 ```bash
-bash .aether/aether-utils.sh activity-log "MODIFIED" "Queen" "Colony sealed - wisdom review completed"
+aether activity-log "MODIFIED" "Queen" "Colony sealed - wisdom review completed"
 ```
 
 ### Step 4.4: Checkpoint State
@@ -350,7 +350,7 @@ Before modifying colony state, create a rolling backup:
 
 Run using the Bash tool with description "Checkpointing colony state before seal...":
 ```bash
-bash .aether/aether-utils.sh state-checkpoint "pre-seal" 2>/dev/null || echo "Warning: State checkpoint failed -- continuing without backup" >&2
+aether state-checkpoint "pre-seal" 2>/dev/null || echo "Warning: State checkpoint failed -- continuing without backup" >&2
 ```
 
 ### Step 4.5: Increment Colony Version
@@ -385,7 +385,7 @@ Update COLONY_STATE.json:
 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.
+Run `aether validate-state colony` after write.
 
 ### Step 5.1: Update Changelog
 
@@ -398,7 +398,7 @@ Build a summary of what the colony accomplished across all phases:
 - Summarize the goal and key outcomes in one line
 
 ```bash
-bash .aether/aether-utils.sh changelog-append \
+aether changelog-append \
   "$(date +%Y-%m-%d)" \
   "seal-crowned-anthill" \
   "00" \
@@ -419,7 +419,7 @@ Mark the colony as inactive in the global registry. This is silent on failure
 
 Run using the Bash tool (ignore errors):
 ```bash
-bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --active false 2>/dev/null || true
+aether registry-add --path "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --active false 2>/dev/null || true
 ```
 
 If the command fails, proceed silently. This is optional bookkeeping.
@@ -431,10 +431,10 @@ Before writing the seal document, spawn a Chronicler to survey documentation cov
 **Generate Chronicler name and dispatch:**
 ```bash
 # Generate unique chronicler name
-chronicler_name=$(bash .aether/aether-utils.sh generate-ant-name "chronicler")
+chronicler_name=$(aether generate-ant-name --caste "chronicler")
 
 # Log spawn and update swarm display
-bash .aether/aether-utils.sh spawn-log "Queen" "chronicler" "$chronicler_name" "Documentation coverage audit"
+aether spawn-log --name "Queen" --caste "chronicler" --id "$chronicler_name" --description "Documentation coverage audit"
 ```
 
 **Display:**
@@ -472,7 +472,7 @@ Work:
 
 **IMPORTANT:** You are strictly read-only. Do not modify any files.
 
-Log activity: bash .aether/aether-utils.sh activity-log "SURVEYING" "{chronicler_name}" "description"
+Log activity: aether activity-log "SURVEYING" "{chronicler_name}" "description"
 
 Return ONLY this JSON (no other text):
 {
@@ -501,7 +501,7 @@ Extract from response: `coverage_percent`, `gaps_identified`, `pages_documented`
 
 Log completion and update swarm display:
 ```bash
-bash .aether/aether-utils.sh spawn-complete "$chronicler_name" "completed" "Documentation audit complete"
+aether spawn-complete --id "$chronicler_name" --status "completed" --summary "Documentation audit complete"
 ```
 
 **Display Chronicler completion line:**
@@ -512,7 +512,7 @@ bash .aether/aether-utils.sh spawn-complete "$chronicler_name" "completed" "Docu
 **Log gaps to midden (non-blocking):**
 For each gap in `gaps_identified` with severity "high" or "medium":
 ```bash
-bash .aether/aether-utils.sh midden-write "documentation" "Gap ({severity}): {description} at {location}" "chronicler"
+aether midden-write "documentation" "Gap ({severity}): {description} at {location}" "chronicler"
 ```
 
 **Display summary:**
@@ -583,7 +583,7 @@ Export colony data as a combined XML archive and a standalone pheromones.xml. Bo
 ```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_result=$(aether colony-archive-xml --output ".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)
@@ -593,7 +593,7 @@ if command -v xmllint >/dev/null 2>&1; then
   fi
 
   # Also export standalone pheromones.xml for cross-colony sharing
-  pher_result=$(bash .aether/aether-utils.sh pheromone-export-xml ".aether/exchange/pheromones.xml" 2>&1)
+  pher_result=$(aether pheromone-export-xml --output ".aether/exchange/pheromones.xml" 2>&1)
   pher_ok=$(echo "$pher_result" | jq -r '.ok // false' 2>/dev/null)
   if [[ "$pher_ok" == "true" ]]; then
     pher_signal_count=$(jq '[.signals[] | select(.active != false)] | length' .aether/data/pheromones.json 2>/dev/null || echo "0")
@@ -603,7 +603,7 @@ if command -v xmllint >/dev/null 2>&1; then
   fi
 
   # Export standalone queen-wisdom.xml for cross-colony wisdom sharing
-  wisdom_result=$(bash .aether/aether-utils.sh wisdom-export-xml ".aether/exchange/queen-wisdom.xml" 2>&1)
+  wisdom_result=$(aether wisdom-export-xml ".aether/exchange/queen-wisdom.xml" 2>&1)
   wisdom_ok=$(echo "$wisdom_result" | jq -r '.ok // false' 2>/dev/null)
   if [[ "$wisdom_ok" == "true" ]]; then
     wisdom_count=$(echo "$wisdom_result" | jq -r '.result.entries // 0' 2>/dev/null)
@@ -613,7 +613,7 @@ if command -v xmllint >/dev/null 2>&1; then
   fi
 
   # Export standalone colony-registry.xml for lineage tracking
-  registry_result=$(bash .aether/aether-utils.sh registry-export-xml ".aether/exchange/colony-registry.xml" 2>&1)
+  registry_result=$(aether registry-export-xml ".aether/exchange/colony-registry.xml" 2>&1)
   registry_ok=$(echo "$registry_result" | jq -r '.ok // false' 2>/dev/null)
   if [[ "$registry_ok" == "true" ]]; then
     registry_count=$(echo "$registry_result" | jq -r '.result.colonies // 0' 2>/dev/null)
@@ -692,7 +692,7 @@ After the ceremony, offer to commit all colony work.
 
 Generate a seal commit message:
 ```bash
-seal_commit=$(bash .aether/aether-utils.sh generate-commit-message seal "$phases_completed" "$goal" "$colony_age_days" 2>/dev/null)
+seal_commit=$(aether generate-commit-message seal "$phases_completed" "$goal" "$colony_age_days" 2>/dev/null)
 seal_message=$(echo "$seal_commit" | jq -r '.result.message // "aether-seal: colony sealed"')
 seal_body=$(echo "$seal_commit" | jq -r '.result.body // ""')
 ```

package/.claude/commands/ant/skill-create.md

@@ -228,7 +228,7 @@ Use the Write tool to create `~/.aether/skills/domain/{SKILL_NAME}/SKILL.md` wit
 Run using the Bash tool with description "Verifying skill frontmatter...":
 
 ```bash
-bash .aether/aether-utils.sh skill-parse-frontmatter ~/.aether/skills/domain/{SKILL_NAME}/SKILL.md
+aether skill-parse-frontmatter ~/.aether/skills/domain/{SKILL_NAME}/SKILL.md
 ```
 
 Check the output. If the result contains `"ok": true` (or the parsed JSON shows the correct name and type), the skill is valid. If parsing fails, fix the frontmatter and retry once.
@@ -238,7 +238,7 @@ Check the output. If the result contains `"ok": true` (or the parsed JSON shows
 Run using the Bash tool with description "Rebuilding skill cache...":
 
 ```bash
-bash .aether/aether-utils.sh skill-cache-rebuild
+aether skill-cache-rebuild
 ```
 
 **4d. Show the result**

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

@@ -10,7 +10,7 @@ You are the **Queen**. Show colony status.
 
 ### 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`
+Run using the Bash tool with description "Checking colony version...": `aether 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.
 
@@ -52,7 +52,7 @@ If `version` field is missing, "1.0", or "2.0":
 
 ### 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`
+Run using the Bash tool with description "Loading colony state...": `aether load-state`
 
 If successful and goal is not null:
 1. Extract current_phase from state
@@ -70,7 +70,7 @@ If successful and goal is not null:
    - 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.
+Run using the Bash tool with description "Releasing colony lock...": `aether unload-state` to release lock.
 
 ### Step 2: Compute Summary
 
@@ -118,7 +118,7 @@ Format the timestamp as: YYYY-MM-DD HH:MM
 
 Run using the Bash tool with description "Reading colony depth...":
 ```bash
-depth_result=$(bash .aether/aether-utils.sh colony-depth get 2>/dev/null || echo '{"ok":true,"result":{"depth":"standard","source":"default"}}')
+depth_result=$(aether colony-depth get 2>/dev/null || echo '{"ok":true,"result":{"depth":"standard","source":"default"}}')
 colony_depth=$(echo "$depth_result" | jq -r '.result.depth // "standard"')
 depth_source=$(echo "$depth_result" | jq -r '.result.source // "default"')
 echo "colony_depth=$colony_depth"
@@ -152,7 +152,7 @@ Read `.aether/data/constraints.json` if exists:
 - Constraints count: `constraints.length`
 
 **Flags:**
-Run using the Bash tool with description "Checking for blockers...": `bash .aether/aether-utils.sh flag-check-blockers`
+Run using the Bash tool with description "Checking for blockers...": `aether flag-check-blockers`
 Extract:
 - Blockers count (critical, block advancement)
 - Issues count (high, warnings)
@@ -163,7 +163,7 @@ 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")
+escalated_count=$(aether flag-list --type blocker --json 2>/dev/null | jq '[.result.flags[] | select(.source == "escalation")] | length' 2>/dev/null || echo "0")
 echo "escalated_count=$escalated_count"
 ```
 
@@ -182,7 +182,7 @@ From `memory.instincts`:
 
 ### Step 2.6: Detect Milestone
 
-Run using the Bash tool with description "Detecting colony milestone...": `bash .aether/aether-utils.sh milestone-detect`
+Run using the Bash tool with description "Detecting colony milestone...": `aether milestone-detect`
 
 Extract from JSON result:
 - `milestone`: Current milestone name
@@ -194,7 +194,7 @@ Extract from JSON result:
 
 Run using the Bash tool with description "Loading memory health metrics...":
 ```bash
-bash .aether/aether-utils.sh memory-metrics
+aether memory-metrics
 ```
 
 Extract from JSON result:
@@ -228,8 +228,8 @@ else
 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)
+phase_bar=$(aether generate-progress-bar "$current_phase" "$total_phases" 20)
+task_bar=$(aether generate-progress-bar "$tasks_completed" "$tasks_total" 20)
 
 echo "phase_bar=$phase_bar"
 echo "task_bar=$task_bar"
@@ -305,7 +305,7 @@ Use the `phase_bar` and `task_bar` values computed in Step 2.7 for the actual ba
 **Colony Vital Signs:**
 After the Memory Health table, run:
 ```bash
-bash .aether/aether-utils.sh colony-vital-signs
+aether colony-vital-signs
 ```
 
 Extract from JSON result:
@@ -349,7 +349,7 @@ If the command fails or returns no data, display:
 **Data Safety:**
 After the Colony Vital Signs panel, run:
 ```bash
-bash .aether/aether-utils.sh data-safety-stats
+aether data-safety-stats
 ```
 
 If the result contains non-zero counts, display:
@@ -367,7 +367,7 @@ If all counts are 0 or the subcommand returns no data, display:
 **Pheromone Summary:**
 After the Data Safety section, run:
 ```bash
-bash .aether/aether-utils.sh pheromone-count
+aether pheromone-count
 ```
 
 Display:
@@ -404,7 +404,7 @@ 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"
+aether print-next-up
 ```
 
 This auto-generates state-based recommendations (IDLE → init, READY → build, EXECUTING → continue, PLANNING → plan).

package/.claude/commands/ant/swarm.md

@@ -60,7 +60,7 @@ Generate swarm ID: `swarm-<unix_timestamp>`
 
 Initialize swarm findings:
 ```bash
-bash .aether/aether-utils.sh swarm-findings-init "<swarm_id>"
+aether swarm-findings-init --id "<swarm_id>"
 ```
 
 #### Step 2.5: Check for Stale Swarm Session
@@ -72,19 +72,19 @@ SWARM_START=$(date +%s)
 
 Check for stale swarm files:
 ```bash
-stale_check=$(bash .aether/aether-utils.sh session-verify-fresh --command swarm "" "$SWARM_START")
+stale_check=$(aether session-verify-fresh --command swarm "" "$SWARM_START")
 has_stale=$(echo "$stale_check" | jq -r '.stale | length')
 
 if [[ "$has_stale" -gt 0 ]]; then
   # Auto-clear stale swarm findings (safe - findings are temporary)
-  bash .aether/aether-utils.sh session-clear --command swarm
+  aether session-clear --command swarm
   echo "Cleared stale swarm findings for fresh investigation"
 fi
 ```
 
 After initializing findings, verify swarm files are fresh:
 ```bash
-verify_result=$(bash .aether/aether-utils.sh session-verify-fresh --command swarm "" "$SWARM_START")
+verify_result=$(aether session-verify-fresh --command swarm "" "$SWARM_START")
 if [[ $(echo "$verify_result" | jq -r '.missing | length') -gt 0 ]]; then
   echo "Warning: Swarm files not properly initialized"
 fi
@@ -106,7 +106,7 @@ Display header:
 
 Before any investigation that might lead to fixes, run using the Bash tool:
 ```bash
-bash .aether/aether-utils.sh autofix-checkpoint "pre-swarm-$SWARM_ID"
+aether autofix-checkpoint --name "pre-swarm-$SWARM_ID"
 ```
 
 Store the result for potential rollback:
@@ -121,7 +121,7 @@ Store the result for potential rollback:
 
 Read existing blockers for context:
 ```bash
-bash .aether/aether-utils.sh flag-list --type blocker
+aether flag-list --type blocker --json
 ```
 
 Read recent activity:
@@ -209,7 +209,7 @@ Wait for all 4 scouts to complete.
 
 As each scout returns, add their findings:
 ```bash
-bash .aether/aether-utils.sh swarm-findings-add "{swarm_id}" "{scout_type}" "{confidence}" '{finding_json}'
+aether swarm-findings-add "{swarm_id}" "{scout_type}" "{confidence}" '{finding_json}'
 ```
 
 Display each scout's report as they complete:
@@ -238,7 +238,7 @@ Cross-compare all findings:
 Rank fix options:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-              S O L U T I O N   R A N K I N G
+🏆 S O L U T I O N   R A N K I N G
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 #1 [0.85 confidence] {best solution}
@@ -294,8 +294,8 @@ Inject learnings:
 
 Set solution in swarm findings and log success:
 ```bash
-bash .aether/aether-utils.sh swarm-solution-set "{swarm_id}" '{solution_json}'
-bash .aether/aether-utils.sh activity-log "SWARM_SUCCESS" "Queen" "Swarm {swarm_id} fixed: {brief description}"
+aether swarm-solution-set "{swarm_id}" '{solution_json}'
+aether activity-log "SWARM_SUCCESS" "Queen" "Swarm {swarm_id} fixed: {brief description}"
 ```
 
 **If verification fails:**
@@ -310,8 +310,8 @@ Attempting rollback...
 
 Rollback and log failure:
 ```bash
-bash .aether/aether-utils.sh autofix-rollback "{checkpoint_type}" "{checkpoint_ref}"
-bash .aether/aether-utils.sh activity-log "SWARM_FAILED" "Queen" "Swarm {swarm_id} fix failed verification"
+aether autofix-rollback --type "{checkpoint_type}" --ref "{checkpoint_ref}"
+aether activity-log "SWARM_FAILED" "Queen" "Swarm {swarm_id} fix failed verification"
 ```
 
 Track attempt count. If this is the 3rd failure on the same issue:
@@ -337,7 +337,7 @@ Swarm will not attempt further fixes on this issue.
 
 Archive findings:
 ```bash
-bash .aether/aether-utils.sh swarm-cleanup "{swarm_id}" --archive
+aether swarm-cleanup "{swarm_id}" --archive
 ```
 
 Generate the state-based Next Up block:
@@ -345,5 +345,5 @@ Generate the state-based Next Up block:
 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"
+aether print-next-up
 ```

package/.claude/commands/ant/tunnels.md

@@ -31,7 +31,7 @@ Stop here.
 
 ### Step 2: List All Chambers
 
-Run using the Bash tool with description "Loading chamber list...": `bash .aether/aether-utils.sh chamber-list`
+Run using the Bash tool with description "Loading chamber list...": `aether chamber-list`
 
 Parse JSON result into array of chambers.
 
@@ -129,7 +129,7 @@ Run /ant:tunnels {chamber_a} {chamber_b} to compare chambers
 ```
 
 To get the hash status, run using the Bash tool with description "Verifying chamber integrity...":
-- Run `bash .aether/aether-utils.sh chamber-verify .aether/chambers/{chamber_name}`
+- Run `aether chamber-verify --path .aether/chambers/{chamber_name}`
 - If verified: hash_status = "verified"
 - If not verified: hash_status = "hash mismatch"
 - If error: hash_status = "error"
@@ -344,7 +344,7 @@ Run using the Bash tool with description "Importing pheromone signals...":
 # Import the EXTRACTED pheromone-only XML (NOT the combined colony-archive.xml)
 # $import_tmp_pheromones has <pheromones> as root — the format pheromone-import-xml expects
 # Second argument triggers prefix-tagging — imported signal IDs become "{source_colony}:original_id"
-import_result=$(bash .aether/aether-utils.sh pheromone-import-xml "$import_tmp_pheromones" "$source_colony" 2>&1)
+import_result=$(aether pheromone-import-xml --input "$import_tmp_pheromones" --colony "$source_colony" 2>&1)
 import_ok=$(echo "$import_result" | jq -r '.ok // false' 2>/dev/null)
 
 if [[ "$import_ok" == "true" ]]; then
@@ -397,7 +397,7 @@ Generate the state-based Next Up block by running using the Bash tool with descr
 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"
+aether print-next-up
 ```
 
 ## Implementation Notes

package/.claude/commands/ant/update.md

@@ -127,6 +127,6 @@ Generate the state-based Next Up block by running:
 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"
+aether print-next-up
 ```
 

package/.claude/commands/ant/verify-castes.md

@@ -62,7 +62,7 @@ Caste slots come from agent frontmatter (`model:` field).
 ## Step 2: Check System Status
 
 
-Run using the Bash tool with description "Checking colony version...": `bash .aether/aether-utils.sh version-check-cached 2>/dev/null || echo "Utils available"`
+Run using the Bash tool with description "Checking colony version...": `aether version-check-cached 2>/dev/null || echo "Utils available"`
 
 
 
@@ -122,7 +122,7 @@ Generate the state-based Next Up block by running using the Bash tool with descr
 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"
+aether print-next-up
 ```
 
 

package/.claude/commands/ant/watch.md

@@ -43,7 +43,7 @@ WATCH_START=$(date +%s)
 
 Check for stale watch files by running using the Bash tool with description "Checking for stale watch session...":
 ```bash
-stale_check=$(bash .aether/aether-utils.sh session-verify-fresh --command watch "" "$WATCH_START")
+stale_check=$(aether session-verify-fresh --command watch "" "$WATCH_START")
 has_stale=$(echo "$stale_check" | jq -r '.stale | length' 2>/dev/null || echo "0")
 ```
 
@@ -195,21 +195,21 @@ Generate the state-based Next Up block by running using the Bash tool with descr
 Workers and commands update watch files as they work:
 
 ### Activity Log
-Workers write via: `bash .aether/aether-utils.sh activity-log "ACTION" "caste" "description"`
+Workers write via: `aether activity-log "ACTION" "caste" "description"`
 
 For named ants (recommended):
 ```bash
 # Generate a name first
-ant_name=$(bash .aether/aether-utils.sh generate-ant-name "builder" | jq -r '.result')
+ant_name=$(aether generate-ant-name --caste "builder" | jq -r '.result')
 # Log with ant name
-bash .aether/aether-utils.sh activity-log "CREATED" "$ant_name (Builder)" "Implemented auth module"
+aether activity-log "CREATED" "$ant_name (Builder)" "Implemented auth module"
 ```
 
 ### Spawn Tracking
 Log spawns for tree visualization:
 ```bash
-bash .aether/aether-utils.sh spawn-log "Prime" "builder" "Hammer-42" "implementing auth"
-bash .aether/aether-utils.sh spawn-complete "Hammer-42" "completed" "auth module done"
+aether spawn-log --name "Prime" --caste "builder" --id "Hammer-42" --description "implementing auth"
+aether spawn-complete --id "Hammer-42" --status "completed" --summary "auth module done"
 ```
 
 ### Status File
@@ -220,11 +220,11 @@ Commands update `.aether/data/watch-status.txt` with current state:
 - Last Activity: most recent log entry
 
 ### Progress File
-Update via: `bash .aether/aether-utils.sh update-progress <percent> "<message>" <phase> <total>`
+Update via: `aether update-progress <percent> "<message>" <phase> <total>`
 
 Example:
 ```bash
-bash .aether/aether-utils.sh update-progress 45 "Building auth module..." 2 5
+aether update-progress 45 "Building auth module..." 2 5
 ```
 
 ---

package/.opencode/commands/ant/archaeology.md

@@ -314,7 +314,7 @@ Excavation date: {YYYY-MM-DD}
 ### Step 8: Log Activity
 
 ```bash
-bash .aether/aether-utils.sh activity-log "ARCHAEOLOGY" "Archaeologist" "Excavated {target}: {total_commits} commits, {author_count} authors, {findings_count} findings, {tech_debt_count} debt markers"
+aether activity-log "ARCHAEOLOGY" "Archaeologist" "Excavated {target}: {total_commits} commits, {author_count} authors, {findings_count} findings, {tech_debt_count} debt markers"
 ```
 
 ## Investigation Guidelines