aether-colony 5.3.3 → 5.4.0

package/.opencode/commands/ant/lay-eggs.md

@@ -147,7 +147,7 @@ echo "System files copied."
 
 
 
-Run: `bash .aether/aether-utils.sh queen-init`
+Run: `aether queen-init`
 
 
 Parse the JSON result:
@@ -163,7 +163,7 @@ Attempt to register this repo in the global hub. Silent on failure — registry
 Run (ignore errors):
 
 ```bash
-bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" 2>/dev/null || true
+aether registry-add --path "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" 2>/dev/null || true
 ```
 
 ### Step 7: Verify Setup

package/.opencode/commands/ant/maturity.md

@@ -17,7 +17,7 @@ You are the **Queen**. Display the colony's maturity journey.
 ### Step 1: Detect Current Milestone
 
 Run:
-`bash .aether/aether-utils.sh milestone-detect`
+`aether milestone-detect`
 
 Parse JSON result to get:
 - `milestone`: Current milestone name (First Mound, Open Chambers, Brood Stable, Ventilated Nest, Sealed Chambers, Crowned Anthill)

package/.opencode/commands/ant/memory-details.md

@@ -26,7 +26,7 @@ Drill-down view of accumulated colony wisdom, pending promotions, and recent fai
 
 Run using the Bash tool with description "Loading colony memory...":
 ```bash
-bash .aether/aether-utils.sh memory-metrics
+aether memory-metrics
 ```
 
 ### Step 2: Display Wisdom (from QUEEN.md)

package/.opencode/commands/ant/oracle.md

@@ -49,10 +49,10 @@ Oracle peering into the depths...
 
 ### Step 0b: Stop Oracle
 
-Create the stop signal file:
+Stop any active Oracle research:
 
 ```bash
-mkdir -p .aether/oracle && touch .aether/oracle/.stop
+mkdir -p .aether/oracle && touch .aether/oracle/.stop && rm -f .aether/oracle/.loop-active
 ```
 
 Output:
@@ -60,8 +60,9 @@ Output:
 ```
 🔮 Oracle Stop Signal Sent
 
-   Created .aether/oracle/.stop
-   The research loop will halt at the end of the current iteration.
+   Created .aether/oracle/.stop (legacy tmux signal)
+   Removed .aether/oracle/.loop-active (in-session loop marker)
+   The research loop will halt at the next iteration boundary.
 
    To check final results: /ant:oracle status
 ```
@@ -453,7 +454,7 @@ Use the Write tool to create `.aether/oracle/state.json`:
 For each focus area string from Question 7:
 
 ```bash
-bash .aether/aether-utils.sh pheromone-write FOCUS "$focus_area" \
+aether pheromone-write --type FOCUS --content "$focus_area" \
   --strength 0.8 --source "oracle:wizard" \
   --reason "Focus area set in oracle wizard" --ttl "24h" 2>/dev/null || true
 ```
@@ -552,7 +553,7 @@ Proceed to Step 3.
 
 ---
 
-### Step 3: Launch
+### Step 3: Launch (In-Session Loop)
 
 Output the research configuration summary, showing the sub-questions from plan.json:
 
@@ -576,53 +577,46 @@ Output the research configuration summary, showing the sub-questions from plan.j
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-Now launch the loop. Try tmux first, fall back to manual.
-
-**Try tmux:**
+**Create the loop marker file:**
 
 ```bash
-tmux new-session -d -s oracle "cd $(pwd) && bash .aether/utils/oracle/oracle.sh; echo ''; echo '🔮 Oracle loop finished. Press any key to close.'; read -n1" 2>/dev/null && echo "TMUX_OK" || echo "TMUX_FAIL"
-```
-
-**If TMUX_OK:**
-
-```
-🔮 Oracle Launched
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-   The Oracle is researching in a background tmux session.
-
-   👁️  Watch live:     tmux attach -t oracle
-   📊 Check status:   /ant:oracle status
-   🛑 Stop early:     /ant:oracle stop
-
-   Research progress visible at .aether/oracle/research-plan.md
-   The Oracle will stop when it reaches {target_confidence}% confidence
-   or completes {max_iterations} iterations.
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-   You can keep working. The Oracle runs independently.
+SESSION_ID="${CLAUDE_SESSION_ID:-$(uuidgen 2>/dev/null || date +%s)}"
+MAX_IT=<max_iterations from wizard>
+TARGET_CONF=<target_confidence from wizard>
+cat > .aether/oracle/.loop-active <<MARKER
+---
+iteration: 0
+max_iterations: $MAX_IT
+session_id: $SESSION_ID
+phase: survey
+target_confidence: $TARGET_CONF
+synthesis_done: false
+oracle_md_path: .aether/utils/oracle/oracle.md
+---
+Oracle research loop active
+MARKER
+echo "LOOP_MARKER_CREATED"
 ```
 
-Stop here.
-
-**If TMUX_FAIL** (tmux not installed or error):
+Output:
 
 ```
-🔮 Ready to Launch
+🔮 Oracle Research Started (In-Session Loop)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-   tmux not available. Run this in a separate terminal:
+   The Oracle is researching IN THIS SESSION.
 
-   cd {current_working_directory}
-   bash .aether/utils/oracle/oracle.sh
+   The Stop hook keeps the loop running automatically between iterations.
+   Phases advance: survey -> investigate -> synthesize -> verify
+   Loop ends when confidence target is reached or max iterations hit.
 
-   Then come back here:
    📊 Check status:   /ant:oracle status
    🛑 Stop early:     /ant:oracle stop
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+   You can continue chatting. The Oracle loop runs between your messages.
 ```
 
-Stop here.
+**Now begin the first iteration.** Read `.aether/utils/oracle/oracle.md` and start survey phase research.
+Target the first untouched question from plan.json. Update state files as you go.

package/.opencode/commands/ant/organize.md

@@ -36,7 +36,7 @@ From COLONY_STATE.json, extract:
 
 Run using the Bash tool:
 ```bash
-bash .aether/aether-utils.sh pheromone-read
+aether pheromone-read
 ```
 
 Use `.result.signals` as the active signal list (already decay-filtered by runtime logic).
@@ -213,7 +213,7 @@ Next:
 
 Use the Bash tool to run:
 ```
-bash .aether/aether-utils.sh activity-log "COMPLETE" "queen" "Hygiene report generated"
+aether activity-log "COMPLETE" "queen" "Hygiene report generated"
 ```
 
 Display persistence confirmation:

package/.opencode/commands/ant/patrol.md

@@ -255,12 +255,12 @@ Run these commands in parallel using the Bash tool:
 
 **Flags check:**
 ```bash
-bash .aether/aether-utils.sh flag-list 2>/dev/null || echo '{"result":{"flags":[]}}'
+aether flag-list --json 2>/dev/null || echo '{"result":{"flags":[]}}'
 ```
 
 **Midden check:**
 ```bash
-bash .aether/aether-utils.sh midden-recent-failures 2>/dev/null || echo '{"result":{"failures":[]}}'
+aether midden-recent-failures 2>/dev/null || echo '{"result":{"failures":[]}}'
 ```
 
 **Parse flag results:**
@@ -338,12 +338,12 @@ Display: `Checking colony health...`
 
 **Expire stale pheromones:**
 ```bash
-bash .aether/aether-utils.sh pheromone-expire 2>/dev/null || true
+aether pheromone-expire 2>/dev/null || true
 ```
 
 **Load memory metrics:**
 ```bash
-bash .aether/aether-utils.sh memory-metrics 2>/dev/null || echo '{}'
+aether memory-metrics 2>/dev/null || echo '{}'
 ```
 
 **Load instincts:**
@@ -363,7 +363,7 @@ From COLONY_STATE.json `events`:
 
 **Count pheromone signals:**
 ```bash
-bash .aether/aether-utils.sh pheromone-count 2>/dev/null || echo '{"result":{"count":0}}'
+aether pheromone-count 2>/dev/null || echo '{"result":{"count":0}}'
 ```
 
 Display:
@@ -592,7 +592,7 @@ Next:
 
 Run using the Bash tool:
 ```bash
-bash .aether/aether-utils.sh activity-log "COMPLETE" "queen" "Colony audit completed - {recommendation}"
+aether activity-log "COMPLETE" "queen" "Colony audit completed - {recommendation}"
 ```
 
 Display persistence confirmation:

package/.opencode/commands/ant/pause-colony.md

@@ -28,7 +28,7 @@ If `goal` is null, output `No colony initialized. Nothing to pause.` and stop.
 
 Run using the Bash tool:
 ```bash
-bash .aether/aether-utils.sh pheromone-read
+aether pheromone-read
 ```
 
 Use `.result.signals` as the active signal list (already decay-filtered by runtime logic).
@@ -109,7 +109,7 @@ If `last_commit_suggestion_phase` equals the current phase, skip this step silen
 
 3. **Generate the commit message:**
 ```bash
-bash .aether/aether-utils.sh generate-commit-message "pause" {current_phase} "{phase_name}"
+aether generate-commit-message --type "pause" --phase {current_phase} --subject "{phase_name}"
 ```
 Parse the returned JSON to extract `message` and `files_changed`.
 

package/.opencode/commands/ant/pheromones.md

@@ -118,7 +118,7 @@ Stop here.
 
 Run using the Bash tool with description "Displaying pheromones...":
 ```bash
-bash .aether/aether-utils.sh pheromone-display "{subcommand or 'all'}"
+aether pheromone-display "{subcommand or 'all'}"
 ```
 
 The output will be the formatted pheromone table.

package/.opencode/commands/ant/plan.md

@@ -46,7 +46,7 @@ Stop here.
 
 ### Step 1.5: Load State and Show Resumption Context
 
-Run using Bash tool: `bash .aether/aether-utils.sh load-state`
+Run using Bash tool: `aether load-state`
 
 If successful and goal is not null:
 1. Extract current_phase from state
@@ -61,7 +61,7 @@ If .aether/HANDOFF.md exists (detected in load-state output):
 - Read .aether/HANDOFF.md for additional context
 - Remove .aether/HANDOFF.md after display (cleanup)
 
-Run: `bash .aether/aether-utils.sh unload-state` to release lock.
+Run: `aether unload-state` to release lock.
 
 **Error handling:**
 - If E_FILE_NOT_FOUND: "No colony initialized. Run /ant:init first." and stop
@@ -97,7 +97,7 @@ Select planning depth (prompt user if not explicitly provided):
 
 Run using the Bash tool with description "Loading compact planning context...":
 ```bash
-bash .aether/aether-utils.sh context-capsule --compact --json 2>/dev/null
+aether context-capsule --compact --json 2>/dev/null
 ```
 
 If JSON is valid and `.ok == true`, extract `.result.prompt_section` into `context_capsule_prompt`.
@@ -179,7 +179,7 @@ Investigate domain knowledge for each phase before the planning loop begins. Thi
 **1. Retrieve hive wisdom for research priming:**
 
 ```bash
-hive_context=$(bash .aether/aether-utils.sh hive-read --limit 5 --format text 2>/dev/null)
+hive_context=$(aether hive-read --limit 5 --format text 2>/dev/null)
 ```
 
 Parse the JSON result to extract `.result.text` as `hive_text`. If command fails or returns empty, set `hive_text = ""`.
@@ -581,7 +581,7 @@ verify_state=$(jq -r '.state' .aether/data/COLONY_STATE.json)
 if [[ "$verify_phases" -lt 1 || "$verify_timestamp" == "null" || "$verify_state" != "READY" ]]; then
   echo "ERROR: Plan write verification failed (phases=$verify_phases, generated_at=$verify_timestamp, state=$verify_state)"
   echo "Attempting retry write..."
-  bash .aether/aether-utils.sh state-write "$(jq --argjson phases "$(echo '$PLAN_JSON' | jq '.plan.phases')" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '.plan.phases = $phases | .plan.generated_at = $ts | .state = "READY"' .aether/data/COLONY_STATE.json)"
+  aether state-write "$(jq --argjson phases "$(echo '$PLAN_JSON' | jq '.plan.phases')" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '.plan.phases = $phases | .plan.generated_at = $ts | .state = "READY"' .aether/data/COLONY_STATE.json)"
   verify_phases=$(jq '.plan.phases | length' .aether/data/COLONY_STATE.json)
   if [[ "$verify_phases" -lt 1 ]]; then
     echo "FATAL: Retry write also failed. Plan was not persisted."
@@ -592,7 +592,7 @@ fi
 echo "Plan verified: $verify_phases phases, generated_at=$verify_timestamp, state=$verify_state"
 ```
 
-Log plan completion: `bash .aether/aether-utils.sh activity-log "PLAN_COMPLETE" "queen" "Plan finalized with {confidence}% confidence"`
+Log plan completion: `aether activity-log "PLAN_COMPLETE" "queen" "Plan finalized with {confidence}% confidence"`
 
 Update watch-status.txt:
 ```

package/.opencode/commands/ant/quick.md

@@ -39,7 +39,7 @@ Stop here.
 
 Run:
 ```bash
-bash .aether/aether-utils.sh generate-ant-name "scout"
+aether generate-ant-name --caste "scout"
 ```
 
 Capture the output as `scout_name`.
@@ -54,7 +54,7 @@ Spawning {scout_name} — {query truncated to 50 chars}
 
 Run:
 ```bash
-bash .aether/aether-utils.sh spawn-log "Queen" "scout" "{scout_name}" "Quick query: {query}"
+aether spawn-log --name "Queen" --caste "scout" --id "{scout_name}" --description "Quick query: {query}"
 ```
 
 
@@ -73,14 +73,14 @@ Display your findings directly to the user.
 
 Run:
 ```bash
-bash .aether/aether-utils.sh spawn-complete "{scout_name}" "completed" "Quick query answered"
+aether spawn-complete --id "{scout_name}" --status "completed" --summary "Quick query answered"
 ```
 
 ### Step 5: Update Session (lightweight)
 
 Run:
 ```bash
-bash .aether/aether-utils.sh session-update "/ant:quick" "" "Quick query: {query truncated to 60 chars}" 2>/dev/null || true
+aether session-update --command "/ant:quick" --worker "" --summary "Quick query: {query truncated to 60 chars}" 2>/dev/null || true
 ```
 
 **NOTE:** This command does NOT:

package/.opencode/commands/ant/redirect.md

@@ -57,8 +57,8 @@ Write constraints.json.
 
 **Write pheromone signal and update context:**
 ```bash
-bash .aether/aether-utils.sh pheromone-write REDIRECT "$normalized_args" --strength 0.9 --reason "User warned colony away from pattern" 2>/dev/null || true
-bash .aether/aether-utils.sh context-update constraint redirect "$normalized_args" "user" 2>/dev/null || true
+aether pheromone-write --type REDIRECT --content "$normalized_args" --strength 0.9 --reason "User warned colony away from pattern" 2>/dev/null || true
+aether context-update --section constraint --key redirect --content "$normalized_args" "user" 2>/dev/null || true
 ```
 
 ### Step 3: Confirm

package/.opencode/commands/ant/resume-colony.md

@@ -20,13 +20,13 @@ Parse `$normalized_args`:
 
 ### Step 0.5: Version Check (Non-blocking)
 
-Run using the Bash tool: `bash .aether/aether-utils.sh version-check 2>/dev/null || true`
+Run using the Bash tool: `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.
 
 ### Step 1: Load State and Validate
 
-Run using Bash tool: `bash .aether/aether-utils.sh load-state`
+Run using Bash tool: `aether load-state`
 
 If successful:
 1. Parse state from result
@@ -41,7 +41,7 @@ Keep state loaded (don't unload yet) - we'll need it for the full display.
 
 Run using the Bash tool:
 ```bash
-bash .aether/aether-utils.sh pheromone-read
+aether pheromone-read
 ```
 
 Use `.result.signals` as the active signal list (already decay-filtered by runtime logic).
@@ -133,7 +133,7 @@ Use Write tool to update COLONY_STATE.json:
 
 Use Bash tool to remove HANDOFF.md: `rm -f .aether/HANDOFF.md`
 
-Run: `bash .aether/aether-utils.sh unload-state` to release lock.
+Run: `aether unload-state` to release lock.
 
 ---
 

package/.opencode/commands/ant/resume.md

@@ -32,7 +32,7 @@ Execute the following steps in order when the user runs `/ant:resume`.
 
 Run::
 ```bash
-bash .aether/aether-utils.sh session-read
+aether session-read
 ```
 
 Parse the JSON result.
@@ -102,11 +102,9 @@ Do NOT proceed with stale or fabricated data.
 
 ### Step 3: Read Pheromone Signals
 
-
-
 Run::
 ```bash
-bash .aether/aether-utils.sh pheromone-read all
+aether pheromone-read all
 ```
 
 Parse the JSON result. Extract `.result.signals` array.
@@ -117,7 +115,6 @@ Parse the JSON result. Extract `.result.signals` array.
 
 Note: pheromone-read applies decay calculation automatically. The `effective_strength` field reflects current signal strength after time-based decay. Signals below 0.1 effective strength are already filtered out.
 
-
 ---
 
 ### Step 4: Read CONTEXT.md
@@ -299,12 +296,9 @@ Recent Decisions:
 
 {if signals array from Step 3 is not empty:}
 Active Signals:
-
-
 {for each signal in signals:}
   {signal.type}: "{signal.content}" [{signal.effective_strength * 100 | floor}%]
 {end}
-
 {end}
 ```
 
@@ -314,7 +308,7 @@ Active Signals:
 
 Run::
 ```bash
-bash .aether/aether-utils.sh resume-dashboard
+aether resume-dashboard
 ```
 
 Extract memory_health from the JSON result:
@@ -346,7 +340,7 @@ Session: {session_id}
 
 Run::
 ```bash
-bash .aether/aether-utils.sh session-mark-resumed
+aether session-mark-resumed
 ```
 
 ### Step 10: Next Up
@@ -356,7 +350,7 @@ Generate the state-based Next Up block by Run::
 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
 ```
 
 ---
@@ -367,10 +361,7 @@ 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 |
-
-
 | pheromone-read fails | 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 |
@@ -382,10 +373,7 @@ bash .aether/aether-utils.sh print-next-up "$state" "$current_phase" "$total_pha
 
 ## Key Constraints
 
-
-
 - Use Read tool for COLONY_STATE.json (not bash cat/jq). Use Bash tool for pheromone-read (applies decay calculation).
-
 - 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/.opencode/commands/ant/run.md

@@ -74,9 +74,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"}`
 
@@ -113,7 +113,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}" \
@@ -142,7 +142,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}" \
@@ -173,7 +173,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)
@@ -185,7 +185,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).
@@ -226,7 +226,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/.opencode/commands/ant/seal.md

@@ -171,7 +171,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" \
@@ -192,7 +192,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.
@@ -237,7 +237,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
@@ -283,7 +283,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)
@@ -293,7 +293,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")
@@ -303,7 +303,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)
@@ -313,7 +313,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)
@@ -384,7 +384,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/.opencode/commands/ant/skill-create.md

@@ -57,7 +57,7 @@ Create the skill file with proper frontmatter and body:
 ### Step 4: Write and Verify
 
 1. Write to `~/.aether/skills/domain/{name}/SKILL.md`
-2. Run: `bash .aether/aether-utils.sh skill-parse-frontmatter ~/.aether/skills/domain/{name}/SKILL.md`
-3. Run: `bash .aether/aether-utils.sh skill-cache-rebuild`
+2. Run: `aether skill-parse-frontmatter ~/.aether/skills/domain/{name}/SKILL.md`
+3. Run: `aether skill-cache-rebuild`
 4. Show the generated skill to the user
 5. Ask if they want to adjust anything