aether-colony 5.0.0 → 5.2.1

package/.opencode/commands/ant/seal.md

@@ -1,34 +1,23 @@
+<!-- Generated from .aether/commands/seal.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:seal
 description: "🏺🐜🏺 Seal the colony with Crowned Anthill milestone"
 ---
 
-You are the **Queen**. Seal the colony when all work is complete.
-
-## Instructions
-
 ### Step -1: Normalize Arguments
 
 Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
 
 This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
 
+You are the **Queen**. Seal the colony when all work is complete.
+
+## Instructions
+
 Parse `$normalized_args`:
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
-### Step 0: Initialize Visual Mode (if enabled)
-
-If `visual_mode` is true:
-```bash
-# Generate session ID
-seal_id="seal-$(date +%s)"
-
-# Initialize swarm display
-bash .aether/aether-utils.sh swarm-display-init "$seal_id"
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "excavating" "Sealing colony" "Colony" '{"read":0,"grep":0,"edit":0,"bash":0}' 0 "fungus_garden" 0
-```
-
 ### Step 1: Read State
 
 Read `.aether/data/COLONY_STATE.json`.
@@ -139,6 +128,31 @@ Create archive manifest file `$archive_dir/manifest.json`:
 }
 ```
 
+### Step 4.5: Increment Colony Version
+
+Before writing the Crowned Anthill milestone, increment `colony_version` in COLONY_STATE.json.
+
+```bash
+# Read current colony_version (default to 0 for backward compat with older colonies)
+current_colony_version=$(jq -r '.colony_version // 0' .aether/data/COLONY_STATE.json 2>/dev/null || echo 0)
+# Guard against non-integer values (floats, strings)
+[[ "$current_colony_version" =~ ^[0-9]+$ ]] || current_colony_version=0
+new_colony_version=$(( current_colony_version + 1 ))
+
+# Write incremented value back — guard against empty output destroying the file
+updated=$(jq --argjson v "$new_colony_version" '.colony_version = $v' .aether/data/COLONY_STATE.json 2>/dev/null)
+if [[ -n "$updated" && ${#updated} -gt 10 ]]; then
+  echo "$updated" > .aether/data/COLONY_STATE.json
+else
+  echo "Warning: jq update failed — colony_version defaults to 1, state file unchanged"
+  new_colony_version=1
+fi
+```
+
+Use `new_colony_version` as `{colony_version}` throughout the rest of the seal ceremony (e.g., display as "Crowned Anthill v{colony_version}").
+
+**Error handling:** If jq fails or produces empty/short output, COLONY_STATE.json is NOT overwritten and `new_colony_version` defaults to 1. Never let version increment failures block the seal.
+
 ### Step 5: Update Milestone to Crowned Anthill
 
 Update COLONY_STATE.json:
@@ -146,6 +160,99 @@ Update COLONY_STATE.json:
 2. Set `milestone_updated_at` to current ISO-8601 timestamp
 3. Append event: `"<timestamp>|milestone_reached|archive|Achieved Crowned Anthill milestone - colony archived"`
 
+### Step 5.1: Update Changelog
+
+**MANDATORY: Record the seal in the project changelog. This step is never skipped.**
+
+If no `CHANGELOG.md` exists, `changelog-append` creates one automatically.
+
+Build a summary of what the colony accomplished across all phases:
+- Collect completed phase names from COLONY_STATE.json
+- Summarize the goal and key outcomes in one line
+
+```bash
+bash .aether/aether-utils.sh changelog-append \
+  "$(date +%Y-%m-%d)" \
+  "seal-crowned-anthill" \
+  "00" \
+  "{key_files_csv}" \
+  "Colony sealed at Crowned Anthill;{goal}" \
+  "{phases_completed} phases completed;Colony wisdom promoted to QUEEN.md" \
+  ""
+```
+
+- `{key_files_csv}` — list the most significant files created or modified across the colony's lifetime (derive from phase plans or git log)
+- `{goal}` — the colony goal from COLONY_STATE.json
+
+**Error handling:** If `changelog-append` fails, log to midden and continue — changelog failure never blocks sealing.
+
+### Step 5.2: Update Registry (Silent)
+
+Mark the colony as inactive in the global registry. This is silent on failure — registry is not required for the colony to work.
+
+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
+```
+
+If the command fails, proceed silently. This is optional bookkeeping.
+
+### Step 5.25: Hive Promotion (NON-BLOCKING)
+
+After wisdom promotion, promote abstracted instincts to the cross-colony hive.
+
+**Extract high-confidence instincts for hive promotion:**
+```bash
+# Get instincts with confidence >= 0.8
+high_conf_instincts=$(jq -r '.memory.instincts[] | select(.confidence >= 0.8) | @base64' .aether/data/COLONY_STATE.json 2>/dev/null || echo "")
+
+# Derive source repo name from current directory
+source_repo="$(pwd)"
+
+# Read domain tags from registry (NOT from instinct.domain which is a category, not a repo domain)
+repo_domain_tags=$(jq -r --arg repo "$(pwd)" \
+  '[.repos[] | select(.path == $repo) | .domain_tags // []] | .[0] // [] | join(",")' \
+  "$HOME/.aether/registry.json" 2>/dev/null || echo "")
+
+hive_promoted_count=0
+hive_errors=0
+for encoded in $high_conf_instincts; do
+  [[ -z "$encoded" ]] && continue
+
+  # Extract trigger and action fields from the instinct object
+  trigger=$(echo "$encoded" | base64 -d | jq -r '.trigger // empty')
+  action=$(echo "$encoded" | base64 -d | jq -r '.action // empty')
+  confidence=$(echo "$encoded" | base64 -d | jq -r '.confidence // 0.7')
+
+  [[ -z "$trigger" || -z "$action" ]] && continue
+
+  # Strip leading "When " or "when " from trigger to avoid "When When..." stutter
+  trigger_clean=$(echo "$trigger" | sed 's/^[Ww]hen //')
+
+  # Build the promotion text in "When {trigger}: {action}" format
+  promote_text="When ${trigger_clean}: ${action}"
+
+  # Build hive-promote args with --text and --source-repo (required)
+  promote_args=(hive-promote --text "$promote_text" --source-repo "$source_repo" --confidence "$confidence")
+  [[ -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 '{}')
+  was_promoted=$(echo "$result" | jq -r '.result.action // "skipped"' 2>/dev/null || echo "skipped")
+
+  if [[ "$was_promoted" == "promoted" || "$was_promoted" == "merged" ]]; then
+    hive_promoted_count=$((hive_promoted_count + 1))
+  fi
+done
+
+if [[ "$hive_promoted_count" -gt 0 ]]; then
+  echo "Hive promotion: $hive_promoted_count instinct(s) promoted to cross-colony hive"
+fi
+```
+
+**Continue to Step 5.5 (non-blocking):**
+Proceed to Step 5.5 regardless of hive promotion results — hive promotion is strictly non-blocking.
+
 ### Step 5.5: Write Final Handoff
 
 After archiving, write the final handoff documenting the completed colony:
@@ -171,7 +278,7 @@ This handoff serves as the final record of the completed colony.
 
 ### Step 5.75: Export XML Archive (best-effort)
 
-Export colony data as a combined XML archive. This is best-effort — seal proceeds even if XML export fails.
+Export colony data as a combined XML archive and a standalone pheromones.xml. Both are best-effort — seal proceeds even if XML export fails.
 
 ```bash
 # Check if xmllint is available
@@ -184,30 +291,57 @@ if command -v xmllint >/dev/null 2>&1; then
   else
     xml_export_line="XML Archive: export failed (non-blocking)"
   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_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")
+    pher_export_line="Signal Export: pheromones.xml (${pher_signal_count} signals, importable by other colonies)"
+  else
+    pher_export_line="Signal Export: failed (non-blocking)"
+  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_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)
+    wisdom_export_line="Wisdom Export: queen-wisdom.xml (${wisdom_count} entries)"
+  else
+    wisdom_export_line="Wisdom Export: failed (non-blocking)"
+  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_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)
+    registry_export_line="Registry Export: colony-registry.xml (${registry_count} colonies)"
+  else
+    registry_export_line="Registry Export: failed (non-blocking)"
+  fi
 else
   xml_export_line="XML Archive: skipped (xmllint not available)"
+  pher_export_line="Signal Export: skipped (xmllint not available)"
+  wisdom_export_line="Wisdom Export: skipped (xmllint not available)"
+  registry_export_line="Registry Export: skipped (xmllint not available)"
 fi
 ```
 
 ### Step 6: Display Result
 
-**If visual_mode is true, render final swarm display:**
-```bash
-bash .aether/aether-utils.sh swarm-display-update "Queen" "prime" "completed" "Colony sealed" "Colony" '{"read":3,"grep":0,"edit":2,"bash":3}' 100 "fungus_garden" 100
-bash .aether/aether-utils.sh swarm-display-render "$seal_id"
-```
-
 Output:
 ```
 🏺 ════════════════════════════════════════════════════
-   C R O W N E D   A N T H I L L
+   C R O W N E D   A N T H I L L   v{colony_version}
 ══════════════════════════════════════════════════ 🏺
 
 ✅ Colony archived successfully!
 
 👑 Goal: {goal (truncated to 60 chars)}
 📍 Phases: {total_phases} completed
-🏆 Milestone: Crowned Anthill
+🏆 Milestone: Crowned Anthill v{colony_version}
 
 📦 Archive Location: {archive_dir}
    - COLONY_STATE.json
@@ -216,6 +350,9 @@ Output:
    - flags.json (if existed)
    - constraints.json (if existed)
 {xml_export_line}
+{pher_export_line}
+{wisdom_export_line}
+{registry_export_line}
 
 🐜 The colony has reached its final form.
    The anthill stands crowned and sealed.
@@ -235,6 +372,74 @@ If option 2 selected: run /ant:tunnels
 If option 3 selected: display "Run /ant:lay-eggs to begin anew after clearing"
 ```
 
+### Step 6.5: Commit Suggestion (Non-blocking)
+
+After the ceremony, offer to commit all colony work.
+
+**Gate check — skip silently if any fail:**
+1. Not a git repo: `git rev-parse --git-dir 2>/dev/null` fails -> skip
+2. Clean working tree: `git status --porcelain 2>/dev/null` is empty -> skip to Step 6.6
+
+**If uncommitted changes exist:**
+
+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_message=$(echo "$seal_commit" | jq -r '.result.message // "aether-seal: colony sealed"')
+seal_body=$(echo "$seal_commit" | jq -r '.result.body // ""')
+```
+
+Display the suggestion:
+```
+Commit suggestion:
+  $seal_message
+  $seal_body
+```
+
+Prompt with AskUserQuestion (3 options):
+1. **Commit with this message** — Run `git add -A && git commit -m "$seal_message" -m "$seal_body"`
+2. **Edit message** — Ask user for their preferred message, then commit with that
+3. **Skip** — Do not commit
+
+If the user chooses option 1 or 2 and the commit succeeds, set `seal_committed = true`.
+If the commit fails or user skips, set `seal_committed = false`.
+
+**Error handling:** If `generate-commit-message` fails, fall back to message `"aether-seal: colony sealed"`. Never let commit suggestion failures stop the seal flow.
+
+### Step 6.6: Push Suggestion (Non-blocking)
+
+Only show if a commit was just made in Step 6.5 (`seal_committed == true`) OR if there are unpushed commits.
+
+**Gate check — skip silently if any fail:**
+1. Not a git repo -> skip
+2. No remote configured: `git remote -v 2>/dev/null` is empty -> skip
+
+**Check for unpushed commits:**
+```bash
+unpushed=$(git log --oneline @{u}..HEAD 2>/dev/null | wc -l | tr -d ' ')
+```
+If `unpushed == 0` and `seal_committed == false` -> skip
+
+**If there are commits to push:**
+
+Detect current branch and upstream status:
+```bash
+current_branch=$(git branch --show-current)
+has_upstream=$(git rev-parse --abbrev-ref @{u} 2>/dev/null && echo "yes" || echo "no")
+```
+
+Display: `Push {unpushed} commit(s) to remote? Branch: {current_branch}`
+
+Prompt with AskUserQuestion (2 options):
+1. **Push now** — If upstream exists: `git push`. If no upstream: `git push -u origin $current_branch`
+2. **I'll push later** — Skip
+
+Display result on success or skip.
+
+**Error handling:** If push fails, display the error but do not stop the seal flow.
+
+**Safety:** Never auto-push. Always require explicit user approval.
+
 ### Edge Cases
 
 **If milestone is already "Sealed Chambers" but phases are complete:**

package/.opencode/commands/ant/skill-create.md

@@ -0,0 +1,63 @@
+<!-- Generated from .aether/commands/skill-create.yaml - DO NOT EDIT DIRECTLY -->
+---
+name: ant:skill-create
+description: "Create a custom domain skill using Oracle mini-research and a guided wizard"
+---
+
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
+You are the **Builder**. Create a custom domain skill by researching best practices and guiding the user through a wizard.
+
+## Instructions
+
+### Step 0: Parse Arguments
+
+If `$normalized_args` is empty:
+```
+Usage: /ant:skill-create "<topic>"
+
+Creates a custom domain skill using Oracle mini-research.
+
+Examples:
+  /ant:skill-create "tailwind"
+  /ant:skill-create "react native"
+  /ant:skill-create "kubernetes"
+```
+Stop here.
+
+### Step 1: Oracle Mini-Research
+
+Launch a focused research session on the topic (5 iterations max):
+1. Web search for best practices, common patterns, and gotchas
+2. Codebase scan for existing usage of the technology
+3. Compile findings into structured notes
+
+### Step 2: Wizard Questions
+
+Ask the user:
+1. What aspect to focus on? (provide 2-4 options based on findings)
+2. Experience level? (beginner / intermediate / advanced)
+3. Any specific rules or constraints? (free text)
+
+### Step 3: Generate SKILL.md
+
+Create the skill file with proper frontmatter and body:
+- name: derived from topic
+- description: "Use when working with {topic}"
+- type: domain
+- domains: inferred from research
+- agent_roles: [builder]
+- detect_files / detect_packages: inferred from research
+- Body: practical best-practices guide from research + wizard answers
+
+### 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`
+4. Show the generated skill to the user
+5. Ask if they want to adjust anything

package/.opencode/commands/ant/status.md

@@ -1,15 +1,22 @@
+<!-- Generated from .aether/commands/status.yaml - DO NOT EDIT DIRECTLY -->
 ---
 name: ant:status
 description: "📈🐜🏘️🐜📈 Show colony status at a glance"
 ---
 
+### Step -1: Normalize Arguments
+
+Run: `normalized_args=$(bash .aether/aether-utils.sh normalize-args "$@")`
+
+This ensures arguments work correctly in both Claude Code and OpenCode. Use `$normalized_args` throughout this command.
+
 You are the **Queen**. Show colony status.
 
 ## Instructions
 
 ### Step 0: Version Check (Non-blocking)
 
-Run using the Bash tool: `bash .aether/aether-utils.sh version-check 2>/dev/null || true`
+Run: `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.
 
@@ -51,7 +58,7 @@ If `version` field is missing, "1.0", or "2.0":
 
 ### Step 1.5: Load State and Show Resumption Context
 
-Run using Bash tool: `bash .aether/aether-utils.sh load-state`
+Run: `bash .aether/aether-utils.sh load-state`
 
 If successful and goal is not null:
 1. Extract current_phase from state
@@ -75,22 +82,44 @@ Run: `bash .aether/aether-utils.sh unload-state` to release lock.
 
 From state, extract:
 
+### Step 2.4: Survey Freshness (Advisory)
+
+Run:
+```bash
+survey_docs=$(ls -1 .aether/data/survey/*.md 2>/dev/null | wc -l | tr -d ' ')
+survey_latest=$(ls -t .aether/data/survey/*.md 2>/dev/null | head -1)
+if [[ -n "$survey_latest" ]]; then
+  now_epoch=$(date +%s)
+  modified_epoch=$(stat -f %m "$survey_latest" 2>/dev/null || stat -c %Y "$survey_latest" 2>/dev/null || echo 0)
+  survey_age_days=$(( (now_epoch - modified_epoch) / 86400 ))
+else
+  survey_age_days=-1
+fi
+echo "survey_docs=$survey_docs"
+echo "survey_age_days=$survey_age_days"
+```
+
+Interpretation:
+- If `survey_docs == 0`: `survey_status = "missing"`
+- If `survey_age_days > 14`: `survey_status = "stale"`
+- Otherwise: `survey_status = "fresh"`
+
 ### Step 2.5: Gather Dream Information
 
-Run using Bash tool: `ls -1 .aether/dreams/*.md 2>/dev/null | wc -l`
+Run: `ls -1 .aether/dreams/*.md 2>/dev/null | wc -l`
 
 Capture:
 - Dream count: number of .md files in .aether/dreams/
 - Latest dream: most recent file by name (files are timestamped: YYYY-MM-DD-HHMM.md)
 
-To get latest dream timestamp:
+To get latest dream timestamp, Run:
 ```bash
 ls -1 .aether/dreams/*.md 2>/dev/null | sort | tail -1 | sed 's/.*\/\([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\)-\([0-9]\{4\}\).*/\1 \2/'
 ```
 
 Format the timestamp as: YYYY-MM-DD HH:MM
 
-From state, extract:
+
 
 **Phase info:**
 - Current phase number: `current_phase`
@@ -117,6 +146,7 @@ Extract:
 **Escalation state:**
 Count escalated flags by checking for blocker flags with source "escalation":
 
+Run:
 ```bash
 escalated_count=$(bash .aether/aether-utils.sh flag-list --type blocker 2>/dev/null | jq '[.result.flags[] | select(.source == "escalation")] | length' 2>/dev/null || echo "0")
 echo "escalated_count=$escalated_count"
@@ -137,7 +167,7 @@ From `memory.instincts`:
 
 ### Step 2.6: Detect Milestone
 
-Run using Bash tool: `bash .aether/aether-utils.sh milestone-detect`
+Run: `bash .aether/aether-utils.sh milestone-detect`
 
 Extract from JSON result:
 - `milestone`: Current milestone name
@@ -145,6 +175,54 @@ Extract from JSON result:
 - `phases_completed`: Number of completed phases
 - `total_phases`: Total phases in plan
 
+### Step 2.8: Load Memory Health Metrics
+
+Run:
+```bash
+bash .aether/aether-utils.sh memory-metrics
+```
+
+Extract from JSON result:
+- wisdom.total
+- pending.total
+- recent_failures.count
+- last_activity.queen_md_updated
+- last_activity.learning_captured
+
+Format timestamps for display (YYYY-MM-DD HH:MM).
+
+### Step 2.7: Generate Progress Bars
+
+Calculate progress metrics and generate visual bars.
+
+Run:
+```bash
+current_phase=$(jq -r '.current_phase // 0' .aether/data/COLONY_STATE.json)
+total_phases=$(jq -r '.plan.phases | length' .aether/data/COLONY_STATE.json)
+
+# Calculate task progress in current phase
+if [[ "$current_phase" -gt 0 && "$current_phase" -le "$total_phases" ]]; then
+  phase_idx=$((current_phase - 1))
+  tasks_completed=$(jq -r ".plan.phases[$phase_idx].tasks // [] | map(select(.status == \"completed\")) | length" .aether/data/COLONY_STATE.json)
+  tasks_total=$(jq -r ".plan.phases[$phase_idx].tasks // [] | length" .aether/data/COLONY_STATE.json)
+  phase_name=$(jq -r ".plan.phases[$phase_idx].name // \"Unnamed\"" .aether/data/COLONY_STATE.json)
+else
+  tasks_completed=0
+  tasks_total=0
+  phase_name="No plan created"
+fi
+
+# Generate progress bars
+phase_bar=$(bash .aether/aether-utils.sh generate-progress-bar "$current_phase" "$total_phases" 20)
+task_bar=$(bash .aether/aether-utils.sh generate-progress-bar "$tasks_completed" "$tasks_total" 20)
+
+echo "phase_bar=$phase_bar"
+echo "task_bar=$task_bar"
+echo "phase_name=$phase_name"
+```
+
+Store `phase_bar`, `task_bar`, and `phase_name` values for display in Step 3.
+
 ### Step 3: Display
 
 Output format:
@@ -154,12 +232,13 @@ Output format:
       (o o)  AETHER COLONY
       | O |  Status Report
        `-`
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 👑 Goal: <goal (truncated to 60 chars)>
 
-📍 Phase <N>/<M>: <phase name>
-   Tasks: <completed>/<total> complete
+📍 Progress
+   Phase: [████████░░░░░░░░░░░░] <N>/<M> phases
+   Tasks: [████████████████░░░░] <completed>/<total> tasks in Phase <N>
 
 🎯 Focus: <focus_count> areas | 🚫 Avoid: <constraints_count> patterns
 🧠 Instincts: <total> learned (<high_confidence> strong)
@@ -168,19 +247,23 @@ Output format:
 ⚠️  Escalated: {escalated_count} task(s) awaiting your decision
 {end if}
 🏆 Milestone: <milestone> (<version>)
+
 💭 Dreams: <dream_count> recorded (latest: <latest_dream>)
+🗺️ Survey: <survey_docs> docs (<survey_age_days>d old, <fresh|stale|missing>)
+
+📚 Memory Health
+┌─────────────────┬────────┬─────────────────────────────┐
+│ Metric          │ Count  │ Last Updated                │
+├─────────────────┼────────┼─────────────────────────────┤
+│ Wisdom Entries  │ {wisdom_total:>6} │ {queen_updated}             │
+│ Pending Promos  │ {pending_total:>6} │ {learning_updated}          │
+│ Recent Failures │ {failures_count:>6} │ {last_failure}              │
+└─────────────────┴────────┴─────────────────────────────┘
 
 State: <state>
-Next:  <suggested_command>   <phase_context>
 ```
 
-**Phase context for Next line:** Include the phase name inline with the suggestion:
-- READY → `Next:  /ant:build 3   Phase 3: Add Authentication`
-- EXECUTING → `Next:  /ant:continue   Phase 3: Add Authentication`
-- PLANNING → `Next:  /ant:plan`
-- IDLE → `Next:  /ant:init`
-
-Look up the phase name from `plan.phases[current_phase].name` and append it.
+Use the `phase_bar` and `task_bar` values computed in Step 2.7 for the actual bar characters and counts.
 
 **If instincts exist, also show top 3:**
 ```
@@ -190,23 +273,35 @@ Look up the phase name from `plan.phases[current_phase].name` and append it.
    [0.7] 🐜 debugging: Trace to root cause first
 ```
 
-**Suggested command logic (use actual values, not templates):**
+**Dream display:**
+- If no dreams exist: `💭 Dreams: None recorded`
+- If dreams exist: `💭 Dreams: <count> recorded (latest: YYYY-MM-DD HH:MM)`
+
+**Memory Health display:**
+- If memory-metrics returns empty/null values, show:
+```
+📚 Memory Health
+   No memory data available. Colony wisdom will accumulate as you complete phases.
+```
 
-Calculate `next_phase = current_phase + 1` from state.
 
-Generate the suggested command based on colony state:
-- IDLE -> `/ant:init`
-- READY -> `/ant:build {next_phase}` (e.g., if current_phase is 2, output `/ant:build 3`)
-- EXECUTING -> `/ant:continue`
-- PLANNING -> `/ant:plan`
 
-The output must be a copy-pasteable command with real numbers, not placeholders.
 
-**Dream display:**
-- If no dreams exist: `💭 Dreams: None recorded`
-- If dreams exist: `💭 Dreams: <count> recorded (latest: YYYY-MM-DD HH:MM)`
 
 **Edge cases:**
-- No phases yet: "Phase 0/0: No plan created"
-- No tasks in phase: "Tasks: 0/0 complete"
+- No phases yet: show `[░░░░░░░░░░░░░░░░░░░░] 0/0 phases`
+- No tasks in phase: show `[░░░░░░░░░░░░░░░░░░░░] 0/0 tasks in Phase 0`
 - No constraints file: "Constraints: 0 focus, 0 avoid"
+
+**At the end of the output, generate the Next Up block:**
+
+Run:
+```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"
+```
+
+This auto-generates state-based recommendations (IDLE → init, READY → build, EXECUTING → continue, PLANNING → plan).