aether-colony 3.1.17 → 5.0.0

package/.claude/commands/ant/feedback.md

@@ -1,39 +1,35 @@
 ---
 name: ant:feedback
-description: "💬🐜🧠🐜💬 Emit FEEDBACK signal to provide guidance to colony"
+description: "Emit FEEDBACK signal to provide guidance to colony"
 ---
 
-You are the **Queen**. Emit a FEEDBACK signal.
+You are the **Queen**. Emit a FEEDBACK pheromone signal.
 
 ## Instructions
 
 The feedback message is: `$ARGUMENTS`
 
 ### Step 1: Validate
+
 If `$ARGUMENTS` empty -> show usage: `/ant:feedback <message>`, stop.
 If content > 500 chars -> "Signal content too long (max 500 chars)", stop.
 
-### Step 2: Read + Update State
+Parse optional flags from `$ARGUMENTS`:
+- `--ttl <value>`: signal lifetime (e.g., `2h`, `1d`, `7d`). Default: `phase_end`.
+- Strip flags from content before using it as the feedback message.
+
+### Step 2: Write Signal and Create Instinct
+
 Read `.aether/data/COLONY_STATE.json`.
 If `goal: null` -> "No colony initialized.", stop.
 
-Generate ISO-8601 timestamp.
-
-**Add signal:**
-Append to `signals` array:
-```json
-{
-  "id": "feedback_<timestamp_ms>",
-  "type": "FEEDBACK",
-  "content": "<feedback message>",
-  "priority": "low",
-  "created_at": "<ISO-8601>",
-  "expires_at": "phase_end"
-}
+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>
 ```
 
 **Create instinct from feedback:**
-User feedback is high-value learning. Append to `memory.instincts`:
+User feedback is high-value learning. Generate ISO-8601 timestamp and append to `memory.instincts` in COLONY_STATE.json:
 ```json
 {
   "id": "instinct_<timestamp>",
@@ -52,23 +48,31 @@ User feedback is high-value learning. Append to `memory.instincts`:
 
 Write COLONY_STATE.json.
 
-### Step 3: Confirm
-
-Output header:
+### Step 3: Get Active Counts
 
+Run using the Bash tool with description "Counting active signals...":
+```bash
+bash .aether/aether-utils.sh pheromone-count
 ```
-💬🐜🧠🐜💬 ═══════════════════════════════════════════════════
-   F E E D B A C K   S I G N A L
-═══════════════════════════════════════════════════ 💬🐜🧠🐜💬
-```
 
-Then output:
+### Step 4: Confirm
+
+Output (4 lines, no banners):
 ```
-💬 FEEDBACK signal emitted
+FEEDBACK signal emitted
+  Note: "<content truncated to 60 chars>"
+  Strength: 0.7 | Expires: <phase end or ttl value>
+  Active signals: <focus_count> FOCUS, <redirect_count> REDIRECT, <feedback_count> FEEDBACK
 
-   "{content preview}"
+Instinct created: [0.7] <domain>: <action summary>
+```
 
-🧠 Instinct created: [0.7] <domain>: <action summary>
+### Step 5: Next Up
 
-🐜 The colony will remember this guidance.
+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"
 ```

package/.claude/commands/ant/flag.md

@@ -48,7 +48,7 @@ Stop here.
 
 ### Step 3: Create Flag
 
-Run:
+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}
 ```
@@ -61,23 +61,23 @@ Output header based on flag type:
 
 **For blocker:**
 ```
-🚩🐜📋🐜🚩 ═══════════════════════════════════════════════════
-   B L O C K E R   F L A G   C R E A T E D
-═══════════════════════════════════════════════════ 🚩🐜📋🐜🚩
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚩🐜📋🐜🚩  B L O C K E R   F L A G   C R E A T E D
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
 **For issue:**
 ```
-🚩🐜📋🐜🚩 ═══════════════════════════════════════════════════
-   I S S U E   F L A G   C R E A T E D
-═══════════════════════════════════════════════════ 🚩🐜📋🐜🚩
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚩🐜📋🐜🚩  I S S U E   F L A G   C R E A T E D
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
 **For note:**
 ```
-🚩🐜📋🐜🚩 ═══════════════════════════════════════════════════
-   N O T E   F L A G   C R E A T E D
-═══════════════════════════════════════════════════ 🚩🐜📋🐜🚩
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚩🐜📋🐜🚩  N O T E   F L A G   C R E A T E D
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
 Then output based on flag type:
@@ -119,6 +119,14 @@ Then output based on flag type:
    Use /ant:flags to view all flags.
 ```
 
+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"
+```
+
 ---
 
 ## Flag Lifecycle

package/.claude/commands/ant/flags.md

@@ -27,7 +27,7 @@ Examples:
 
 ### Step 2: Handle Resolution/Acknowledgment
 
-If `--resolve` was provided:
+If `--resolve` was provided, run using the Bash tool with description "Resolving colony flag...":
 ```bash
 bash .aether/aether-utils.sh flag-resolve "{flag_id}" "{resolution_message}"
 ```
@@ -39,7 +39,7 @@ Output:
 ```
 Stop here.
 
-If `--ack` was provided:
+If `--ack` was provided, run using the Bash tool with description "Acknowledging colony flag...":
 ```bash
 bash .aether/aether-utils.sh flag-acknowledge "{flag_id}"
 ```
@@ -53,7 +53,7 @@ Stop here.
 
 ### Step 3: List Flags
 
-Run:
+Run using the Bash tool with description "Loading colony flags...":
 ```bash
 bash .aether/aether-utils.sh flag-list {options}
 ```
@@ -65,9 +65,9 @@ Parse result for flags array.
 Output header:
 
 ```
-📋🐜🚩🐜📋 ═══════════════════════════════════════════════════
-   P R O J E C T   F L A G S
-═══════════════════════════════════════════════════ 📋🐜🚩🐜📋
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📋🐜🚩🐜📋  P R O J E C T   F L A G S
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
 If no flags:
@@ -127,6 +127,14 @@ Commands:
   /ant:flag "description"               Create new flag
 ```
 
+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"
+```
+
 ---
 
 ## Quick Actions

package/.claude/commands/ant/focus.md

@@ -1,9 +1,9 @@
 ---
 name: ant:focus
-description: "🔦🐜🔍🐜🔦 Emit FOCUS signal to guide colony attention"
+description: "Emit FOCUS signal to guide colony attention"
 ---
 
-You are the **Queen**. Add a FOCUS constraint.
+You are the **Queen**. Emit a FOCUS pheromone signal.
 
 ## Instructions
 
@@ -14,37 +14,45 @@ The focus area is: `$ARGUMENTS`
 If `$ARGUMENTS` empty -> show usage: `/ant:focus <area>`, stop.
 If content > 500 chars -> "Focus content too long (max 500 chars)", stop.
 
-### Step 2: Read + Update Constraints
+Parse optional flags from `$ARGUMENTS`:
+- `--ttl <value>`: signal lifetime (e.g., `2h`, `1d`, `7d`). Default: `phase_end`.
+- Strip flags from content before using it as the focus area.
+
+### Step 2: Write Signal
 
 Read `.aether/data/COLONY_STATE.json`.
 If `goal: null` -> "No colony initialized.", stop.
 
-Read `.aether/data/constraints.json`. If file doesn't exist, create it with:
-```json
-{"version": "1.0", "focus": [], "constraints": []}
+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>
 ```
 
-Append the focus area to the `focus` array.
-
-If `focus` array exceeds 5 entries, remove the oldest entries to keep only 5.
+Parse the returned JSON for the signal ID.
 
-Write constraints.json.
+### Step 3: Get Active Counts
 
-### Step 3: Confirm
+Run using the Bash tool with description "Counting active signals...":
+```bash
+bash .aether/aether-utils.sh pheromone-count
+```
 
-Output header:
+### Step 4: Confirm
 
+Output (3-4 lines, no banners):
 ```
-🔦🐜🔍🐜🔦 ═══════════════════════════════════════════════════
-   F O C U S   S I G N A L
-═══════════════════════════════════════════════════ 🔦🐜🔍🐜🔦
-```
-
-Then output:
+FOCUS signal emitted
+  Area: "<content truncated to 60 chars>"
+  Strength: 0.8 | Expires: <phase end or ttl value>
+  Active signals: <focus_count> FOCUS, <redirect_count> REDIRECT, <feedback_count> FEEDBACK
 ```
-🎯 FOCUS signal emitted
 
-   "{content preview}"
+### Step 5: Next Up
 
-🐜 Colony attention directed.
+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"
 ```

package/.claude/commands/ant/help.md

@@ -11,7 +11,7 @@ Output the following:
 
 ```
 👑 AETHER QUEEN ANT COLONY
-══════════════════════════════════════════
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   A multi-agent system built on ant colony intelligence.
   Workers self-organize via pheromone signals. You guide with intention.
@@ -110,3 +110,13 @@ HOW IT WORKS
     spawn-tree.txt      Worker spawn hierarchy
     constraints.json    Focus/redirect pheromone data
 ```
+
+### Next Up
+
+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"
+```

package/.claude/commands/ant/history.md

@@ -125,3 +125,13 @@ Show total event count at the end:
 ```
 Total events recorded: <count>
 ```
+
+### Step 8: Next Up
+
+Generate the state-based Next Up block 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"
+```

package/.claude/commands/ant/init.md

@@ -13,6 +13,37 @@ Parse `$ARGUMENTS`:
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
+<failure_modes>
+### Colony State Overwrite
+If COLONY_STATE.json already exists with an active colony:
+- STOP before overwriting
+- Warn: "Active colony detected with goal: [goal]. Overwriting will lose this data."
+- Options: (1) Archive first with /ant:seal, (2) Continue and overwrite, (3) Cancel
+
+### Write Failure Mid-Init
+If writing COLONY_STATE.json fails partway:
+- Remove the incomplete file (partial state is worse than no state)
+- Report the error
+- Recovery: user can run /ant:init again safely
+</failure_modes>
+
+<success_criteria>
+Command is complete when:
+- COLONY_STATE.json exists and is valid JSON
+- Colony goal, milestone, and timestamp are set
+- Session file is written
+- User sees confirmation of colony creation
+</success_criteria>
+
+<read_only>
+Do not touch during init:
+- .aether/dreams/ (user notes)
+- .aether/chambers/ (archived colonies)
+- .env* files
+- .claude/settings.json
+- .github/workflows/
+</read_only>
+
 ### Step 0: Initialize Visual Mode (if enabled)
 
 If `visual_mode` is true:
@@ -20,14 +51,13 @@ If `visual_mode` is true:
 # Generate session ID
 init_id="init-$(date +%s)"
 
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$init_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Colony initialization" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
+# Initialize swarm display (consolidated)
+bash .aether/aether-utils.sh swarm-display-init "$init_id" && bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Colony initialization" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
 ```
 
 ### Step 0.5: Version Check (Non-blocking)
 
-Run using the Bash tool: `bash .aether/aether-utils.sh version-check 2>/dev/null || true`
+Run using the Bash tool with description "Checking colony version...": `bash .aether/aether-utils.sh 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.
 
@@ -58,18 +88,29 @@ Check if `.aether/aether-utils.sh` exists using the Read tool.
 **If the file already exists** — skip this step entirely. System files are present.
 
 **If the file does NOT exist:**
-- Check if `~/.aether/system/` exists (expand `~` to the user's home directory)
+- Check if `~/.aether/system/aether-utils.sh` exists (expand `~` to the user's home directory)
 - **If the hub exists:** Run using the Bash tool:
+  ```bash
+  mkdir -p .aether/docs .aether/utils .aether/templates .aether/schemas .aether/exchange .claude/rules && \
+  cp -f ~/.aether/system/aether-utils.sh .aether/ && \
+  cp -f ~/.aether/system/workers.md .aether/ 2>/dev/null || true && \
+  cp -f ~/.aether/system/CONTEXT.md .aether/ 2>/dev/null || true && \
+  cp -f ~/.aether/system/model-profiles.yaml .aether/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/docs/* .aether/docs/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/utils/* .aether/utils/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/templates/* .aether/templates/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/schemas/* .aether/schemas/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/exchange/* .aether/exchange/ 2>/dev/null || true && \
+  cp -Rf ~/.aether/system/rules/* .claude/rules/ 2>/dev/null || true && \
+  chmod +x .aether/aether-utils.sh
   ```
-  bash ~/.aether/system/aether-utils.sh bootstrap-system
-  ```
-  This copies system files from the global hub into `.aether/`. Display:
+  This copies system files from the global hub into `.aether/` and rules into `.claude/rules/`. Display:
   ```
   Bootstrapped system files from global hub.
   ```
 - **If the hub does NOT exist:** Output:
   ```
-  No Aether system files found locally or in ~/.aether/.
+  No Aether system files found locally or in ~/.aether/system/.
   Run `aether install` or `npx aether-colony install` to set up the global hub first.
   ```
   Stop here. Do not proceed.
@@ -111,7 +152,6 @@ If the `goal` field is not null:
 Colony already initialized with goal: "{existing_goal}"
 
 State freshness: {freshness_status}
-Session: {session_id}
 Initialized: {initialized_at}
 
 To reinitialize with a new goal, the current state will be reset.
@@ -149,9 +189,23 @@ If no instincts meet the threshold, display:
 
 Generate a session ID in the format `session_{unix_timestamp}_{random}` and an ISO-8601 UTC timestamp.
 
-Use the Write tool to write `.aether/data/COLONY_STATE.json` with the v3.0 structure.
+Resolve the colony-state template path:
+  Check `~/.aether/system/templates/colony-state.template.json` first,
+  then `.aether/templates/colony-state.template.json`.
+
+If no template found: output "Template missing: colony-state.template.json. Run aether update to fix." and stop.
 
-**If Step 2.6 found instincts to inherit**, convert each into the instinct format and seed the `memory.instincts` array. Each inherited instinct should have:
+Read the template file. Follow its `_instructions` field.
+Replace all `__PLACEHOLDER__` values:
+  - `__GOAL__` → the user's goal from $ARGUMENTS
+  - `__SESSION_ID__` → the generated session ID (format: `session_{unix_timestamp}_{random}`)
+  - `__ISO8601_TIMESTAMP__` → the current ISO-8601 UTC timestamp (used in both `initialized_at` and the events entry)
+  - `__PHASE_LEARNINGS__` → JSON array from Step 2.6, or `[]` if none
+  - `__INSTINCTS__` → JSON array from Step 2.6, or `[]` if none
+
+IMPORTANT: `__PHASE_LEARNINGS__` and `__INSTINCTS__` must be JSON array values (e.g., `[]` not `"[]"`).
+
+**If Step 2.6 found instincts to inherit**, convert each into the instinct format for the `__INSTINCTS__` array. Each inherited instinct should have:
 - `id`: `instinct_inherited_{index}`
 - `trigger`: inferred from the instinct description
 - `action`: the instinct description
@@ -164,56 +218,29 @@ Use the Write tool to write `.aether/data/COLONY_STATE.json` with the v3.0 struc
 - `applications`: 0
 - `successes`: 0
 
-**If Step 2.6 found validated learnings**, seed `memory.phase_learnings` with each as:
+**If Step 2.6 found validated learnings**, seed the `__PHASE_LEARNINGS__` array with each as:
 - `phase`: `"inherited"`
 - `learning`: the learning text
 - `status`: `"validated"`
 - `source`: `"inherited:completion-report"`
 
-**If Step 2.6 was skipped or found nothing**, use empty arrays as before.
-
-```json
-{
-  "version": "3.0",
-  "goal": "<the user's goal>",
-  "state": "READY",
-  "current_phase": 0,
-  "session_id": "<generated session_id>",
-  "initialized_at": "<ISO-8601 timestamp>",
-  "build_started_at": null,
-  "plan": {
-    "generated_at": null,
-    "confidence": null,
-    "phases": []
-  },
-  "memory": {
-    "phase_learnings": "<inherited learnings or []>",
-    "decisions": [],
-    "instincts": "<inherited instincts or []>"
-  },
-  "errors": {
-    "records": [],
-    "flagged_patterns": []
-  },
-  "signals": [],
-  "graveyards": [],
-  "events": [
-    "<ISO-8601 timestamp>|colony_initialized|init|Colony initialized with goal: <the user's goal>"
-  ]
-}
-```
+**If Step 2.6 was skipped or found nothing**, use empty arrays `[]` for both `__PHASE_LEARNINGS__` and `__INSTINCTS__`.
+
+Remove ALL keys starting with underscore (`_template`, `_version`, `_instructions`, `_comment_*`).
+Write the resulting JSON to `.aether/data/COLONY_STATE.json` using the Write tool.
 
 ### Step 4: Initialize Constraints
 
-Write `.aether/data/constraints.json`:
+Resolve the constraints template path:
+  Check `~/.aether/system/templates/constraints.template.json` first,
+  then `.aether/templates/constraints.template.json`.
 
-```json
-{
-  "version": "1.0",
-  "focus": [],
-  "constraints": []
-}
-```
+If no template found: output "Template missing: constraints.template.json. Run aether update to fix." and stop.
+
+Read the template file. Follow its `_instructions` field.
+No placeholder substitution needed — the data keys are written as-is.
+Remove ALL keys starting with underscore (`_template`, `_version`, `_instructions`, `_comment_*`).
+Write the resulting JSON to `.aether/data/constraints.json` using the Write tool.
 
 ### Step 5: Initialize Context Document
 
@@ -260,18 +287,17 @@ If either command fails, proceed silently. These are optional bookkeeping.
 
 ### Step 7: Display Result
 
-**If visual_mode is true, render final swarm display:**
+**If visual_mode is true, render final swarm display (consolidated):**
 ```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony initialized" "Colony" '{"read":5,"grep":2,"edit":3,"bash":2}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-inline "$init_id"
+bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony initialized" "Colony" '{"read":5,"grep":2,"edit":3,"bash":2}' 100 "fungus_garden" 100 && bash .aether/aether-utils.sh swarm-display-text "$init_id"
 ```
 
 Output this header:
 
 ```
-🌱🐜🆕🐜🌱 ═══════════════════════════════════════════════════
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    A E T H E R   C O L O N Y
-═══════════════════════════════════════════════════ 🌱🐜🆕🐜🌱
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
 Then output the result:
@@ -282,7 +308,6 @@ Then output the result:
    "{goal}"
 
 🏠 Colony Status: READY
-📋 Session: <session_id>
 
 {If instincts or learnings were inherited from Step 2.6:}
 🧠 Inherited from prior colony:
@@ -295,15 +320,16 @@ Then output the result:
    during planning and execution.
 {End if}
 
-🐜 The colony awaits your command:
-
-   /ant:plan      📋 Generate project plan
-   /ant:colonize  🗺️  Analyze existing codebase first
-   /ant:watch     👁️  Set up live visibility
-
 💾 State persisted — safe to /clear, then run /ant:plan
 
 📋 Context document created at `.aether/CONTEXT.md` — read this if session resets
+
+──────────────────────────────────────────────────
+🐜 Next Up
+──────────────────────────────────────────────────
+   /ant:plan                 📋 Create execution plan
+   /ant:status               📊 Check colony state
+   /ant:focus                🎯 Set initial focus
 ```
 
 ### Step 8: Initialize Session

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

@@ -53,9 +53,9 @@ Also read in parallel:
 ### Step 2: Display Header
 
 ```
-🔍🐜💭🐜🔍 ═══════════════════════════════════════════════
+🔍🐜💭🐜🔍 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
          D R E A M   I N T E R P R E T E R
-═══════════════════════════════════════════════ 🔍🐜💭🐜🔍
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🔍🐜💭🐜🔍
 
 📓 Reviewing: {dream_filename}
    {N} dreams | {concerns} concerns | {pheromones} suggested pheromones
@@ -147,9 +147,9 @@ Verdict emoji mapping:
 After all dreams are interpreted, display:
 
 ```
-🔍🐜💭🐜🔍 ═══════════════════════════════════════════════
+🔍🐜💭🐜🔍 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
          I N T E R P R E T A T I O N   C O M P L E T E
-═══════════════════════════════════════════════ 🔍🐜💭🐜🔍
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🔍🐜💭🐜🔍
 
 📊 Results:
    {confirmed_count} confirmed | {partial_count} partially confirmed | {unconfirmed_count} unconfirmed | {refuted_count} refuted
@@ -218,6 +218,7 @@ Wait for user response.
 
 ### Step 7: Log Activity
 
+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"
 ```
@@ -243,6 +244,16 @@ bash .aether/aether-utils.sh activity-log "INTERPRET" "Interpreter" "Dream revie
 /ant:build    🔨 Start building
 ```
 
+### Step 9: Next Up
+
+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"
+```
+
 ## Investigation Guidelines
 
 When investigating dreams, remember: