aether-colony 5.3.3 → 5.4.0

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
 ```
 

package/.claude/commands/ant/oracle.md

@@ -44,10 +44,10 @@ Oracle peering into the depths...
 
 ### Step 0b: Stop Oracle
 
-Create the stop signal file by running using the Bash tool with description "Stopping oracle research...":
+Stop any active Oracle research by running using the Bash tool with description "Stopping 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:
@@ -55,8 +55,11 @@ Output:
 ```
 🔮🐜 Oracle Stop Signal Sent
 
-   Created .aether/oracle/.stop
-   The research loop will halt at the end of the current iteration.
+   Removed loop state files.
+   - .aether/oracle/.stop (signal for legacy tmux loop)
+   - .aether/oracle/.loop-active (signal for in-session loop)
+
+   Any active research will halt at the next iteration boundary.
 
    To check final results: /ant:oracle status
 ```
@@ -409,14 +412,14 @@ ORACLE_START=$(date +%s)
 
 Check for stale files by running using the Bash tool with description "Checking for stale oracle session...":
 ```bash
-stale_check=$(bash .aether/aether-utils.sh session-verify-fresh --command oracle "" "$ORACLE_START")
+stale_check=$(aether session-verify-fresh --command oracle "" "$ORACLE_START")
 has_stale=$(echo "$stale_check" | jq -r '.stale | length')
 has_progress=$(echo "$stale_check" | jq -r '.fresh | length')
 
 if [[ "$has_stale" -gt 0 ]] || [[ "$has_progress" -gt 0 ]]; then
   # Found existing oracle session
   if [[ "$force_research" == "true" ]]; then
-    bash .aether/aether-utils.sh session-clear --command oracle
+    aether session-clear --command oracle
     echo "Cleared stale oracle session for fresh research"
   else
     # Existing session found - prompt user
@@ -482,7 +485,7 @@ Use the Write tool to create `.aether/oracle/state.json`:
 For each focus area string from Question 7, run using the Bash tool with description "Emitting focus area pheromones...":
 
 ```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
 ```
@@ -581,7 +584,7 @@ Next investigation: <text of q1, the first question>
 
 Verify that state.json, plan.json, gaps.md, synthesis.md, and research-plan.md were created successfully by running using the Bash tool with description "Verifying oracle files...":
 ```bash
-verify_result=$(bash .aether/aether-utils.sh session-verify-fresh --command oracle "" "$ORACLE_START")
+verify_result=$(aether session-verify-fresh --command oracle "" "$ORACLE_START")
 fresh_count=$(echo "$verify_result" | jq -r '.fresh | length')
 
 if [[ "$fresh_count" -lt 5 ]]; then
@@ -593,7 +596,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:
 
@@ -617,61 +620,59 @@ 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** by running using the Bash tool with description "Launching oracle in tmux...":
+**Create the loop marker file** by running using the Bash tool with description "Creating oracle loop marker...":
 
 ```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"
+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"
 ```
 
-**If TMUX_OK:**
+Output:
 
 ```
-🔮🐜 Oracle Launched
+🔮🐜 Oracle Research Started (In-Session Loop)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-   The Oracle is researching in a background tmux session.
+   The Oracle is researching IN THIS SESSION.
+
+   The Stop hook will keep the loop running automatically:
+   - Each iteration researches one question
+   - Phases advance: survey -> investigate -> synthesize -> verify
+   - Loop ends when confidence reaches {target_confidence}% or max iterations hit
+   - A final synthesis pass produces the research report
 
-   👁️  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.
+   You can continue chatting. The Oracle loop runs between your messages.
 ```
 
-Stop here.
-
-**If TMUX_FAIL** (tmux not installed or error):
-
-```
-🔮 Ready to Launch
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-   tmux not available. Run this in a separate terminal:
-
-   cd {current_working_directory}
-   bash .aether/utils/oracle/oracle.sh
-
-   Then come back here:
-   📊 Check status:   /ant:oracle status
-   🛑 Stop early:     /ant:oracle stop
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
+**Now begin the first iteration.** Read `.aether/utils/oracle/oracle.md` and start the survey phase research immediately.
+Target the first untouched question from plan.json. Update state files as you go.
+When you try to stop, the Stop hook will check progress and continue the loop if needed.
 
 Generate the state-based Next Up block by running 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)
 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
 ```
-
-Stop here.

package/.claude/commands/ant/organize.md

@@ -33,7 +33,7 @@ From COLONY_STATE.json, extract:
 
 Run using the Bash tool with description "Loading active pheromones...":
 ```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).
@@ -209,7 +209,7 @@ Next:
 
 Use the Bash tool with description "Logging hygiene activity..." 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:
@@ -228,5 +228,5 @@ 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/patrol.md

@@ -249,12 +249,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:**
@@ -332,12 +332,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:**
@@ -357,7 +357,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:
@@ -586,7 +586,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/.claude/commands/ant/pause-colony.md

@@ -25,7 +25,7 @@ If `goal` is null, output `No colony initialized. Nothing to pause.` and stop.
 
 Run using the Bash tool with description "Loading active pheromones...":
 ```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).
@@ -117,7 +117,7 @@ Store this as `ai_description`. If no clear description emerges, leave empty (wi
 
 **4. Generate Enhanced Commit Message:**
 ```bash
-bash .aether/aether-utils.sh generate-commit-message "contextual" {current_phase} "{phase_name}" "{ai_description}" {plan_number}
+aether generate-commit-message --type "contextual" --phase {current_phase} --subject "{phase_name}" "{ai_description}" {plan_number}
 ```
 
 Parse the returned JSON to extract `message`, `body`, `files_changed`, `subsystem`, and `scope`.
@@ -173,12 +173,12 @@ Continue to Step 5.
 Log this pause activity to `.aether/CONTEXT.md` by running using the Bash tool with description "Updating context document...":
 
 ```bash
-bash .aether/aether-utils.sh context-update activity "pause-colony" "Colony paused — handoff created" "—"
+aether context-update activity "pause-colony" "Colony paused — handoff created" "—"
 ```
 
 Update safe-to-clear status by running using the Bash tool with description "Marking safe to clear...":
 ```bash
-bash .aether/aether-utils.sh context-update safe-to-clear "YES" "Colony paused — safe to /clear, run /ant:resume-colony to continue"
+aether context-update safe-to-clear "YES" "Colony paused — safe to /clear, run /ant:resume-colony to continue"
 ```
 
 ### Step 5: Display Confirmation
@@ -229,5 +229,5 @@ 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/phase.md

@@ -75,7 +75,7 @@ After displaying phase details, generate the state-based Next Up block by runnin
 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/pheromones.md

@@ -112,7 +112,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/.claude/commands/ant/plan.md

@@ -39,7 +39,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
@@ -54,7 +54,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
@@ -90,7 +90,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`.
@@ -172,7 +172,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 = ""`.
@@ -574,7 +574,7 @@ if [[ "$verify_phases" -lt 1 || "$verify_timestamp" == "null" || "$verify_state"
   echo "ERROR: Plan write verification failed (phases=$verify_phases, generated_at=$verify_timestamp, state=$verify_state)"
   echo "Attempting retry write..."
   # Retry: re-read, update, write via state API
-  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."
@@ -585,7 +585,7 @@ fi
 echo "Plan verified: $verify_phases phases, generated_at=$verify_timestamp, state=$verify_state"
 ```
 
-Log: `bash .aether/aether-utils.sh activity-log "PLAN_COMPLETE" "queen" "Plan finalized with {confidence}% confidence"`
+Log: `aether activity-log "PLAN_COMPLETE" "queen" "Plan finalized with {confidence}% confidence"`
 
 Update watch-status.txt:
 ```
@@ -604,7 +604,7 @@ Ready to build.
 Update the session tracking file to enable `/ant:resume` after context clear:
 
 ```bash
-bash .aether/aether-utils.sh session-update "/ant:plan" "/ant:build 1" "Plan generated with {confidence}% confidence, {N} phases"
+aether session-update --command "/ant:plan" --worker "/ant:build 1" --summary "Plan generated with {confidence}% confidence, {N} phases"
 ```
 
 ### Step 7: Display Plan
@@ -653,7 +653,7 @@ After displaying the plan, 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/quick.md

@@ -33,7 +33,7 @@ Stop here.
 
 Run using the Bash tool with description "Naming scout...":
 ```bash
-bash .aether/aether-utils.sh generate-ant-name "scout"
+aether generate-ant-name --caste "scout"
 ```
 
 Capture the output as `scout_name`.
@@ -48,7 +48,7 @@ Spawning {scout_name} — {query truncated to 50 chars}
 
 Run using the Bash tool with description "Dispatching scout...":
 ```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}"
 ```
 
 
@@ -82,14 +82,14 @@ Display the Scout's answer directly to the user.
 
 Run using the Bash tool with description "Recording scout completion...":
 ```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 using the Bash tool with description "Updating session...":
 ```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/.claude/commands/ant/redirect.md

@@ -32,7 +32,7 @@ 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>
+aether pheromone-write --type REDIRECT --content "<content>" --strength 0.9 --reason "User warned colony away from pattern" --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 redirect "<content>" "user" 2>/dev/null || true
+aether context-update --section constraint --key redirect --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/resume-colony.md

@@ -17,13 +17,13 @@ Parse `$ARGUMENTS`:
 If `visual_mode` is true, run using the Bash tool with description "Initializing resume display...":
 ### 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`
+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.
 
 ### Step 1: Load State and Validate
 
-Run using the Bash tool with description "Restoring colony session...": `bash .aether/aether-utils.sh load-state`
+Run using the Bash tool with description "Restoring colony session...": `aether load-state`
 
 If successful:
 1. Parse state from result
@@ -38,7 +38,7 @@ Keep state loaded (don't unload yet) - we'll need it for the full display.
 
 Run using the Bash tool with description "Loading active pheromones...":
 ```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).
@@ -130,7 +130,7 @@ Use Write tool to update COLONY_STATE.json:
 
 Use Bash tool with description "Cleaning up handoff file..." to remove HANDOFF.md: `rm -f .aether/HANDOFF.md`
 
-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 7: Next Up
 
@@ -139,7 +139,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/resume.md

@@ -26,7 +26,7 @@ Execute the following steps in order when the user runs `/ant:resume`.
 
 Run using the Bash tool with description "Restoring colony session..."::
 ```bash
-bash .aether/aether-utils.sh session-read
+aether session-read
 ```
 
 Parse the JSON result.
@@ -96,18 +96,18 @@ Do NOT proceed with stale or fabricated data.
 
 ### Step 3: Read Pheromone Signals
 
+Run using the Bash tool with description "Loading active pheromone signals..."::
+```bash
+aether pheromone-read all
+```
 
-Use the Read tool to read `.aether/data/constraints.json`.
-
-Extract the following top-level keys:
-- `focus` array — active focus signals (if key missing, treat as empty array)
-- `constraints` array — active redirect/constraint signals (if key missing, treat as empty array)
-
-If the file is missing: skip silently (no pheromones active).
-
-Pheromones persist until explicitly cleared — no decay.
+Parse the JSON result. Extract `.result.signals` array.
 
+- If `ok` is `true` and `.result.signals` is non-empty: store signals for dashboard rendering in Step 8
+- If `ok` is `true` and `.result.signals` is empty: no active pheromones (skip in dashboard)
+- If the command fails or returns an error: skip silently (no pheromones active)
 
+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.
 
 ---
 
@@ -290,15 +290,9 @@ Recent Decisions:
 
 {if signals array from Step 3 is not empty:}
 Active Signals:
-
-{for each focus signal:}
-  FOCUS: {focus text}
+{for each signal in signals:}
+  {signal.type}: "{signal.content}" [{signal.effective_strength * 100 | floor}%]
 {end}
-{for each constraint signal:}
-  REDIRECT: {constraint text}
-{end}
-
-
 {end}
 ```
 
@@ -308,7 +302,7 @@ Active Signals:
 
 Run using the Bash tool with description "Loading memory health..."::
 ```bash
-bash .aether/aether-utils.sh resume-dashboard
+aether resume-dashboard
 ```
 
 Extract memory_health from the JSON result:
@@ -340,7 +334,7 @@ Session: {session_id}
 
 Run using the Bash tool with description "Marking session as resumed..."::
 ```bash
-bash .aether/aether-utils.sh session-mark-resumed
+aether session-mark-resumed
 ```
 
 ### Step 10: Next Up
@@ -350,7 +344,7 @@ 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
 ```
 
 ---
@@ -361,10 +355,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 |
-
-| constraints.json missing | Skip silently (no pheromones) |
-
-
+| 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 |
@@ -376,10 +367,7 @@ 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 (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