aether-colony 3.1.17 → 5.0.0

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

@@ -13,7 +13,7 @@ Parse `$ARGUMENTS`:
 
 ### Step 0: Initialize Visual Mode (if enabled)
 
-If `visual_mode` is true:
+If `visual_mode` is true, run using the Bash tool with description "Initializing resume display...":
 ```bash
 # Generate session ID
 resume_id="resume-$(date +%s)"
@@ -25,13 +25,13 @@ bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "
 
 ### 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.
 
 ### Step 1: Load State and Validate
 
-Run using Bash tool: `bash .aether/aether-utils.sh load-state`
+Run using the Bash tool with description "Restoring colony session...": `bash .aether/aether-utils.sh load-state`
 
 If successful:
 1. Parse state from result
@@ -58,9 +58,9 @@ If `signals` array is empty or all expired, treat as "no active pheromones."
 Output header:
 
 ```
-🚦➡️🐜💨💨 ═══════════════════════════════════════════════════
+🚦➡️🐜💨💨 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    C O L O N Y   R E S U M E D
-═══════════════════════════════════════════════════ 🚦➡️🐜💨💨
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🚦➡️🐜💨💨
 ```
 
 Read the .aether/HANDOFF.md for context about what was happening, then display:
@@ -93,10 +93,10 @@ CONTEXT FROM HANDOFF
 NEXT ACTIONS
 ```
 
-**If visual_mode is true, render final swarm display:**
+**If visual_mode is true, render final swarm display** by running using the Bash tool with description "Updating resume display...":
 ```bash
 bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony resumed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":1}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-inline "$resume_id"
+bash .aether/aether-utils.sh swarm-display-text "$resume_id"
 ```
 
 Route to next action based on state:
@@ -113,9 +113,19 @@ Use Write tool to update COLONY_STATE.json:
 - Update last_updated timestamp
 - Add event: `{timestamp, type: "colony_resumed", worker: "resume", details: "Session resumed"}`
 
-Use Bash tool to remove HANDOFF.md: `rm -f .aether/HANDOFF.md`
+Use Bash tool with description "Cleaning up handoff file..." to remove HANDOFF.md: `rm -f .aether/HANDOFF.md`
 
-Run: `bash .aether/aether-utils.sh unload-state` to release lock.
+Run using the Bash tool with description "Releasing colony lock...": `bash .aether/aether-utils.sh unload-state` to release lock.
+
+### Step 7: 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/resume.md

@@ -1,21 +1,12 @@
-# /ant:resume — Resume Previous Session
-
-Resume work from where you left off after a context clear or new session start.
-
-## When to Use
+---
+name: resume
+description: "Resume Previous Session"
+symbol: refresh
+---
 
-- After running `/clear` and wanting to continue previous work
-- When opening a new Claude Code session with existing colony state
-- To check what you were working on and pick up where you left off
-
-## What It Does
+# /ant:resume — Resume Previous Session
 
-1. Reads `.aether/data/session.json` to understand previous activity
-2. Reads `COLONY_STATE.json` to verify colony status
-3. Checks `TO-DOs.md` for relevant pending work
-4. Presents a summary and asks if you want to resume
-5. If yes: Restores context and suggests next step
-6. If no: Offers to start fresh with `/ant:init`
+Resume work after `/clear` or in a new session. Reads colony state, detects codebase drift, and gives you a clear "do this next" recommendation.
 
 ## Usage
 
@@ -23,137 +14,322 @@ Resume work from where you left off after a context clear or new session start.
 /ant:resume
 ```
 
-## Session Recovery Flow
+---
+
+## Implementation
+
+Execute the following steps in order when the user runs `/ant:resume`.
+
+---
 
-### Step 1: Check for Existing Session
+### Step 1: Read Session State
 
+Run using the Bash tool with description "Restoring colony session...":
 ```bash
 bash .aether/aether-utils.sh session-read
 ```
 
-Check if session exists and whether it's stale (> 24 hours old).
+Parse the JSON result.
 
-### Step 2: If No Session Found
+- If `exists` is `false`: display the following and **stop**:
 
-Display:
 ```
-📋 SESSION RESUME
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+RESUME SESSION
 
 No previous session found.
 
-Would you like to:
-1. Start a new colony with /ant:init
-2. Check status with /ant:status
-3. View existing colonies with /ant:history
+Start fresh: /ant:init "your goal"
+Or check: /ant:status
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-Offer to run `/ant:init` to start fresh.
+- If `exists` is `true`: extract from the session data:
+  - `colony_goal`
+  - `current_phase`
+  - `last_command`
+  - `suggested_next`
+  - `baseline_commit`
+  - `session_id`
 
-### Step 3: If Session Exists
+---
 
-Read session data and colony state, then present summary:
+### Step 2: Read COLONY_STATE.json (Authoritative Source)
+
+Use the Read tool to read `.aether/data/COLONY_STATE.json`.
+
+COLONY_STATE.json is the authoritative source for goal and state (session.json may be stale). Extract:
+- `goal` (use this as authoritative, overriding session.json colony_goal)
+- `state` (READY, PLANNING, EXECUTING, PAUSED)
+- `current_phase`
+- `plan.phases` (array with id, name, status for each phase)
+- `plan.generated_at`
+- `memory.decisions` (flat list — do NOT distinguish user vs Claude origin)
+- `events` (last 5 for recent activity context)
+
+If the file is missing or the JSON cannot be parsed, **stop immediately** and display:
 
 ```
-📋 SESSION RESUME
+State file missing or corrupted.
 
-You were working on: {colony_goal}
-Current Phase: {current_phase} ({current_milestone})
-Last Command: {last_command}
-Last Active: {hours_ago} hours ago
-Suggested Next: {suggested_next}
+Options:
+1. Start fresh with /ant:init "goal"
+2. Try to recover (I'll look for backup files)
+
+What would you like to do?
+```
+
+Do NOT proceed with stale or fabricated data.
+
+---
+
+### Step 3: Read Pheromone Signals
 
-Active TODOs:
-- {todo1}
-- {todo2}
+Use the Read tool to read `.aether/data/constraints.json`.
 
-Would you like to resume this work?
+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.
+
+---
+
+### Step 4: Read CONTEXT.md
+
+Use the Read tool to read `.aether/CONTEXT.md` if it exists.
+
+If missing: fall back to COLONY_STATE.json for narrative context. Note: "Context document not found — reconstructing from state."
+
+---
+
+### Step 5: Drift Detection
+
+Extract `baseline_commit` from the session.json data read in Step 1.
+
+```bash
+current_commit=$(git rev-parse HEAD 2>/dev/null || echo "")
 ```
 
-Use `AskUserQuestion` to present options:
-- **Yes, resume** — Continue where you left off
-- **Show details** — See full colony state first
-- **No, start fresh** — Clear session and start new
+If `baseline_commit` is non-empty and differs from `current_commit`:
+
+```bash
+commit_count=$(git rev-list --count "$baseline_commit..HEAD" 2>/dev/null || echo "0")
+changed_count=$(git diff --stat "$baseline_commit" HEAD 2>/dev/null | tail -1 | grep -oE '[0-9]+ file' | grep -oE '[0-9]+' || echo "0")
+```
 
-### Step 4: If User Chooses "Yes, resume"
+Store `drift_detected=true`, `commit_count`, `changed_count` for dashboard rendering.
 
-1. Mark session as resumed:
-   ```bash
-   bash .aether/aether-utils.sh session-mark-resumed
-   ```
+If `baseline_commit` is empty or matches `current_commit`: set `drift_detected=false`.
 
-2. Present context summary:
-   ```
-   🔄 Resuming Session
+Restore identically regardless of time elapsed — no warnings about session age.
 
-   Colony: {goal}
-   Phase: {phase} - {milestone}
-   Context restored.
+---
 
-   Next suggested step: {suggested_next}
-   ```
+### Step 6: Compute Workflow Position and Next-Step Guidance
 
-3. Run the suggested command or present further options based on state.
+Compute `suggested_next` dynamically from COLONY_STATE.json data. Do not use the static value from session.json.
 
-### Step 5: If User Chooses "Show details"
+Use this decision tree:
 
-Display:
 ```
-📊 Colony Details
+Case 1 — No plan created yet:
+  Check: plan.phases is empty AND plan.generated_at is null
+  recommended = "/ant:plan"
+  reason = "No plan created yet"
+  alternatives = ["/ant:colonize — analyze codebase first"]
+
+Case 2 — Plan ready, first phase not started:
+  Check: plan.phases is not empty AND state == "READY" AND current_phase == 0
+  recommended = "/ant:build 1"
+  reason = "Plan ready, first phase not started"
+  alternatives = ["/ant:plan — review or regenerate plan"]
+
+Case 3 — Build in progress:
+  Check: state == "EXECUTING"
+  recommended = "/ant:continue"
+  reason = "Build in progress"
+  alternatives = ["/ant:build {current_phase} — rebuild current phase", "/ant:flags — check for blockers"]
+
+Case 4 — Phase complete, next phase available:
+  Check: state == "READY" AND current_phase > 0 AND current_phase < plan.phases.length
+  next = current_phase + 1
+  recommended = "/ant:build {next}"
+  reason = "Phase {current_phase} complete, ready for next"
+  alternatives = ["/ant:plan — regenerate plan", "/ant:phase {next} — preview next phase"]
+
+Case 5 — All phases complete:
+  Check: state == "READY" AND current_phase > 0 AND current_phase >= plan.phases.length
+  recommended = "/ant:seal"
+  reason = "All phases complete"
+  alternatives = ["/ant:status — view final state"]
+
+Case 6 — Colony paused:
+  Check: state == "PAUSED"
+  recommended = "/ant:resume-colony"
+  reason = "Colony is paused"
+  alternatives = ["/ant:status — check state first"]
+
+Default:
+  recommended = "/ant:status"
+  reason = "Check colony status"
+  alternatives = []
+```
+
+---
+
+### Step 7: Workflow-Step Blocking (Early-Return Guards)
+
+Run these guards BEFORE rendering the dashboard. If a blocking condition is detected, output the block message and STOP. Do not render the dashboard. Do not offer alternative commands.
 
+**BLOCK CONDITION 1: No plan exists**
+
+Check: plan.phases is empty AND plan.generated_at is null
+
+Output and STOP:
+
+```
+BLOCKED: No plan exists yet.
+Required: Run /ant:plan to create a build plan.
 Goal: {goal}
-State: {state}
-Phase: {phase}
-Milestone: {milestone}
+```
+
+Stop here — do not continue to Step 8 or render the dashboard.
+
+---
+
+**BLOCK CONDITION 2: Plan attempted but failed**
 
-Recent Activity (from activity.log):
-{last 5 entries}
+Check: plan.phases is empty AND plan.generated_at is not null
 
-Pending TODOs:
-{todos}
+Output and STOP:
 
-[Present Yes/No choice to resume]
+```
+BLOCKED: Plan was attempted but has no phases.
+Required: Run /ant:plan to regenerate the plan.
+Goal: {goal}
 ```
 
-### Step 6: If User Chooses "No, start fresh"
+Stop here — do not continue to Step 8 or render the dashboard.
 
-1. Clear the session:
-   ```bash
-   bash .aether/aether-utils.sh session-clear
-   ```
+---
 
-2. Offer:
-   ```
-   Session cleared.
+**BLOCK CONDITION 3: Build interrupted**
 
-   Start fresh with:
-   - /ant:init "your new goal"
-   - /ant:status (to check other colonies)
-   ```
+Check: state == "EXECUTING" AND the last 3 events show no recent build activity
 
-## Integration with Colony Commands
+Output and STOP:
 
-All `/ant:*` commands should update the session after execution:
+```
+BLOCKED: Build may have been interrupted.
+Required: Run /ant:continue to check and advance.
+Goal: {goal}
+```
+
+Stop here — do not continue to Step 8 or render the dashboard.
+
+---
+
+### Step 8: Render Dashboard
+
+Lead with the next-step recommendation. Context follows underneath ("straight to action" ordering).
 
-```bash
-# Example: After /ant:build completes
-bash .aether/aether-utils.sh session-update "/ant:build $phase" "/ant:continue" "Completed phase $phase"
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+RESUME SESSION
 
-This ensures session.json is always current for resume functionality.
+Next: {recommended}
+      {reason}
+{if alternatives exist:}
+Also: {alternatives, comma-separated}
+{end}
 
-## Session File Location
+{if drift_detected:}
+Note: Codebase changed since last session ({commit_count} commit(s), {changed_count} file(s) modified)
+{end}
 
-`.aether/data/session.json`
+Goal: {goal}
+State: {state}
+Phase: {current_phase}/{total_phases}
 
-This file persists across context clears and Claude Code sessions.
+Phase Progress:
+{for each phase in plan.phases:}
+  [{status_icon}] Phase {id}: {name}
+{end}
+```
 
-## Stale Session Detection
+Status icons:
+- completed: `v` (checkmark)
+- in_progress: `~` (tilde)
+- pending: ` ` (space)
 
-Sessions older than 24 hours are marked "stale":
-- User is warned: "This session is X days old"
-- Given option to resume anyway or start fresh
-- Helps prevent accidentally resuming ancient work
+```
+{if memory.decisions is not empty:}
+Recent Decisions:
+{for each of the last 5 decisions:}
+  - {decision text}
+{end}
+{end}
+
+{if focus array or constraints array is not empty:}
+Active Signals:
+{for each focus signal:}
+  FOCUS: {focus text}
+{end}
+{for each constraint signal:}
+  REDIRECT: {constraint text}
+{end}
+{end}
 
-## Implementation
+Last Command: {last_command}
+Session: {session_id}
+```
+
+---
+
+### Step 9: Mark Session Resumed
+
+Run using the Bash tool with description "Marking session as resumed...":
+```bash
+bash .aether/aether-utils.sh session-mark-resumed
+```
+
+### Step 10: 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"
+```
 
-Execute this flow when user runs `/ant:resume`.
+---
+
+## Error Handling Reference
+
+| Condition | Response |
+|-----------|----------|
+| 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) |
+| 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 |
+| State EXECUTING, events show no activity | BLOCK — redirect to /ant:continue |
+| baseline_commit matches current HEAD | No drift warning shown |
+| baseline_commit differs from current HEAD | Show informational drift note |
+
+---
+
+## Key Constraints
+
+- Use Read tool for COLONY_STATE.json and constraints.json (not bash cat/jq)
+- 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
+- Decisions shown as flat list — no user vs Claude distinction
+- Blocking guards run BEFORE dashboard rendering (early-return pattern)
+- Drift detection is informational only — not alarming, not a blocker