aether-colony 5.3.2 → 5.4.0

package/.aether/commands/claude/flag.md

@@ -1,151 +0,0 @@
-<!-- Generated from .aether/commands/flag.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:flag
-description: "🚩🐜📋🐜🚩 Create a project-specific flag (blocker, issue, or note)"
----
-
-You are the **Queen**. Create a project-specific flag.
-
-## Instructions
-
-The flag is: `$ARGUMENTS`
-
-### Step 1: Parse Arguments
-
-Parse `$ARGUMENTS` for:
-- `--type` or `-t`: blocker | issue | note (default: issue)
-- `--phase` or `-p`: phase number (optional)
-- Remaining text: the flag title/description
-
-Examples:
-- `/ant:flag "Build fails on auth module"` → issue type
-- `/ant:flag --type blocker "API rate limit hit"` → blocker type
-- `/ant:flag -t note -p 3 "Consider refactoring later"` → note for phase 3
-
-If `$ARGUMENTS` is empty:
-```
-Usage: /ant:flag "<description>" [--type blocker|issue|note] [--phase N]
-
-Types:
-  blocker  Critical issue that blocks phase advancement
-  issue    Warning that should be addressed (default)
-  note     Informational for future reference
-
-Examples:
-  /ant:flag "Build fails on auth"
-  /ant:flag --type blocker "Tests hanging"
-  /ant:flag -t note "Consider refactoring"
-```
-Stop here.
-
-### Step 2: Validate Colony
-
-Read `.aether/data/COLONY_STATE.json`.
-If file missing or `goal: null`:
-```
-No colony initialized. Run /ant:init first.
-```
-Stop here.
-
-### Step 3: Create Flag
-
-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}
-```
-
-Parse the result for the flag ID.
-
-### Step 4: Confirm
-
-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
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-
-```
-
-**For issue:**
-```
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🚩🐜📋🐜🚩  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
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-
-```
-
-Then output based on flag type:
-
-**For blocker:**
-```
-🚫 BLOCKER flag created
-
-   "{title}"
-
-   ID: {flag_id}
-   Phase: {phase or "all"}
-
-⚠️  This will BLOCK phase advancement until resolved.
-   Use /ant:flags to view all flags.
-```
-
-**For issue:**
-```
-⚠️  ISSUE flag created
-
-   "{title}"
-
-   ID: {flag_id}
-   Phase: {phase or "all"}
-
-   Use /ant:flags to view all flags.
-```
-
-**For note:**
-```
-📝 NOTE flag created
-
-   "{title}"
-
-   ID: {flag_id}
-   Phase: {phase or "all"}
-
-   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
-
-1. **Created** - Flag is active and visible
-2. **Acknowledged** - Flag noted but continuing (issues/notes only)
-3. **Resolved** - Flag closed with resolution message
-4. **Auto-resolved** - Blockers auto-resolve on build_pass
-
-Blockers CANNOT be acknowledged - they must be resolved before phase advancement.

package/.aether/commands/claude/flags.md

@@ -1,169 +0,0 @@
-<!-- Generated from .aether/commands/flags.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:flags
-description: "📋🐜🚩🐜📋 List project flags (blockers, issues, notes)"
----
-
-You are the **Queen**. Display project flags.
-
-## Instructions
-
-Arguments: `$ARGUMENTS`
-
-### Step 1: Parse Arguments
-
-Parse `$ARGUMENTS` for:
-- `--all` or `-a`: Show resolved flags too
-- `--type` or `-t`: Filter by type (blocker|issue|note)
-- `--phase` or `-p`: Filter by phase number
-- `--resolve` or `-r`: Resolve a specific flag ID
-- `--ack` or `-k`: Acknowledge a specific flag ID
-
-Examples:
-- `/ant:flags` → Show active flags
-- `/ant:flags --all` → Include resolved flags
-- `/ant:flags -t blocker` → Show only blockers
-- `/ant:flags --resolve flag_123 "Fixed by commit abc"` → Resolve a flag
-- `/ant:flags --ack flag_456` → Acknowledge an issue
-
-### Step 2: Handle Resolution/Acknowledgment
-
-
-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}"
-```
-Output:
-```
-✅ Flag resolved: {flag_id}
-
-   Resolution: {message}
-```
-Stop here.
-
-
-If `--ack` was provided, run using the Bash tool with description "Acknowledging colony flag...":
-
-
-```bash
-bash .aether/aether-utils.sh flag-acknowledge "{flag_id}"
-```
-Output:
-```
-👁️ Flag acknowledged: {flag_id}
-
-   Flag noted. Continuing with work.
-```
-Stop here.
-
-### Step 3: List Flags
-
-
-Run using the Bash tool with description "Loading colony flags...":
-
-
-```bash
-bash .aether/aether-utils.sh flag-list {options}
-```
-
-Parse result for flags array.
-
-### Step 4: Display
-
-Output header:
-
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📋🐜🚩🐜📋  P R O J E C T   F L A G S
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-
-
-If no flags:
-```
-       .-.
-      (o o)  AETHER COLONY
-      | O |  Flags
-       `-"
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-✨ No active flags! Colony is clear.
-
-{if --all was used: "No resolved flags either."}
-```
-
-If flags exist:
-```
-       .-.
-      (o o)  AETHER COLONY
-      | O |  Flags
-       `-"
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-{for each flag, grouped by type:}
-
-🚫 BLOCKERS ({count})
-   {flag_id}: {title}
-   Phase: {phase or "all"} | Created: {date}
-   └─ {description preview}
-
-⚠️  ISSUES ({count})
-   {flag_id}: {title} {if acknowledged: "[ACK]"}
-   Phase: {phase or "all"} | Created: {date}
-   └─ {description preview}
-
-📝 NOTES ({count})
-   {flag_id}: {title}
-   Phase: {phase or "all"} | Created: {date}
-   └─ {description preview}
-
-{if --all and resolved flags exist:}
-
-✅ RESOLVED ({count})
-   {flag_id}: {title}
-   Resolved: {date} | {resolution}
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Summary: {blockers} blockers | {issues} issues | {notes} notes
-
-{if blockers > 0:}
-⚠️  Blockers must be resolved before /ant:continue
-
-Commands:
-  /ant:flags --resolve {id} "message"   Resolve a flag
-  /ant:flags --ack {id}                 Acknowledge an issue
-  /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
-
-**Resolve a flag:**
-```
-/ant:flags --resolve flag_123456 "Fixed in commit abc123"
-```
-
-**Acknowledge an issue:**
-```
-/ant:flags --ack flag_789012
-```
-
-**Create a new flag:**
-```
-/ant:flag --type blocker "Critical issue here"
-```

package/.aether/commands/claude/focus.md

@@ -1,76 +0,0 @@
-<!-- Generated from .aether/commands/focus.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:focus
-description: "Emit FOCUS signal to guide colony attention"
----
-
-
-You are the **Queen**. Emit a FOCUS pheromone signal.
-
-
-
-## Instructions
-
-The focus area is: `$ARGUMENTS`
-
-### Step 1: Validate
-
-If `$ARGUMENTS` empty -> show usage: `/ant:focus <area>`, stop.
-If content > 500 chars -> "Focus 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 focus area.
-
-
-### Step 2: Write Signal
-
-Read `.aether/data/COLONY_STATE.json`.
-If `goal: null` -> "No colony initialized.", stop.
-
-
-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>
-```
-
-Parse the returned JSON for the signal ID.
-
-### 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 focus "<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 (3-4 lines, no banners):
-```
-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
-```
-
-
-
-
-### 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"
-```
-

package/.aether/commands/claude/help.md

@@ -1,154 +0,0 @@
-<!-- Generated from .aether/commands/help.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:help
-description: "Aether Colony - command reference and system overview"
----
-
-You are the **Queen Ant Colony**. Display the system overview and available commands.
-
-## Instructions
-
-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.
-
-SETUP & GETTING STARTED
-
-  /ant:lay-eggs          Set up Aether in this repo (one-time, creates .aether/)
-  /ant:init "<goal>"     Start a colony with a goal
-  /ant:colonize          Analyze existing codebase (optional)
-  /ant:plan              Generate project plan
-  /ant:build <phase>     Execute a phase (spawns parallel workers)
-  /ant:continue          Verify work, extract learnings, advance
-
-PHEROMONE COMMANDS
-
-  /ant:focus "<area>"    Guide colony attention (priority: normal, expires: phase end)
-  /ant:redirect "<pat>"  Warn away from pattern (priority: high, expires: phase end)
-  /ant:feedback "<msg>"  Adjust behavior (priority: low, expires: phase end)
-  /ant:pheromones        View and manage active pheromone signals
-  /ant:export-signals [path]  Export pheromone signals to portable XML
-  /ant:import-signals <file> [colony]  Import signals from another colony's XML
-
-STATUS & UPDATES
-
-  /ant:status            Colony dashboard — goal, phase, instincts, flags
-  /ant:update            Update system files from global hub (~/.aether/)
-  /ant:phase [N|list]    View phase details or list all phases
-  /ant:insert-phase      Insert a corrective phase after current phase
-  /ant:flags             List active flags (blockers, issues, notes)
-  /ant:flag "<title>"    Create a flag (blocker, issue, or note)
-
-  /ant:memory-details    Show detailed colony memory — wisdom, promotions, failures
-  /ant:maturity          View colony maturity journey and milestone progress
-
-
-SESSION COMMANDS
-
-  /ant:pause-colony      Save state and create handoff document
-  /ant:resume-colony     Restore from pause (full state + context)
-
-  /ant:resume            Quick session restore (memory health + next steps)
-
-  /ant:watch             Set up tmux session for live colony visibility
-
-COLONY LIFECYCLE
-
-  /ant:seal             Seal colony with Crowned Anthill milestone
-  /ant:entomb           Archive completed colony into chambers
-  /ant:history          Browse colony event history
-
-ADVANCED
-
-  /ant:swarm "<bug>"     Parallel scouts investigate stubborn bugs
-  /ant:organize          Codebase hygiene report (stale files, dead code)
-  /ant:council           Convene council for intent clarification
-  /ant:dream             Philosophical wanderer — observes and writes wisdom
-  /ant:interpret         Review dreams — validate against codebase, discuss action
-  /ant:chaos             🎲 Resilience testing — adversarial probing of the codebase
-  /ant:archaeology       🏺 Git history analysis — excavate patterns from commit history
-  /ant:tunnels           Browse archived colonies and compare chambers
-
-TYPICAL WORKFLOW
-
-  First time in a repo:
-  0. /ant:lay-eggs                           (set up Aether in this repo)
-
-  Starting a colony:
-  1. /ant:init "Build a REST API with auth"  (start colony with a goal)
-  2. /ant:colonize                           (if existing code)
-  3. /ant:plan                               (generates phases)
-  4. /ant:focus "security"                   (optional guidance)
-  5. /ant:build 1                            (workers execute phase 1)
-  6. /ant:continue                           (verify, learn, advance)
-  7. /ant:build 2                            (repeat until complete)
-
-  After /clear or session break:
-  8. /ant:resume-colony                      (restore full context)
-  9. /ant:status                             (see where you left off)
-
-  After completing a colony:
-  10. /ant:seal                              (mark as complete)
-  11. /ant:entomb                            (archive to chambers)
-  12. /ant:init "next project goal"          (start fresh colony)
-
-WORKER CASTES
-
-  👑 Queen        — orchestrates, spawns workers, synthesizes results
-  🗺️ colonizer    — explores codebase, maps structure
-  📋 route-setter — plans phases, breaks down goals
-  🔨 builder      — implements code, runs commands
-  👁️ watcher      — validates, tests, independent quality checks
-  🔍 scout        — researches, gathers information
-  🏛️ architect    — synthesizes knowledge, extracts patterns
-  🎲 chaos        — resilience tester, adversarial probing
-  🏺 archaeologist — git history analyst, excavates commit patterns
-
-HOW IT WORKS
-
-  Colony Lifecycle:
-
-    INIT → PLAN → BUILD → CONTINUE → BUILD → ... → COMPLETE
-
-
-
-  Workers spawn sub-workers autonomously (max depth 3).
-  Builders receive colony knowledge (instincts, learnings, error patterns).
-  Watchers independently verify work — builders never self-approve.
-  Phase boundaries are control points: emergence within, gates between.
-
-  Pheromone System:
-    Signals expire after their TTL. Workers sense active signals
-    and adjust behavior. FOCUS attracts, REDIRECT repels, FEEDBACK calibrates.
-
-  Colony Memory:
-    Instincts — learned patterns with confidence scores (validated through use)
-    Learnings — per-phase observations (hypothesis → validated → disproven)
-    Graveyards — markers on files where workers previously failed
-
-  State Files (.aether/data/):
-    COLONY_STATE.json   Goal, phases, tasks, memory, events
-    activity.log        Timestamped worker activity
-    spawn-tree.txt      Worker spawn hierarchy
-    pheromones.json     Active FOCUS/REDIRECT/FEEDBACK signals
-    constraints.json    Compatibility mirror for focus/redirect data
-
-```
-
-
-### Next Up
-
-Generate the state-based Next Up block by Run 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/history.md

@@ -1,140 +0,0 @@
-<!-- Generated from .aether/commands/history.yaml - DO NOT EDIT DIRECTLY -->
----
-name: ant:history
-description: "📜🐜📜 Show colony event history"
----
-
-You are the **Queen**. Show colony history.
-
-## Instructions
-
-### Step 1: Read State
-
-Read `.aether/data/COLONY_STATE.json`.
-
-If file missing or `goal: null`:
-```
-No colony initialized. Run /ant:init first.
-```
-Stop here.
-
-### Step 2: Parse Events
-
-Extract the `events` array from the state.
-
-Each event is in format: `timestamp|type|source|description`
-
-Parse each event into components:
-- timestamp: before first `|`
-- type: between first and second `|`
-- source: between second and third `|`
-- description: after third `|`
-
-### Step 3: Parse Filter Arguments
-
-Parse optional filter arguments:
-
-**Event Type Filter:**
-- `--type TYPE` or `-t TYPE`: Filter by event type
-- Multiple types can be specified (comma-separated)
-- Valid types: `colony_initialized`, `phase_started`, `phase_advanced`, `plan_generated`, `milestone_reached`, `state_upgraded`
-
-**Date Range Filter:**
-- `--since DATE`: Show events since DATE
-  - ISO format: `2026-02-13`, `2026-02-13T14:30:00`
-  - Relative: `1d` (1 day ago), `2h` (2 hours ago), `30m` (30 minutes ago)
-- `--until DATE`: Show events until DATE
-  - Same format options as `--since`
-
-### Step 4: Apply Limit
-
-Parse optional `--limit N` argument (default: 10).
-
-If `--limit` is provided, only show N events.
-
-### Step 5: Filter Events
-
-Apply filters to the events array:
-
-**Type Filtering:**
-- If `--type` is provided, split by comma to get list of types
-- Filter events to only include those where type matches any of the specified types (case-insensitive)
-
-**Date Range Filtering:**
-- For `--since`: Parse the date value
-  - If relative (e.g., "1d", "2h", "30m"), calculate timestamp by subtracting from current time
-  - If ISO format, parse directly
-  - Filter events with timestamp >= since date
-- For `--until`: Same parsing logic
-  - Filter events with timestamp <= until date
-
-**Track Active Filters:**
-- Record which filters are active for display indicator
-
-### Step 6: Sort and Display
-
-Sort events in reverse chronological order (most recent first).
-
-If events array is empty:
-```
-No colony events recorded yet.
-```
-
-**Filter Indicators:**
-- If any filters are active, show at the top:
-  - Type filter: `Filters: type=<TYPE>[,<TYPE>...]`
-  - Since filter: `Filters: since=<DATE>`
-  - Until filter: `Filters: until=<DATE>`
-  - Multiple filters: Combine on same line (e.g., `Filters: type=phase_started,phase_advanced since=1d`)
-- Show filtered count: "Showing X of Y events (filtered from Z total)"
-
-Otherwise, display in format:
-```
-━━━ Colony History (most recent first) ━━━
-
-[TIMESTAMP] [TYPE] from [SOURCE]
-  Description: [description]
-
-[TIMESTAMP] [TYPE] from [SOURCE]
-  Description: [description]
-
-... (up to limit)
-```
-
-**Format:**
-- Timestamp: Show in readable format (e.g., "2026-02-13 14:30:00")
-- Type: Uppercase event type
-- Source: Italics for source
-- Description: Plain text
-
-**Event type icons:**
-- `colony_initialized`: 🏠
-- `phase_started`: 🚀
-- `phase_advanced`: ➡️
-- `plan_generated`: 📋
-- `milestone_reached`: 🏆
-- `state_upgraded`: 🔄
-- `default`: 📌
-
-**Limit display:**
-- If filtering is active, show: "Showing X of Y events (filtered from Z total)"
-- If only limit is applied (no filters), show: "Showing X of Y events"
-
-### Step 7: Display Summary
-
-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"
-```
-