aether-colony 1.1.0

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

@@ -0,0 +1,155 @@
+---
+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/.claude/commands/ant/focus.md

@@ -0,0 +1,58 @@
+---
+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 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/.claude/commands/ant/help.md

@@ -0,0 +1,122 @@
+---
+name: 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.
+
+GETTING STARTED
+
+  /ant:init "<goal>"     Set colony intention and initialize
+  /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)
+
+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:flags             List active flags (blockers, issues, notes)
+  /ant:flag "<title>"    Create a flag (blocker, issue, or note)
+
+SESSION COMMANDS
+
+  /ant:pause-colony      Save state and create handoff document
+  /ant:resume-colony     Restore from pause (full state + context)
+  /ant:watch             Set up tmux session for live colony visibility
+
+COLONY LIFECYCLE
+
+  /ant:seal             Seal colony with Crowned Anthill milestone
+  /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
+
+TYPICAL WORKFLOW
+
+  1. /ant:init "Build a REST API with auth"
+  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)
+
+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, signals, events
+    activity.log        Timestamped worker activity
+    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

@@ -0,0 +1,137 @@
+---
+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"
+```