aether-colony 1.1.9 → 1.1.11

package/.aether/aether-utils.sh

@@ -464,6 +464,10 @@ EOF
       elif [[ "$c_type" == "focus" ]]; then
         sed -i.bak "/^## 💭 Active Pheromones/,/^## /{ /^| Signal |/a\\
 | FOCUS | $c_message | normal |
+}" "$ctx_file" && rm -f "$ctx_file.bak"
+      elif [[ "$c_type" == "feedback" ]]; then
+        sed -i.bak "/^## 💭 Active Pheromones/,/^## /{ /^| Signal |/a\\
+| FEEDBACK | $c_message | low |
 }" "$ctx_file" && rm -f "$ctx_file.bak"
       fi
 
@@ -499,6 +503,14 @@ EOF
       ' "$ctx_file" > "$ctx_tmp"
 
       mv "$ctx_tmp" "$ctx_file"
+
+      # Auto-emit FEEDBACK pheromone for the decision so builders see it
+      bash "$0" pheromone-write FEEDBACK "Decision: $decision — $rationale" \
+        --strength 0.65 \
+        --source "system:decision" \
+        --reason "Auto-emitted from architectural decision" \
+        --ttl "30d" 2>/dev/null || true
+
       json_ok "{\"updated\":true,\"action\":\"decision\"}"
       ;;
 
@@ -5274,6 +5286,14 @@ $updated_meta
 
     promote_result=$(bash "$0" queen-promote "$wisdom_type" "$content" "$colony_name" 2>/dev/null || echo '{}')
     if echo "$promote_result" | jq -e '.ok == true' >/dev/null 2>&1; then
+      # Also create an instinct from the promoted learning
+      bash "$0" instinct-create \
+        --trigger "When working on $wisdom_type patterns" \
+        --action "$content" \
+        --confidence 0.6 \
+        --domain "$wisdom_type" \
+        --source "promoted_from_learning" \
+        --evidence "Auto-promoted after $observation_count observations" 2>/dev/null || true
       json_ok "{\"promoted\":true,\"mode\":\"auto\",\"policy_threshold\":$policy_threshold,\"observation_count\":$observation_count,\"colony_count\":$colony_count,\"event_type\":\"$event_type\"}"
     else
       promote_msg=$(echo "$promote_result" | jq -r '.error.message // "promotion_failed"' 2>/dev/null || echo "promotion_failed")
@@ -7132,6 +7152,123 @@ $updated_meta
     fi
     ;;
 
+  instinct-create)
+    # Create or update an instinct in COLONY_STATE.json
+    # Usage: instinct-create --trigger "when X" --action "do Y" --confidence 0.5 --domain "architecture" --source "phase-3" --evidence "observation"
+    # Deduplicates: if trigger+action matches existing instinct, boosts confidence instead
+    # Cap: max 30 instincts, evicts lowest confidence when exceeded
+
+    ic_trigger=""
+    ic_action=""
+    ic_confidence="0.5"
+    ic_domain="workflow"
+    ic_source=""
+    ic_evidence=""
+
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --trigger)    ic_trigger="$2"; shift 2 ;;
+        --action)     ic_action="$2"; shift 2 ;;
+        --confidence) ic_confidence="$2"; shift 2 ;;
+        --domain)     ic_domain="$2"; shift 2 ;;
+        --source)     ic_source="$2"; shift 2 ;;
+        --evidence)   ic_evidence="$2"; shift 2 ;;
+        *) shift ;;
+      esac
+    done
+
+    [[ -z "$ic_trigger" ]] && json_err "$E_VALIDATION_FAILED" "instinct-create requires --trigger"
+    [[ -z "$ic_action" ]] && json_err "$E_VALIDATION_FAILED" "instinct-create requires --action"
+
+    ic_state_file="$DATA_DIR/COLONY_STATE.json"
+    [[ -f "$ic_state_file" ]] || json_err "$E_FILE_NOT_FOUND" "COLONY_STATE.json not found. Run /ant:init first."
+
+    # Validate confidence range
+    if ! [[ "$ic_confidence" =~ ^(0(\.[0-9]+)?|1(\.0+)?)$ ]]; then
+      ic_confidence="0.5"
+    fi
+
+    ic_now=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    ic_epoch=$(date +%s)
+    ic_id="instinct_${ic_epoch}"
+
+    # Check for existing instinct with matching trigger+action (fuzzy: exact substring match)
+    ic_existing=$(jq -c --arg trigger "$ic_trigger" --arg action "$ic_action" '
+      [(.memory.instincts // [])[] | select(.trigger == $trigger and .action == $action)] | first // null
+    ' "$ic_state_file" 2>/dev/null)
+
+    if [[ -n "$ic_existing" && "$ic_existing" != "null" ]]; then
+      # Update existing: boost confidence by +0.1, increment applications
+      ic_updated=$(jq --arg trigger "$ic_trigger" --arg action "$ic_action" --arg now "$ic_now" '
+        .memory.instincts = [
+          (.memory.instincts // [])[] |
+          if .trigger == $trigger and .action == $action then
+            .confidence = ([(.confidence + 0.1), 1.0] | min) |
+            .applications = ((.applications // 0) + 1) |
+            .last_applied = $now
+          else
+            .
+          end
+        ]
+      ' "$ic_state_file" 2>/dev/null)
+
+      if [[ -n "$ic_updated" ]]; then
+        atomic_write "$ic_state_file" "$ic_updated"
+        ic_new_conf=$(echo "$ic_updated" | jq --arg trigger "$ic_trigger" --arg action "$ic_action" '
+          [(.memory.instincts // [])[] | select(.trigger == $trigger and .action == $action)] | first | .confidence // 0
+        ' 2>/dev/null)
+        json_ok "{\"instinct_id\":\"existing\",\"action\":\"updated\",\"confidence\":$ic_new_conf}"
+      else
+        json_err "$E_INTERNAL" "Failed to update existing instinct"
+      fi
+    else
+      # Create new instinct
+      ic_new_instinct=$(jq -n \
+        --arg id "$ic_id" \
+        --arg trigger "$ic_trigger" \
+        --arg action "$ic_action" \
+        --argjson confidence "$ic_confidence" \
+        --arg status "hypothesis" \
+        --arg domain "$ic_domain" \
+        --arg source "$ic_source" \
+        --arg evidence "$ic_evidence" \
+        --arg created_at "$ic_now" \
+        '{
+          id: $id,
+          trigger: $trigger,
+          action: $action,
+          confidence: $confidence,
+          status: $status,
+          domain: $domain,
+          source: $source,
+          evidence: [$evidence],
+          tested: false,
+          created_at: $created_at,
+          last_applied: null,
+          applications: 0,
+          successes: 0,
+          failures: 0
+        }')
+
+      # Add instinct, enforce 30-instinct cap (evict lowest confidence)
+      ic_updated=$(jq --argjson new_instinct "$ic_new_instinct" '
+        .memory.instincts = (
+          ((.memory.instincts // []) + [$new_instinct])
+          | sort_by(-.confidence)
+          | .[:30]
+        )
+      ' "$ic_state_file" 2>/dev/null)
+
+      if [[ -n "$ic_updated" ]]; then
+        atomic_write "$ic_state_file" "$ic_updated"
+        json_ok "{\"instinct_id\":\"$ic_id\",\"action\":\"created\",\"confidence\":$ic_confidence}"
+      else
+        json_err "$E_INTERNAL" "Failed to create instinct"
+      fi
+    fi
+    exit 0
+    ;;
+
   pheromone-prime)
     # Combine active pheromone signals and learned instincts into a prompt-ready block
     # Usage: pheromone-prime [--compact] [--max-signals N] [--max-instincts N]
@@ -9183,10 +9320,10 @@ EOF
       exit 0
     fi
 
-    # Extract failures, sort by created_at descending, limit results
+    # Extract failures from .entries[], sort by timestamp descending, limit results
     result=$(jq --argjson limit "$limit" '{
-      "count": ([.signals[]? | select(.type == "failure")] | length),
-      "failures": ([.signals[]? | select(.type == "failure")] | sort_by(.created_at) | reverse | [.[:$limit][] | {created_at, source, context, content: .content.text}])
+      "count": ([.entries[]?] | length),
+      "failures": ([.entries[]?] | sort_by(.timestamp) | reverse | .[:$limit] | [.[] | {timestamp, category, source, message}])
     }' "$midden_file" 2>/dev/null)
 
     if [[ -z "$result" ]]; then

package/.aether/docs/command-playbooks/build-wave.md

@@ -259,6 +259,19 @@ Run using the Bash tool with description "Marking build start...": `bash .aether
 Before dispatching each worker, refresh colony context so new pheromones/memory are visible:
 Run using the Bash tool with description "Refreshing colony context...": `prime_result=$(bash .aether/aether-utils.sh colony-prime --compact 2>/dev/null)` and update `prompt_section` from `prime_result.result.prompt_section`.
 
+**PER WAVE:** Query midden for recent failures to inject into builder context:
+Run using the Bash tool with description "Checking midden for recent failures...":
+`midden_result=$(bash .aether/aether-utils.sh midden-recent-failures 5 2>/dev/null || echo '{"count":0,"failures":[]}')`
+
+Parse `midden_result`. If `count > 0`, format as `midden_context`:
+```
+**Previous Failures (from colony midden):**
+- [{category}] {message} (source: {source}, {timestamp})
+...
+```
+
+If `count == 0`, set `midden_context` to empty.
+
 > **Platform note**: In Claude Code, use `Task tool with subagent_type`. In OpenCode, use the equivalent agent spawning mechanism for your platform (e.g., invoke the agent definition from `.opencode/agents/`).
 
 For each Wave 1 task, use Task tool with `subagent_type="aether-builder"`, include `description: "🔨 Builder {Ant-Name}: {task_description}"` (DO NOT use run_in_background - multiple Task calls in a single message run in parallel and block until complete):
@@ -289,6 +302,12 @@ Goal: "{colony_goal}"
 
 { grave_context if exists }
 
+{ midden_context if exists }
+
+**Midden Context (if provided):**
+- These are previous failures from this colony. Avoid repeating these patterns.
+- If a failure is related to your task, take extra care or try a different approach.
+
 **External Integration Context (if provided by Ambassador):**
 If integration_plan is provided above, you MUST:
 1. Follow the implementation_steps in order

package/.aether/docs/command-playbooks/continue-advance.md

@@ -79,50 +79,28 @@ Update COLONY_STATE.json:
 
    Memory capture also auto-emits a FEEDBACK pheromone and attempts auto-promotion when recurrence policy is met.
 
-3. **Extract instincts from patterns:**
+3. **Extract instincts from phase patterns:**
 
-   Read activity.log for patterns from this phase's build.
+   Review the completed phase for repeating patterns. For each pattern observed:
 
-   For each pattern observed (success, error_resolution, user_feedback):
-
-   **If pattern matches existing instinct:**
-   - Update confidence: +0.1 for success outcome, -0.1 for failure
-   - Increment applications count
-   - Update last_applied timestamp
-
-   **If new pattern:**
-   - Create new instinct with initial confidence:
-     - success: 0.4
-     - error_resolution: 0.5
-     - user_feedback: 0.7
-
-   Append to `memory.instincts`:
-   ```json
-   {
-     "id": "instinct_<unix_timestamp>",
-     "trigger": "<when X>",
-     "action": "<do Y>",
-     "confidence": 0.5,
-     "status": "hypothesis",
-     "domain": "<testing|architecture|code-style|debugging|workflow>",
-     "source": "phase-<id>",
-     "evidence": ["<specific observation that led to this>"],
-     "tested": false,
-     "created_at": "<ISO-8601>",
-     "last_applied": null,
-     "applications": 0,
-     "successes": 0,
-     "failures": 0
-   }
+   Run using the Bash tool with description "Creating instinct from pattern...":
+   ```bash
+   bash .aether/aether-utils.sh instinct-create \
+     --trigger "<when this situation arises>" \
+     --action "<what worked or should be done>" \
+     --confidence <0.4-0.7 based on evidence> \
+     --domain "<testing|architecture|code-style|debugging|workflow>" \
+     --source "phase-{id}" \
+     --evidence "<specific observation>" 2>/dev/null || true
    ```
 
-   **Instinct confidence updates:**
-   - Success when applied: +0.1, increment `successes`
-   - Failure when applied: -0.15, increment `failures`
-   - If `failures` >= 2 and `successes` == 0: mark `status: "disproven"`
-   - If `successes` >= 2 and tested: mark `status: "validated"`
+   Confidence guidelines:
+   - 0.4: success pattern (worked once)
+   - 0.5: error_resolution (fixed a problem)
+   - 0.7: user_feedback (explicit guidance)
 
-   Cap: Keep max 30 instincts (remove lowest confidence when exceeded).
+   If pattern matches existing instinct, confidence will be boosted automatically.
+   Cap: max 30 instincts enforced by `instinct-create` (lowest confidence evicted).
 
 4. **Advance state:**
    - Set `current_phase` to next phase number

package/.aether/rules/aether-colony.md

@@ -19,10 +19,11 @@ This only applies to genuinely new conversations, not after /clear.
 
 ## Available Commands
 
-### Getting Started
+### Setup & Getting Started
 | Command | Purpose |
 |---------|---------|
-| `/ant:init "<goal>"` | Set colony intention and initialize |
+| `/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 |
 | `/ant:plan` | Generate project phases |
 | `/ant:build <phase>` | Execute a phase with parallel workers |
@@ -75,19 +76,28 @@ This only applies to genuinely new conversations, not after /clear.
 ## Typical Workflow
 
 ```
-/ant:init "Build feature X"    → Set colony goal
-/ant:colonize                  → Understand existing code (optional)
-/ant:plan                      → Generate phases
-/ant:focus "security"          → Steer attention (optional)
-/ant:build 1                   → Execute phase 1
-/ant:continue                  → Verify, learn, advance
-/ant:build 2                   → Execute phase 2
-...repeat until complete...
-/ant:seal                      → Seal completed colony
+First time in a repo:
+0. /ant:lay-eggs                           (set up Aether in this repo)
+
+Starting a colony:
+1. /ant:init "Build feature X"             (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)
 ```
 
-After `/clear` or session break: `/ant:resume-colony` to restore context.
-
 ## Worker Castes
 
 Workers are assigned to castes based on task type:

package/.claude/commands/ant/feedback.md

@@ -48,6 +48,13 @@ User feedback is high-value learning. Generate ISO-8601 timestamp and append to
 
 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...":

package/.claude/commands/ant/focus.md

@@ -30,6 +30,13 @@ bash .aether/aether-utils.sh pheromone-write FOCUS "<content>" --strength 0.8 --
 
 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...":

package/.claude/commands/ant/help.md

@@ -16,9 +16,10 @@ Output the following:
   A multi-agent system built on ant colony intelligence.
   Workers self-organize via pheromone signals. You guide with intention.
 
-GETTING STARTED
+SETUP & GETTING STARTED
 
-  /ant:init "<goal>"     Set colony intention and initialize
+  /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)
@@ -53,7 +54,6 @@ COLONY LIFECYCLE
 
   /ant:seal             Seal colony with Crowned Anthill milestone
   /ant:entomb           Archive completed colony into chambers
-  /ant:lay-eggs         Lay first eggs of new colony (First Eggs milestone)
   /ant:history          Browse colony event history
 
 ADVANCED
@@ -75,7 +75,11 @@ MAINTENANCE
 
 TYPICAL WORKFLOW
 
-  1. /ant:init "Build a REST API with auth"
+  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)
@@ -87,6 +91,11 @@ TYPICAL WORKFLOW
   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

package/.claude/commands/ant/init.md

@@ -64,57 +64,26 @@ Aether Colony
 
 Stop here. Do not proceed.
 
-### Step 1.5: Bootstrap System Files (Conditional)
+### Step 1.5: Verify Aether Setup
 
 Check if `.aether/aether-utils.sh` exists using the Read tool.
 
-**If the file already exists** — skip this step entirely. System files are present.
+**If the file already exists** — skip this step entirely. Aether is set up.
 
 **If the file does NOT exist:**
-- Check if `~/.aether/system/aether-utils.sh` exists (expand `~` to the user's home directory)
-- **If the hub exists:** Run using the Bash tool:
-  ```bash
-  mkdir -p \
-    .aether/data \
-    .aether/data/midden \
-    .aether/data/backups \
-    .aether/data/survey \
-    .aether/dreams \
-    .aether/chambers \
-    .aether/locks \
-    .aether/temp \
-    .aether/docs \
-    .aether/utils \
-    .aether/templates \
-    .aether/schemas \
-    .aether/exchange \
-    .aether/rules \
-    .claude/rules && \
-  cp -f ~/.aether/system/aether-utils.sh .aether/ && \
-  cp -f ~/.aether/system/workers.md .aether/ 2>/dev/null || true && \
-  cp -f ~/.aether/system/CONTEXT.md .aether/ 2>/dev/null || true && \
-  cp -f ~/.aether/system/model-profiles.yaml .aether/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/docs/* .aether/docs/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/utils/* .aether/utils/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/templates/* .aether/templates/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/schemas/* .aether/schemas/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/exchange/* .aether/exchange/ 2>/dev/null || true && \
-  cp -Rf ~/.aether/system/rules/* .claude/rules/ 2>/dev/null || true && \
-  touch .aether/dreams/.gitkeep && \
-  touch .aether/chambers/.gitkeep && \
-  touch .aether/data/midden/.gitkeep && \
-  chmod +x .aether/aether-utils.sh
-  ```
-  This copies system files from the global hub into `.aether/` and creates all required directories upfront. Display:
-  ```
-  Bootstrapped system files from global hub.
-  ```
-- **If the hub does NOT exist:** Output:
-  ```
-  No Aether system files found locally or in ~/.aether/system/.
-  Run `aether install` or `npx aether-colony install` to set up the global hub first.
-  ```
-  Stop here. Do not proceed.
+```
+Aether is not set up in this repo yet.
+
+Run /ant:lay-eggs first to create the .aether/ directory
+with all system files, then run /ant:init "your goal" to
+start a colony.
+
+If the global hub isn't installed either:
+  npm install -g aether-colony   (installs the hub)
+  /ant:lay-eggs                  (sets up this repo)
+  /ant:init "your goal"          (starts the colony)
+```
+Stop here. Do not proceed.
 
 ### Step 1.6: Initialize QUEEN.md Wisdom Document