aether-colony 5.3.1 → 5.3.3

package/.aether/commands/claude/entomb.md

@@ -1,498 +0,0 @@
-<!-- Generated from .aether/commands/entomb.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:entomb
-description: "⚰️🐜⚰️ Entomb completed colony in chambers"
----
-
-You are the **Queen**. Archive the sealed colony to chambers.
-
-## Instructions
-
-Parse `$ARGUMENTS`:
-- If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
-- Otherwise: set `visual_mode = true`
-
-<failure_modes>
-### Archive Write Failure
-If writing to chambers/ archive fails partway:
-- Do NOT delete source data (the active colony) until archive is verified
-- Report what was archived vs. what failed
-- Recovery: the original colony data is intact -- user can retry
-
-### Seal Verification Failure
-If the colony was not properly sealed before entomb:
-- STOP -- do not archive an incomplete colony
-- Direct user to run /ant:seal first
-- This is a hard gate, not a suggestion
-
-### Chamber Naming Conflict
-If the target chamber directory already exists:
-- STOP -- do not overwrite an existing archive
-- Report the conflict
-- Options: (1) Use a different name, (2) Merge with existing, (3) Cancel
-</failure_modes>
-
-<success_criteria>
-Command is complete when:
-- Colony data is fully copied to chambers/ archive directory
-- Archive integrity is verified (all expected files present)
-- Active colony state is cleared only after archive verification
-- User sees confirmation with archive location
-</success_criteria>
-
-<read_only>
-Do not touch during entomb:
-- .aether/dreams/ (user notes -- not archived)
-- Source code files
-- .env* files
-- .claude/settings.json
-- .github/workflows/
-- Other chamber directories (only write to the new chamber)
-</read_only>
-
-### Step 0: Initialize Visual Mode (if enabled)
-
-If `visual_mode` is true:
-### Step 1: Read State
-
-Read `.aether/data/COLONY_STATE.json`.
-
-If file missing or `goal: null`:
-```
-No colony to entomb. Run /ant:init first.
-```
-Stop here.
-
-Extract: `goal`, `state`, `current_phase`, `plan.phases`, `milestone`, `version`, `initialized_at`, `memory.decisions`, `memory.phase_learnings`, `memory.instincts`.
-
-Read `colony_version` for display (default to 1 for backward compat with older colonies):
-```bash
-colony_version=$(jq -r '.colony_version // 1' .aether/data/COLONY_STATE.json 2>/dev/null || echo 1)
-[[ "$colony_version" =~ ^[0-9]+$ ]] || colony_version=1
-```
-
-### Step 2: Seal-First Enforcement
-
-Check `milestone` in COLONY_STATE.json.
-
-**If milestone != "Crowned Anthill":**
-```
-Colony has not been sealed.
-
-Current milestone: {milestone}
-Required: Crowned Anthill
-
-Run /ant:seal first to complete the sealing ceremony.
-```
-Stop here.
-
-**Belt-and-suspenders:** Also check `.aether/CROWNED-ANTHILL.md` exists. If milestone is Crowned Anthill but file is missing:
-```
-CROWNED-ANTHILL.md not found — seal may have been interrupted. Run /ant:seal again.
-```
-Stop here.
-
-### Step 3: User Confirmation
-
-Show what will be archived:
-```
-ENTOMB COLONY
-
-Goal: {goal}
-Version: v{colony_version}
-Milestone: Crowned Anthill
-Phases: {phases_completed} of {total_phases}
-
-This will:
-  - Archive ALL colony data to .aether/chambers/
-  - Copy CROWNED-ANTHILL.md, pheromones, dreams, session data
-  - Promote colony wisdom to QUEEN.md (cross-generational learning)
-  - Reset COLONY_STATE.json for a fresh start
-  - Clear session data
-
-This action is permanent. The archived colony can be browsed via /ant:tunnels.
-
-Entomb this colony? (yes/no)
-```
-
-Use `AskUserQuestion with yes/no options`.
-
-If not "yes":
-```
-Entombment cancelled. Colony remains active.
-```
-Stop here.
-
-### Step 3.25: Wisdom Approval
-
-Before archiving, review wisdom proposals accumulated during this colony's lifecycle.
-
-```bash
-# Check for pending proposals
-proposals=$(bash .aether/aether-utils.sh learning-check-promotion 2>/dev/null || echo '{"proposals":[]}')
-proposal_count=$(echo "$proposals" | jq '.proposals | length')
-
-if [[ "$proposal_count" -gt 0 ]]; then
-  echo ""
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo "   🧠 FINAL WISDOM REVIEW"
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo ""
-  echo "Review wisdom proposals before archiving this colony."
-  echo "Approved proposals will be promoted to QUEEN.md."
-  echo ""
-
-  # Run approval workflow (blocking)
-  bash .aether/aether-utils.sh learning-approve-proposals
-
-  echo ""
-  echo "Wisdom review complete. Proceeding with entombment..."
-  echo ""
-else
-  echo "No wisdom proposals to review."
-fi
-```
-
-### Step 3.5: Check XML Tools
-
-XML archiving is required for entombment. Check tool availability before proceeding.
-Uses `command -v xmllint` directly — consistent with seal.md's tool check.
-
-```bash
-if command -v xmllint >/dev/null 2>&1; then
-  xmllint_available=true
-else
-  xmllint_available=false
-fi
-```
-
-**If xmllint is NOT available:**
-
-Ask the user:
-```
-xmllint is not installed — XML archiving requires it.
-
-Install now?
-  - macOS: xcode-select --install (or brew install libxml2)
-  - Linux: apt-get install libxml2-utils
-
-Install xmllint? (yes/no)
-```
-
-Use AskUserQuestion with yes/no options.
-
-If yes:
-- On macOS: Run `xcode-select --install` or `brew install libxml2`
-- On Linux: Run `sudo apt-get install -y libxml2-utils`
-- After install attempt, re-check: `command -v xmllint >/dev/null 2>&1`
-- If still not available after install:
-  ```
-  xmllint installation failed. Cannot entomb without XML archiving.
-  Install xmllint manually and try again.
-  ```
-  Stop here.
-
-If no:
-```
-Entombment requires XML archiving. Install xmllint and try again.
-```
-Stop here.
-
-### Step 4: Ensure QUEEN.md Exists
-
-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_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"
-    fi
-  fi
-fi
-```
-
-### Step 5: Generate Chamber Name
-
-Date-first naming:
-```bash
-date_prefix=$(date -u +%Y-%m-%d)
-sanitized_goal=$(echo "$goal" | tr '[:upper:]' '[:lower:]' | tr -cs '[:alnum:]' '-' | sed 's/^-//;s/-$//' | cut -c1-40)
-chamber_name="${date_prefix}-${sanitized_goal}"
-```
-
-Collision handling:
-```bash
-counter=1
-original_name="$chamber_name"
-while [[ -d ".aether/chambers/$chamber_name" ]]; do
-  chamber_name="${original_name}-${counter}"
-  counter=$((counter + 1))
-done
-```
-
-### Step 6: Create Chamber
-
-Extract decisions and learnings as JSON arrays:
-```bash
-decisions_json=$(jq -c '.memory.decisions // []' .aether/data/COLONY_STATE.json)
-learnings_json=$(jq -c '.memory.phase_learnings // []' .aether/data/COLONY_STATE.json)
-phases_completed=$(jq '[.plan.phases[] | select(.status == "completed")] | length' .aether/data/COLONY_STATE.json)
-total_phases=$(jq '.plan.phases | length' .aether/data/COLONY_STATE.json)
-version=$(jq -r '.version // "3.0"' .aether/data/COLONY_STATE.json)
-```
-
-Create the chamber:
-```bash
-bash .aether/aether-utils.sh chamber-create \
-  ".aether/chambers/$chamber_name" \
-  ".aether/data/COLONY_STATE.json" \
-  "$goal" \
-  "$phases_completed" \
-  "$total_phases" \
-  "$milestone" \
-  "$version" \
-  "$decisions_json" \
-  "$learnings_json"
-```
-
-### Step 7: Archive Additional Files
-
-AFTER chamber-create succeeds, copy additional data files:
-```bash
-chamber_dir=".aether/chambers/$chamber_name"
-
-# Archive data files (if they exist)
-for f in pheromones.json session.json activity.log flags.json constraints.json spawn-tree.txt timing.log view-state.json; do
-  [[ -f ".aether/data/$f" ]] && cp ".aether/data/$f" "$chamber_dir/" 2>/dev/null || true
-done
-
-# Archive seal document (critical — this is the ceremony record)
-[[ -f ".aether/CROWNED-ANTHILL.md" ]] && cp ".aether/CROWNED-ANTHILL.md" "$chamber_dir/"
-
-# Archive HANDOFF.md if it exists
-[[ -f ".aether/HANDOFF.md" ]] && cp ".aether/HANDOFF.md" "$chamber_dir/"
-
-# Archive dreams directory (optional — may not exist)
-[[ -d ".aether/dreams" ]] && cp -r ".aether/dreams" "$chamber_dir/dreams" 2>/dev/null || true
-
-# Archive XML exchange files to chamber (per D-04, D-05)
-xml_archived=0
-for xml_file in .aether/exchange/*.xml; do
-  [[ -f "$xml_file" ]] && cp "$xml_file" "$chamber_dir/" && xml_archived=$((xml_archived + 1))
-done
-if [[ "$xml_archived" -gt 0 ]]; then
-  echo "XML Archive: ${xml_archived} exchange file(s) copied to chamber"
-fi
-```
-
-Do NOT copy: `.aether/data/backups/`, `.aether/data/locks/`, `.aether/data/midden/`, `.aether/data/survey/`.
-
-### Step 7.5: Export XML Archive (hard-stop)
-
-Export combined XML archive to the chamber. This is a HARD REQUIREMENT — entomb fails if XML export fails.
-
-```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_ok=$(echo "$xml_result" | jq -r '.ok // false' 2>/dev/null)
-
-if [[ "$xml_ok" != "true" ]]; then
-  # HARD STOP — remove the chamber and abort
-  rm -rf "$chamber_dir"
-  echo "XML archive export failed. Colony NOT entombed."
-  echo ""
-  echo "Error: $(echo "$xml_result" | jq -r '.error // "Unknown error"' 2>/dev/null)"
-  echo ""
-  echo "The chamber has been cleaned up. Fix the XML issue and try again."
-  # Do NOT proceed to state reset or any further steps
-fi
-```
-
-If xml_ok is true, store for display:
-```bash
-xml_pheromone_count=$(echo "$xml_result" | jq -r '.result.pheromone_count // 0' 2>/dev/null)
-xml_exchange_count=$(find .aether/exchange -maxdepth 1 -name "*.xml" 2>/dev/null | wc -l | tr -d ' ')
-xml_archive_line="XML Archive: colony-archive.xml (${xml_pheromone_count} signals) + ${xml_exchange_count} exchange file(s)"
-```
-
-**Critical behavior:** If XML export fails, entomb STOPS. The chamber directory is removed (cleanup). The colony state is NOT reset. The user sees a clear error and can retry after fixing the issue.
-
-### Step 8: Verify Chamber Integrity
-
-Run verification:
-```bash
-bash .aether/aether-utils.sh chamber-verify ".aether/chambers/$chamber_name"
-```
-
-If verification fails, display error and stop:
-```
-Chamber verification failed.
-
-Error: {verification_error}
-
-The colony has NOT been reset. Please check the chamber directory:
-.aether/chambers/{chamber_name}/
-```
-Stop here.
-
-### Step 9: Record in Eternal Memory
-
-Write colony summary to eternal memory:
-```bash
-bash .aether/aether-utils.sh eternal-init  # idempotent
-eternal_file="$HOME/.aether/eternal/memory.json"
-if [[ -f "$eternal_file" ]]; then
-  colony_entry=$(jq -n \
-    --arg goal "$goal" \
-    --arg milestone "$milestone" \
-    --arg sealed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    --arg chamber ".aether/chambers/$chamber_name" \
-    '{goal: $goal, milestone: $milestone, sealed_at: $sealed_at, chamber: $chamber}')
-  tmp_eternal="$(mktemp /tmp/aether-eternal.XXXXXX)"
-  jq --argjson colony_entry "$colony_entry" '.colonies = ((.colonies // []) + [$colony_entry])' "$eternal_file" > "$tmp_eternal" \
-    && mv "$tmp_eternal" "$eternal_file"
-fi
-```
-
-### Step 10: Reset Colony State
-
-Backup current state:
-```bash
-cp .aether/data/COLONY_STATE.json .aether/data/COLONY_STATE.json.bak
-```
-
-Reset state, clearing everything including promoted wisdom (already in QUEEN.md):
-```bash
-# Resolve jq template path (hub-first)
-jq_template=""
-for path in \
-  "$HOME/.aether/system/templates/colony-state-reset.jq.template" \
-  ".aether/templates/colony-state-reset.jq.template"; do
-  if [[ -f "$path" ]]; then
-    jq_template="$path"
-    break
-  fi
-done
-
-if [[ -z "$jq_template" ]]; then
-  echo "Template missing: colony-state-reset.jq.template. Run aether update to fix."
-  exit 1
-fi
-
-jq -f "$jq_template" .aether/data/COLONY_STATE.json.bak > .aether/data/COLONY_STATE.json
-```
-
-Verify reset succeeded:
-```bash
-new_goal=$(jq -r '.goal' .aether/data/COLONY_STATE.json)
-if [[ "$new_goal" != "null" ]]; then
-  # Restore from backup
-  mv .aether/data/COLONY_STATE.json.bak .aether/data/COLONY_STATE.json
-  echo "Error: State reset failed. Restored from backup."
-  exit 1
-fi
-```
-
-Remove backup after successful reset:
-```bash
-rm -f .aether/data/COLONY_STATE.json.bak
-```
-
-Clear session data:
-```bash
-rm -f .aether/data/session.json
-```
-
-Clean up seal document (it's now in the chamber):
-```bash
-rm -f .aether/CROWNED-ANTHILL.md
-```
-
-Clean up exchange XML files (now archived in chamber per D-06):
-```bash
-rm -f .aether/exchange/*.xml 2>/dev/null || true
-```
-
-### Step 11: Write HANDOFF.md
-
-Write handoff documenting the entombed colony:
-
-Resolve the handoff template path:
-  Check ~/.aether/system/templates/handoff.template.md first,
-  then .aether/templates/handoff.template.md.
-
-If no template found: output "Template missing: handoff.template.md. Run aether update to fix." and stop.
-
-Read the template file. Fill all {{PLACEHOLDER}} values:
-  - {{CHAMBER_NAME}} → chamber_name
-  - {{GOAL}} → goal
-  - {{PHASES_COMPLETED}} → phases completed count
-  - {{TOTAL_PHASES}} → total phases count
-  - {{MILESTONE}} → milestone
-  - {{ENTOMB_TIMESTAMP}} → current ISO-8601 UTC timestamp
-
-Remove the HTML comment lines at the top of the template.
-Write the result to .aether/HANDOFF.md using the Write tool.
-
-### Step 12: Display Result
-
-Display:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   C O L O N Y   E N T O M B E D
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Entombed v{colony_version}
-
-Goal: {goal}
-Phases: {completed} completed
-Milestone: {milestone}
-
-Chamber: .aether/chambers/{chamber_name}/
-{xml_archive_line}
-
-The colony rests. Its learnings live on in QUEEN.md.
-
-──────────────────────────────────────────────────
-🐜 Next Up
-──────────────────────────────────────────────────
-   /ant:lay-eggs            🥚 Start a new colony
-   /ant:tunnels             🗄️  Browse archived chambers
-```
-
-What would you like to do next?
-  1. /ant:lay-eggs "<new goal>"  — Start a new colony
-  2. /ant:tunnels                — Browse archived colonies
-  3. /clear                      — Clear context and continue
-
-Use AskUserQuestion with these three options.
-
-If option 1 selected: proceed to run /ant:lay-eggs flow
-If option 2 selected: run /ant:tunnels
-If option 3 selected: display "Run /ant:lay-eggs to begin anew after clearing"
-```
-
-### Edge Cases
-
-**Colony not sealed:**
-- Refuse with guidance to run /ant:seal first. This is the primary gate.
-
-**Chamber name collision:**
-- Automatically append counter to make unique.
-
-**Missing files during archive:**
-- Note in output but continue with available files. The `|| true` in the copy loop handles this.
-
-**State reset failure:**
-- Restore from backup, display error, do not claim success.
-
-**Empty phases array:**
-- Can entomb a colony that was initialized but had no phases planned (treat as 0 of 0 completed).
-
-**Missing CROWNED-ANTHILL.md:**
-- Refuse with guidance to run /ant:seal again.

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

@@ -1,57 +0,0 @@
-<!-- Generated from .aether/commands/export-signals.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:export-signals
-description: "Export colony pheromone signals to portable XML format"
----
-
-You are the **Queen**. Export colony pheromone signals to portable XML format.
-
-## Instructions
-
-The optional output path is: `$ARGUMENTS`
-
-### Step 1: Validate
-
-Read `.aether/data/COLONY_STATE.json`.
-If file missing or `goal: null` -> "No colony initialized. Run /ant:init first.", stop.
-
-Parse `$ARGUMENTS`:
-- If a path is provided, use it as the output path.
-- If empty, default to `.aether/exchange/pheromones.xml`.
-
-### Step 2: Export
-
-Run using the Bash tool with description "Exporting pheromone signals to XML...":
-```bash
-bash .aether/aether-utils.sh pheromone-export-xml "<output_path>"
-```
-
-Parse the returned JSON:
-- If `.ok` is `true`: extract `.result.path` and `.result.validated` (if present).
-- If `.ok` is `false`: check `.error` for details. If error mentions `xmllint` or `E_FEATURE_UNAVAILABLE`, display: "XML export requires xmllint. Install with: xcode-select --install (macOS) or apt-get install libxml2-utils (Linux)." Otherwise display the error message and stop.
-
-### Step 3: Confirm
-
-
-Output (3-5 lines, no banners):
-```
-Pheromone signals exported to XML
-  Path: <output_path>
-  Validated: <yes/no based on .result.validated>
-
-Share this file with another colony using /ant:import-signals.
-```
-
-
-
-
-### Step 4: 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/.aether/commands/claude/feedback.md

@@ -1,96 +0,0 @@
-<!-- Generated from .aether/commands/feedback.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:feedback
-description: "Emit FEEDBACK signal to provide guidance to colony"
----
-
-
-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.
-
-
-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.
-
-
-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. Generate ISO-8601 timestamp and append to `memory.instincts` in COLONY_STATE.json:
-```json
-{
-  "id": "instinct_<timestamp>",
-  "trigger": "<infer from feedback context>",
-  "action": "<the feedback guidance>",
-  "confidence": 0.7,
-  "domain": "<infer: testing|architecture|code-style|debugging|workflow>",
-  "source": "user_feedback",
-  "evidence": ["User feedback: <content>"],
-  "created_at": "<ISO-8601>",
-  "last_applied": null,
-  "applications": 0,
-  "successes": 0
-}
-```
-
-Write COLONY_STATE.json.
-
-### Step 2.5: Update Context Document
-
-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
-```
-
-### Step 3: Get Active Counts
-
-Run using the Bash tool with description "Counting active signals...":
-```bash
-bash .aether/aether-utils.sh pheromone-count
-```
-
-### Step 4: Confirm
-
-Output (4 lines, no banners):
-```
-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
-
-Instinct created: [0.7] <domain>: <action summary>
-```
-
-
-
-
-### Step 5: 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"
-```
-