aether-colony 5.3.2 → 5.4.0

package/.claude/commands/ant/dream.md

@@ -227,7 +227,7 @@ Colony status: /ant:status
 Run using the Bash tool with description "Logging dream activity...":
 
 ```bash
-bash .aether/aether-utils.sh activity-log "DREAM" "Dreamer" "Dream session: {N} observations, {concerns} concerns, {pheromones} pheromone suggestions"
+aether activity-log "DREAM" "Dreamer" "Dream session: {N} observations, {concerns} concerns, {pheromones} pheromone suggestions"
 ```
 
 
@@ -236,7 +236,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/entomb.md

@@ -129,7 +129,7 @@ Before archiving, review wisdom proposals accumulated during this colony's lifec
 
 ```bash
 # 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
@@ -143,7 +143,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 entombment..."
@@ -205,12 +205,12 @@ Verify QUEEN.md is initialized for wisdom storage:
 ```bash
 queen_file=".aether/QUEEN.md"
 if [[ ! -f "$queen_file" ]]; then
-  init_result=$(bash .aether/aether-utils.sh queen-init 2>/dev/null || echo '{"ok":false}')
+  init_result=$(aether queen-init 2>/dev/null || echo '{"ok":false}')
   init_ok=$(echo "$init_result" | jq -r '.ok // false')
   if [[ "$init_ok" == "true" ]]; then
     created=$(echo "$init_result" | jq -r '.result.created // false')
     if [[ "$created" == "true" ]]; then
-      bash .aether/aether-utils.sh activity-log "CREATED" "Queen" "Initialized QUEEN.md for wisdom storage"
+      aether activity-log "CREATED" "Queen" "Initialized QUEEN.md for wisdom storage"
     fi
   fi
 fi
@@ -248,7 +248,7 @@ version=$(jq -r '.version // "3.0"' .aether/data/COLONY_STATE.json)
 
 Create the chamber:
 ```bash
-bash .aether/aether-utils.sh chamber-create \
+aether chamber-create \
   ".aether/chambers/$chamber_name" \
   ".aether/data/COLONY_STATE.json" \
   "$goal" \
@@ -298,7 +298,7 @@ Export combined XML archive to the chamber. This is a HARD REQUIREMENT — entom
 
 ```bash
 chamber_dir=".aether/chambers/$chamber_name"
-xml_result=$(bash .aether/aether-utils.sh colony-archive-xml "$chamber_dir/colony-archive.xml" 2>&1)
+xml_result=$(aether colony-archive-xml --output "$chamber_dir/colony-archive.xml" 2>&1)
 xml_ok=$(echo "$xml_result" | jq -r '.ok // false' 2>/dev/null)
 
 if [[ "$xml_ok" != "true" ]]; then
@@ -326,7 +326,7 @@ xml_archive_line="XML Archive: colony-archive.xml (${xml_pheromone_count} signal
 
 Run verification:
 ```bash
-bash .aether/aether-utils.sh chamber-verify ".aether/chambers/$chamber_name"
+aether chamber-verify --path ".aether/chambers/$chamber_name"
 ```
 
 If verification fails, display error and stop:
@@ -344,7 +344,7 @@ Stop here.
 
 Write colony summary to eternal memory:
 ```bash
-bash .aether/aether-utils.sh eternal-init  # idempotent
+aether eternal-init  # idempotent
 eternal_file="$HOME/.aether/eternal/memory.json"
 if [[ -f "$eternal_file" ]]; then
   colony_entry=$(jq -n \
@@ -444,7 +444,7 @@ Write the result to .aether/HANDOFF.md using the Write tool.
 Display:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   C O L O N Y   E N T O M B E D
+⚰️ C O L O N Y   E N T O M B E D
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Entombed v{colony_version}

package/.claude/commands/ant/export-signals.md

@@ -23,7 +23,7 @@ Parse `$ARGUMENTS`:
 
 Run using the Bash tool with description "Exporting pheromone signals to XML...":
 ```bash
-bash .aether/aether-utils.sh pheromone-export-xml "<output_path>"
+aether pheromone-export-xml --output "<output_path>"
 ```
 
 Parse the returned JSON:
@@ -52,6 +52,6 @@ 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/feedback.md

@@ -32,7 +32,7 @@ If `goal: null` -> "No colony initialized.", stop.
 
 Run using the Bash tool with description "Recording colony feedback...":
 ```bash
-bash .aether/aether-utils.sh pheromone-write FEEDBACK "<content>" --strength 0.7 --reason "User feedback guidance" --ttl <ttl>
+aether pheromone-write --type FEEDBACK --content "<content>" --strength 0.7 --reason "User feedback guidance" --ttl <ttl>
 ```
 
 **Create instinct from feedback:**
@@ -59,14 +59,14 @@ Write COLONY_STATE.json.
 
 Run using the Bash tool with description "Updating context document...":
 ```bash
-bash .aether/aether-utils.sh context-update constraint feedback "<content>" "user" 2>/dev/null || true
+aether context-update --section constraint --key feedback --content "<content>" "user" 2>/dev/null || true
 ```
 
 ### Step 3: Get Active Counts
 
 Run using the Bash tool with description "Counting active signals...":
 ```bash
-bash .aether/aether-utils.sh pheromone-count
+aether pheromone-count
 ```
 
 ### Step 4: Confirm
@@ -91,6 +91,6 @@ 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/flag.md

@@ -51,7 +51,7 @@ Stop here.
 
 Run using the Bash tool with description "Raising colony flag...":
 ```bash
-bash .aether/aether-utils.sh flag-add "{type}" "{title}" "{description}" "manual" {phase_or_null}
+aether flag-add --severity "{type}" --title "{title}" --description "{description}" --source "manual" --phase {phase_or_null}
 ```
 
 Parse the result for the flag ID.
@@ -135,7 +135,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/flags.md

@@ -33,7 +33,7 @@ If `--resolve` was provided, run using the Bash tool with description "Resolving
 
 
 ```bash
-bash .aether/aether-utils.sh flag-resolve "{flag_id}" "{resolution_message}"
+aether flag-resolve --id "{flag_id}" --message "{resolution_message}"
 ```
 Output:
 ```
@@ -48,7 +48,7 @@ If `--ack` was provided, run using the Bash tool with description "Acknowledging
 
 
 ```bash
-bash .aether/aether-utils.sh flag-acknowledge "{flag_id}"
+aether flag-acknowledge --id "{flag_id}"
 ```
 Output:
 ```
@@ -65,7 +65,7 @@ Run using the Bash tool with description "Loading colony flags...":
 
 
 ```bash
-bash .aether/aether-utils.sh flag-list {options}
+aether flag-list {options}
 ```
 
 Parse result for flags array.
@@ -145,7 +145,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/focus.md

@@ -32,7 +32,7 @@ If `goal: null` -> "No colony initialized.", stop.
 
 Run using the Bash tool with description "Setting colony focus...":
 ```bash
-bash .aether/aether-utils.sh pheromone-write FOCUS "<content>" --strength 0.8 --reason "User directed colony attention" --ttl <ttl>
+aether pheromone-write --type FOCUS --content "<content>" --strength 0.8 --reason "User directed colony attention" --ttl <ttl>
 ```
 
 Parse the returned JSON for the signal ID.
@@ -41,14 +41,14 @@ Parse the returned JSON for the signal ID.
 
 Run using the Bash tool with description "Updating context document...":
 ```bash
-bash .aether/aether-utils.sh context-update constraint focus "<content>" "user" 2>/dev/null || true
+aether context-update --section constraint --key focus --content "<content>" "user" 2>/dev/null || true
 ```
 
 ### Step 3: Get Active Counts
 
 Run using the Bash tool with description "Counting active signals...":
 ```bash
-bash .aether/aether-utils.sh pheromone-count
+aether pheromone-count
 ```
 
 ### Step 4: Confirm
@@ -71,6 +71,6 @@ 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/help.md

@@ -149,6 +149,6 @@ Generate the state-based Next Up block by Run using the Bash tool with descripti
 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/history.md

@@ -135,6 +135,6 @@ Generate the state-based Next Up block using the Bash tool with description "Gen
 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/import-signals.md

@@ -36,7 +36,7 @@ Verify the XML file exists. If not -> "File not found: <path>", stop.
 
 Run using the Bash tool with description "Importing pheromone signals from XML...":
 ```bash
-bash .aether/aether-utils.sh pheromone-import-xml "<xml_path>" "<colony_prefix>"
+aether pheromone-import-xml --input "<xml_path>" --colony "<colony_prefix>"
 ```
 
 Parse the returned JSON:
@@ -66,6 +66,6 @@ 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/init.md

@@ -41,7 +41,6 @@ Do not touch during init:
 - .aether/dreams/ (user notes)
 - .aether/chambers/ (archived colonies)
 - .env* files
-- .claude/settings.json
 - .github/workflows/
 </read_only>
 
@@ -90,7 +89,7 @@ Stop here. Do not proceed.
 
 Run using the Bash tool with description "Initializing QUEEN.md...":
 ```
-bash .aether/aether-utils.sh queen-init
+aether queen-init
 ```
 
 Parse the JSON result:
@@ -103,7 +102,7 @@ This step is non-blocking -- proceed regardless of outcome.
 
 Run the scan via Bash tool:
 ```bash
-scan_result=$(bash .aether/aether-utils.sh init-research 2>/dev/null)
+scan_result=$(aether init-research 2>/dev/null)
 scan_data=$(echo "$scan_result" | jq '.result')
 ```
 
@@ -156,7 +155,7 @@ Strip `(Colony: ...)` suffixes using sed. If grep finds nothing, variables remai
 Display a brief header:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   A E T H E R   C O L O N Y   I N I T
+🥚 A E T H E R   C O L O N Y   I N I T
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
@@ -274,14 +273,14 @@ Only reached after user approval. ALL file writes happen here.
 
 1. Write charter content via:
 ```bash
-bash .aether/aether-utils.sh charter-write --intent "{approved_intent}" --vision "{approved_vision}" --governance "{approved_governance}" --goals "{approved_goals}"
+aether charter-write --intent "{approved_intent}" --vision "{approved_vision}" --governance "{approved_governance}" --goals "{approved_goals}"
 ```
 
 2. Auto-apply approved pheromone suggestions (see pheromone auto-apply below).
 
 3. Update the goal field in COLONY_STATE.json in-place using the state API:
 ```bash
-bash .aether/aether-utils.sh state-write "$(jq --arg new_goal "{approved_intent}" '.goal = $new_goal' .aether/data/COLONY_STATE.json)"
+aether state-write "$(jq --arg new_goal "{approved_intent}" '.goal = $new_goal' .aether/data/COLONY_STATE.json)"
 ```
 
 4. **Verify the write** — read back and confirm goal is set:
@@ -299,7 +298,7 @@ if [[ "$verify_goal" == "null" || -z "$verify_goal" ]]; then
 fi
 ```
 
-5. Run `bash .aether/aether-utils.sh session-init "$(jq -r '.session_id' .aether/data/COLONY_STATE.json)" "{approved_intent}"`
+5. Run `aether session-init "$(jq -r '.session_id' .aether/data/COLONY_STATE.json)" "{approved_intent}"`
 
 6. Skip to Step 8 (display result). Do NOT write COLONY_STATE.json from template, do NOT write constraints.json, do NOT write pheromones.json.
 
@@ -357,12 +356,12 @@ for template in pheromones midden learning-observations; do
 done
 ```
 
-8. Run `bash .aether/aether-utils.sh context-update init "{approved_intent}"`
-9. Run `bash .aether/aether-utils.sh validate-state colony`
+8. Run `aether context-update init "{approved_intent}"`
+9. Run `aether validate-state colony`
 10. Register repo (silent on failure):
 ```bash
-domain_tags=$(bash .aether/aether-utils.sh domain-detect 2>/dev/null | jq -r '.result.tags // ""' || echo "")
-bash .aether/aether-utils.sh registry-add "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --goal "{approved_intent}" --active true --tags "$domain_tags" 2>/dev/null || true
+domain_tags=$(aether domain-detect 2>/dev/null | jq -r '.result.tags // ""' || echo "")
+aether registry-add --path "$(pwd)" "$(jq -r '.version // "unknown"' ~/.aether/version.json 2>/dev/null || echo 'unknown')" --goal "{approved_intent}" --active true --tags "$domain_tags" 2>/dev/null || true
 cp ~/.aether/version.json .aether/version.json 2>/dev/null || true
 ```
 11. Seed QUEEN.md from hive (non-blocking):
@@ -372,10 +371,10 @@ domain_tags=$(jq -r --arg repo "$(pwd)" \
   "$HOME/.aether/registry.json" 2>/dev/null || echo "")
 seed_args="queen-seed-from-hive --limit 5"
 [[ -n "$domain_tags" ]] && seed_args="$seed_args --domain $domain_tags"
-seed_result=$(bash .aether/aether-utils.sh $seed_args 2>/dev/null || echo '{}')
+seed_result=$(aether $seed_args 2>/dev/null || echo '{}')
 seeded_count=$(echo "$seed_result" | jq -r '.result.seeded // 0' 2>/dev/null || echo "0")
 ```
-12. Run `bash .aether/aether-utils.sh session-init "{session_id}" "{approved_intent}"`
+12. Run `aether session-init "{session_id}" "{approved_intent}"`
 
 **Pheromone auto-apply (referenced by both re-init and fresh init paths above):**
 
@@ -383,7 +382,7 @@ If approved pheromone suggestions exist (the user kept them in the prompt and di
 
 For each approved pheromone suggestion, call:
 ```bash
-bash .aether/aether-utils.sh pheromone-write "{type}" '{content}' --source "system:init" --reason '{reason}' --ttl "30d" 2>/dev/null || true
+aether pheromone-write "{type}" '{content}' --source "system:init" --reason '{reason}' --ttl "30d" 2>/dev/null || true
 ```
 
 Implementation notes:
@@ -441,21 +440,21 @@ Import ALL available data types (per D-09 -- no cherry-picking):
 ```bash
 # Import pheromones (per D-09)
 if [[ -f "$latest_chamber/pheromones.xml" ]]; then
-  pher_import=$(bash .aether/aether-utils.sh pheromone-import-xml "$latest_chamber/pheromones.xml" "imported" 2>/dev/null || echo '{"ok":false}')
+  pher_import=$(aether pheromone-import-xml --input "$latest_chamber/pheromones.xml" --colony "imported" 2>/dev/null || echo '{"ok":false}')
   pher_imported=$(echo "$pher_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
   echo "Pheromones: ${pher_imported} signal(s) imported"
 fi
 
 # Import wisdom to queen-wisdom.json (per D-09)
 if [[ -f "$latest_chamber/queen-wisdom.xml" ]]; then
-  wis_import=$(bash .aether/aether-utils.sh wisdom-import-xml "$latest_chamber/queen-wisdom.xml" ".aether/data/queen-wisdom.json" 2>/dev/null || echo '{"ok":false}')
+  wis_import=$(aether wisdom-import-xml "$latest_chamber/queen-wisdom.xml" ".aether/data/queen-wisdom.json" 2>/dev/null || echo '{"ok":false}')
   wis_imported=$(echo "$wis_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
   echo "Wisdom: ${wis_imported} entries(s) imported to queen-wisdom.json"
 fi
 
 # Import registry lineage (per D-09)
 if [[ -f "$latest_chamber/colony-registry.xml" ]]; then
-  reg_import=$(bash .aether/aether-utils.sh registry-import-xml "$latest_chamber/colony-registry.xml" 2>/dev/null || echo '{"ok":false}')
+  reg_import=$(aether registry-import-xml "$latest_chamber/colony-registry.xml" 2>/dev/null || echo '{"ok":false}')
   reg_imported=$(echo "$reg_import" | jq -r '.result.imported // 0' 2>/dev/null || echo "0")
   echo "Registry: ${reg_imported} colon(ies) lineage imported"
 fi
@@ -470,30 +469,48 @@ Display "Import skipped. Starting fresh colony." and proceed to Step 8.
 **If xml_import_available is false (no chambers, no XML, or no xmllint):**
 
 Skip silently -- proceed directly to Step 8 without any mention of import (per D-11).
+### Step 7.5: Install Clash Detection Hook
+
+If `.aether/utils/clash-detect.sh` exists, run:
+
+```bash
+aether clash-setup --install 2>/dev/null || true
+```
+
+This installs the PreToolUse hook that prevents conflicting edits across worktrees.
+Non-blocking — if it fails, init continues normally.
+
+Also configure the merge driver for package-lock.json:
+
+```bash
+git config merge.lockfile.driver "bash .aether/utils/merge-driver-lockfile.sh %O %A %B" 2>/dev/null || true
+git config merge.lockfile.name "npm lockfile auto-merge" 2>/dev/null || true
+```
+
 ### Step 8: Display Result
 
 Display the success header and result block:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   A E T H E R   C O L O N Y
+🥚 A E T H E R   C O L O N Y
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Queen has set the colony's intention
+👑 Queen has set the colony's intention
 
    "{approved_intent}"
 
-   Colony Status: READY
+   🟢 Colony Status: READY
 
-{If re-init: "   Mode: Re-init (charter updated, state preserved)"}
-{If fresh and seeded_count > 0: "   Hive wisdom: {seeded_count} cross-colony pattern(s) seeded into QUEEN.md"}
+{If re-init: "   🔄 Mode: Re-init (charter updated, state preserved)"}
+{If fresh and seeded_count > 0: "   🧠 Hive wisdom: {seeded_count} cross-colony pattern(s) seeded into QUEEN.md"}
 
-State persisted -- safe to /clear, then run /ant:plan
+💾 State persisted -- safe to /clear, then run /ant:plan
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   Next Up
+🐜 Next Up
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   /ant:plan                 Generate execution plan
-   /ant:status               Check colony state
-   /ant:focus                Set initial focus
+   /ant:plan                 📊 Generate execution plan
+   /ant:status               📋 Check colony state
+   /ant:focus                🎯 Set initial focus
 ```

package/.claude/commands/ant/insert-phase.md

@@ -70,7 +70,7 @@ Example:
 Run using the Bash tool with description "Inserting corrective phase...":
 
 ```bash
-bash .aether/aether-utils.sh phase-insert "<phase_name>" "<goal_text>" "<constraints_text>"
+aether phase-insert --name "<phase_name>" --goal "<goal_text>" --constraints "<constraints_text>"
 ```
 
 Parse JSON result:

package/.claude/commands/ant/interpret.md

@@ -229,7 +229,7 @@ Wait for user response.
 Run using the Bash tool with description "Logging interpretation activity...":
 
 ```bash
-bash .aether/aether-utils.sh activity-log "INTERPRET" "Interpreter" "Dream review: {dream_file}, {confirmed} confirmed, {partial} partial, {unconfirmed} unconfirmed, {refuted} refuted, {actions_taken} actions taken"
+aether activity-log "INTERPRET" "Interpreter" "Dream review: {dream_file}, {confirmed} confirmed, {partial} partial, {unconfirmed} unconfirmed, {refuted} refuted, {actions_taken} actions taken"
 ```
 
 ### Step 8: Display Closing
@@ -261,7 +261,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/lay-eggs.md

@@ -142,7 +142,7 @@ echo "System files copied."
 
 Run using the Bash tool with description "Initializing QUEEN.md...":
 ```bash
-bash .aether/aether-utils.sh queen-init
+aether queen-init
 ```
 
 
@@ -160,7 +160,7 @@ Run using the Bash tool with description "Registering repo..." (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/.claude/commands/ant/maturity.md

@@ -11,7 +11,7 @@ You are the **Queen**. Display the colony's maturity journey.
 ### Step 1: Detect Current Milestone
 
 Run using the Bash tool with description "Detecting colony milestone...":
-`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)
@@ -108,6 +108,6 @@ 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/memory-details.md

@@ -20,7 +20,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/.claude/commands/ant/migrate-state.md

@@ -166,6 +166,6 @@ 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
 ```