aether-colony 5.1.0 → 5.3.0

package/.aether/utils/state-api.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 # State API facade -- centralized COLONY_STATE.json access
-# Provides: _state_read, _state_write, _state_read_field, _state_mutate, _state_migrate
+# Provides: _state_read, _state_write, _state_read_field, _state_mutate, _state_migrate,
+#           _colony_vital_signs
 #
 # These functions are sourced by aether-utils.sh at startup.
 # All shared infrastructure (json_ok, json_err, atomic_write, acquire_lock,
@@ -95,11 +96,32 @@ _state_write() {
 
 _state_mutate() {
     # Read-modify-write COLONY_STATE.json with a jq expression
-    # Usage: state-mutate '<jq_expression>'
+    # Usage: state-mutate [--arg NAME VALUE] [--argjson NAME VALUE] '<jq_expression>'
+    # Supports jq --arg, --argjson, --slurpfile, --rawfile flags (forwarded to jq)
     # Acquires lock, creates backup, applies jq, validates, writes atomically
     # Returns: json_ok with mutated:true, or json_err on failure
 
-    sm_expr="${1:-}"
+    # Parse jq flags (--arg, --argjson, --slurpfile, --rawfile) from arguments
+    # The jq expression is always the last argument (after all flags)
+    local sm_jq_flags=()
+    local sm_expr=""
+    local i=0
+    local args=("$@")
+
+    while [[ $i -lt ${#args[@]} ]]; do
+        case "${args[$i]}" in
+            --arg|--argjson|--slurpfile|--rawfile)
+                # Flag requires a name and value — consume next two args
+                sm_jq_flags+=("${args[$i]}" "${args[$((i+1))]}" "${args[$((i+2))]}")
+                i=$((i + 3))
+                ;;
+            *)
+                # Last argument is the jq expression
+                sm_expr="${args[$i]}"
+                i=$((i + 1))
+                ;;
+        esac
+    done
 
     if [[ -z "$sm_expr" ]]; then
         json_err "$E_VALIDATION_FAILED" "state-mutate requires a jq expression argument"
@@ -121,8 +143,8 @@ _state_mutate() {
         fi
     fi
 
-    # Apply jq expression to current state
-    sm_updated=$(jq "$sm_expr" "$sm_state_file" 2>/dev/null) || {
+    # Apply jq expression to current state (with forwarded flags)
+    sm_updated=$(jq ${sm_jq_flags[@]+"${sm_jq_flags[@]}"} "$sm_expr" "$sm_state_file" 2>/dev/null) || {
         release_lock 2>/dev/null || true  # SUPPRESS:OK -- cleanup: lock may not be held
         json_err "$E_JSON_INVALID" "jq expression failed: $sm_expr"
     }
@@ -197,3 +219,192 @@ _state_migrate() {
         [[ "$sm_lock_held" == "true" ]] && release_lock 2>/dev/null || true  # SUPPRESS:OK -- cleanup: lock may not be held
     fi
 }
+
+# ============================================================================
+# _colony_vital_signs
+# Compute colony health metrics from existing data files
+# Usage: colony-vital-signs
+# Returns: JSON with build_velocity, error_rate, signal_health, memory_pressure,
+#          colony_age_hours, and overall_health (0-100)
+# Gracefully degrades: missing files produce zero/default values
+# ============================================================================
+_colony_vital_signs() {
+    local cvs_state_file="$COLONY_DATA_DIR/COLONY_STATE.json"
+    local cvs_midden_file="$COLONY_DATA_DIR/midden/midden.json"
+    local cvs_phero_file="$COLONY_DATA_DIR/pheromones.json"
+    local cvs_session_file="$COLONY_DATA_DIR/session.json"
+
+    # --- Compute 24h window boundary ---
+    local cvs_now
+    cvs_now=$(date -u +%s 2>/dev/null || echo "0")
+    local cvs_window_start=$(( cvs_now - 86400 ))
+
+    # ---- build_velocity: count phase_completed events in last 24h ----
+    local cvs_phases_per_day=0
+    if [[ -f "$cvs_state_file" ]]; then
+        cvs_phases_per_day=$(jq --argjson win "$cvs_window_start" '
+            [.events[]? |
+             select(. != null) |
+             select(test("\\|phase_completed\\|")) |
+             capture("^(?P<ts>[^|]+)\\|") |
+             .ts |
+             gsub("[TZ:-]"; " ") |
+             split(" ") |
+             if length >= 6 then
+               (.[0:6] | join(" ")) |
+               # convert to comparable string for ordering -- full ISO compare
+               . as $s | $s
+             else . end
+            ] | length
+        ' "$cvs_state_file" 2>/dev/null || echo "0")
+
+        # Simpler approach: use string comparison on ISO timestamps
+        # Compute the 24h-ago timestamp as ISO string
+        local cvs_cutoff_iso
+        cvs_cutoff_iso=$(date -u -r "$cvs_window_start" '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null \
+            || date -u -d "@$cvs_window_start" '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null \
+            || echo "")
+
+        if [[ -n "$cvs_cutoff_iso" ]]; then
+            cvs_phases_per_day=$(jq --arg cutoff "$cvs_cutoff_iso" '
+                [.events[]? |
+                 select(. != null and (type == "string")) |
+                 select(test("\\|phase_completed\\|")) |
+                 split("|") | .[0] |
+                 select(. >= $cutoff)
+                ] | length
+            ' "$cvs_state_file" 2>/dev/null || echo "0")
+        fi
+    fi
+    # Normalize: ensure integer
+    cvs_phases_per_day=$(( cvs_phases_per_day + 0 )) 2>/dev/null || cvs_phases_per_day=0
+
+    # Determine trend (simple heuristic: any builds = steady, 0 = idle)
+    local cvs_bv_trend="idle"
+    [[ "$cvs_phases_per_day" -ge 1 ]] && cvs_bv_trend="steady"
+    [[ "$cvs_phases_per_day" -ge 3 ]] && cvs_bv_trend="accelerating"
+
+    # ---- error_rate: unreviewed midden entries in last 24h ----
+    local cvs_errors_per_day=0
+    local cvs_err_status="clean"
+    if [[ -f "$cvs_midden_file" ]]; then
+        local cvs_cutoff_iso_err
+        cvs_cutoff_iso_err=$(date -u -r "$cvs_window_start" '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null \
+            || date -u -d "@$cvs_window_start" '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null \
+            || echo "")
+
+        if [[ -n "$cvs_cutoff_iso_err" ]]; then
+            cvs_errors_per_day=$(jq --arg cutoff "$cvs_cutoff_iso_err" '
+                [(.entries // [])[]? |
+                 select(.reviewed == false or .reviewed == null) |
+                 select((.timestamp // "") >= $cutoff)
+                ] | length
+            ' "$cvs_midden_file" 2>/dev/null || echo "0")
+        else
+            # Fallback: count all unreviewed
+            cvs_errors_per_day=$(jq '
+                [(.entries // [])[]? | select(.reviewed == false or .reviewed == null)] | length
+            ' "$cvs_midden_file" 2>/dev/null || echo "0")
+        fi
+    fi
+    cvs_errors_per_day=$(( cvs_errors_per_day + 0 )) 2>/dev/null || cvs_errors_per_day=0
+
+    if [[ "$cvs_errors_per_day" -eq 0 ]]; then
+        cvs_err_status="clean"
+    elif [[ "$cvs_errors_per_day" -le 2 ]]; then
+        cvs_err_status="nominal"
+    elif [[ "$cvs_errors_per_day" -le 5 ]]; then
+        cvs_err_status="elevated"
+    else
+        cvs_err_status="critical"
+    fi
+
+    # ---- signal_health: count active pheromones ----
+    local cvs_active_count=0
+    local cvs_sig_status="dormant"
+    if [[ -f "$cvs_phero_file" ]]; then
+        cvs_active_count=$(jq '
+            [.signals[]? | select(.active == true)] | length
+        ' "$cvs_phero_file" 2>/dev/null || echo "0")
+    fi
+    cvs_active_count=$(( cvs_active_count + 0 )) 2>/dev/null || cvs_active_count=0
+
+    if [[ "$cvs_active_count" -eq 0 ]]; then
+        cvs_sig_status="dormant"
+    elif [[ "$cvs_active_count" -le 3 ]]; then
+        cvs_sig_status="guided"
+    else
+        cvs_sig_status="active"
+    fi
+
+    # ---- memory_pressure: count instincts ----
+    local cvs_instinct_count=0
+    local cvs_mem_status="empty"
+    if [[ -f "$cvs_state_file" ]]; then
+        # instincts may be a JSON string (serialized array) or a real array
+        local cvs_raw_instincts
+        cvs_raw_instincts=$(jq -r '.memory.instincts // "[]"' "$cvs_state_file" 2>/dev/null || echo "[]")
+        # Handle both string-encoded and native array
+        cvs_instinct_count=$(echo "$cvs_raw_instincts" | jq -r 'if type == "string" then (. | fromjson | length) elif type == "array" then length else 0 end' 2>/dev/null || echo "0")
+    fi
+    cvs_instinct_count=$(( cvs_instinct_count + 0 )) 2>/dev/null || cvs_instinct_count=0
+
+    if [[ "$cvs_instinct_count" -eq 0 ]]; then
+        cvs_mem_status="empty"
+    elif [[ "$cvs_instinct_count" -le 5 ]]; then
+        cvs_mem_status="growing"
+    elif [[ "$cvs_instinct_count" -le 15 ]]; then
+        cvs_mem_status="healthy"
+    else
+        cvs_mem_status="rich"
+    fi
+
+    # ---- colony_age_hours: hours since initialized_at ----
+    local cvs_age_hours=0
+    if [[ -f "$cvs_state_file" ]]; then
+        local cvs_init_at
+        cvs_init_at=$(jq -r '.initialized_at // empty' "$cvs_state_file" 2>/dev/null || echo "")
+        if [[ -n "$cvs_init_at" ]]; then
+            local cvs_init_ts
+            cvs_init_ts=$(date -u -j -f '%Y-%m-%dT%H:%M:%SZ' "$cvs_init_at" '+%s' 2>/dev/null \
+                || date -u -d "$cvs_init_at" '+%s' 2>/dev/null \
+                || echo "0")
+            if [[ "$cvs_init_ts" -gt 0 && "$cvs_now" -gt "$cvs_init_ts" ]]; then
+                cvs_age_hours=$(( (cvs_now - cvs_init_ts) / 3600 ))
+            fi
+        fi
+    fi
+
+    # ---- overall_health: weighted 0-100 score ----
+    # Components (max points each):
+    #   recent builds (+30): has at least one phase_completed in 24h
+    #   low errors (+30):    zero unreviewed errors in 24h
+    #   signals exist (+20): at least one active pheromone
+    #   instincts growing (+20): at least one instinct
+    local cvs_score=0
+    [[ "$cvs_phases_per_day" -ge 1 ]] && cvs_score=$(( cvs_score + 30 ))
+    [[ "$cvs_errors_per_day" -eq 0 ]] && cvs_score=$(( cvs_score + 30 ))
+    [[ "$cvs_active_count" -ge 1 ]] && cvs_score=$(( cvs_score + 20 ))
+    [[ "$cvs_instinct_count" -ge 1 ]] && cvs_score=$(( cvs_score + 20 ))
+    [[ "$cvs_score" -gt 100 ]] && cvs_score=100
+
+    json_ok "$(jq -n \
+        --argjson phases_per_day "$cvs_phases_per_day" \
+        --arg bv_trend "$cvs_bv_trend" \
+        --argjson errors_per_day "$cvs_errors_per_day" \
+        --arg err_status "$cvs_err_status" \
+        --argjson active_count "$cvs_active_count" \
+        --arg sig_status "$cvs_sig_status" \
+        --argjson instinct_count "$cvs_instinct_count" \
+        --arg mem_status "$cvs_mem_status" \
+        --argjson age_hours "$cvs_age_hours" \
+        --argjson overall_health "$cvs_score" \
+        '{
+            build_velocity:   {phases_per_day: $phases_per_day, trend: $bv_trend},
+            error_rate:       {errors_per_day: $errors_per_day, status: $err_status},
+            signal_health:    {active_count: $active_count, status: $sig_status},
+            memory_pressure:  {instinct_count: $instinct_count, status: $mem_status},
+            colony_age_hours: $age_hours,
+            overall_health:   $overall_health
+        }')"
+}

package/.aether/utils/swarm.sh

@@ -32,7 +32,7 @@ _autofix_checkpoint() {
         label="${1:-autofix-$(date +%s)}"
         stash_name="aether-checkpoint: $label"
         # Only stash Aether-managed directories, never touch user files
-        if git stash push -m "$stash_name" -- $target_dirs >/dev/null 2>&1; then  # SUPPRESS:OK -- existence-test: stash operation may fail
+        if git stash push -m "$stash_name" -- $target_dirs ":(exclude).aether/data/" >/dev/null 2>&1; then  # SUPPRESS:OK -- existence-test: stash operation may fail
           json_ok "$(jq -n --arg ref "$stash_name" '{type: "stash", ref: $ref}')"
         else
           # Stash failed (possibly due to conflicts), record commit hash

package/.aether/utils/worktree.sh

@@ -0,0 +1,189 @@
+#!/bin/bash
+# Worktree utility functions -- extracted from aether-utils.sh
+# Provides: _worktree_create, _worktree_cleanup
+#
+# These functions are sourced by aether-utils.sh at startup.
+# All shared infrastructure (json_ok, json_err, atomic_write, acquire_lock,
+# release_lock, DATA_DIR, COLONY_DATA_DIR, SCRIPT_DIR, AETHER_ROOT, error
+# constants) is available.
+
+# Default worktree location relative to AETHER_ROOT
+WORKTREE_BASE_DIR="${AETHER_ROOT}/.aether/worktrees"
+
+# _worktree_create
+# Creates a git worktree for an agent working on a specific task.
+#
+# Usage: _worktree_create --branch <branch-name> [--base <base-branch>] [--task-id <task-id>]
+# Returns JSON: {ok:true, result:{path, branch, base, worktree_dir, task_id}}
+_worktree_create() {
+    local branch=""
+    local base=""
+    local task_id=""
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --branch) branch="${2:-}"; shift 2 ;;
+            --base)   base="${2:-}";   shift 2 ;;
+            --task-id) task_id="${2:-}"; shift 2 ;;
+            *) shift ;;
+        esac
+    done
+
+    # Validate required arguments
+    if [[ -z "$branch" ]]; then
+        json_err "$E_VALIDATION_FAILED" "Usage: worktree-create --branch <branch-name> [--base <base-branch>] [--task-id <task-id>]"
+    fi
+
+    # Sanitize branch name: reject obviously dangerous patterns
+    if [[ "$branch" == *..* ]] || [[ "$branch" == */* ]] || [[ "$branch" == *\\* ]]; then
+        json_err "$E_VALIDATION_FAILED" "Branch name must not contain '..', '/', or backslashes"
+    fi
+
+    # Default base to current branch
+    if [[ -z "$base" ]]; then
+        base=$(git -C "$AETHER_ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")
+    fi
+
+    local worktree_dir="$WORKTREE_BASE_DIR/$branch"
+
+    # Check if worktree already exists
+    if [[ -d "$worktree_dir" ]]; then
+        json_err "$E_VALIDATION_FAILED" "Worktree already exists for branch '$branch' at $worktree_dir"
+    fi
+
+    # Check if branch already exists as a git branch (would indicate duplicate)
+    if git -C "$AETHER_ROOT" show-ref --verify --quiet "refs/heads/$branch" 2>/dev/null; then
+        json_err "$E_VALIDATION_FAILED" "Branch '$branch' already exists"
+    fi
+
+    # Ensure base branch exists
+    if ! git -C "$AETHER_ROOT" show-ref --verify --quiet "refs/heads/$base" 2>/dev/null; then
+        json_err "$E_GIT_ERROR" "Base branch '$base' does not exist"
+    fi
+
+    # Ensure parent directory exists
+    mkdir -p "$WORKTREE_BASE_DIR"
+
+    # Create the worktree (git worktree add creates the branch automatically)
+    if ! git -C "$AETHER_ROOT" worktree add "$worktree_dir" -b "$branch" "$base" >/dev/null 2>&1; then
+        json_err "$E_GIT_ERROR" "Failed to create worktree for branch '$branch'"
+    fi
+
+    # Copy .aether/data/ structure to the new worktree so the agent has colony context
+    # Per state-contract-design.md, branch-local state lives in .aether/data/ (gitignored)
+    # and each worktree gets its own independent copy for colony context isolation.
+    if [[ -d "$AETHER_ROOT/.aether/data" ]]; then
+        mkdir -p "$worktree_dir/.aether/data"
+        cp -r "$AETHER_ROOT/.aether/data/." "$worktree_dir/.aether/data/" 2>/dev/null || true  # SUPPRESS:OK -- copy: data dir may be empty
+    fi
+
+    # Copy exchange scripts so xml-utils.sh can source pheromone-xml.sh etc.
+    if [[ -d "$AETHER_ROOT/.aether/exchange" ]]; then
+        mkdir -p "$worktree_dir/.aether/exchange"
+        cp -r "$AETHER_ROOT/.aether/exchange/." "$worktree_dir/.aether/exchange/" 2>/dev/null || true
+    fi
+
+    # Inject main's pheromone signals into the worktree (per D-01)
+    # Non-blocking: if injection fails, worktree still works without injected signals
+    if [[ -f "$worktree_dir/.aether/data/pheromones.json" ]]; then
+      local main_head
+      main_head=$(git -C "$AETHER_ROOT" rev-parse HEAD 2>/dev/null || echo "unknown")
+      (
+        cd "$worktree_dir" 2>/dev/null && \
+        DATA_DIR="$worktree_dir/.aether/data" \
+        COLONY_DATA_DIR="$worktree_dir/.aether/data" \
+        bash "$AETHER_ROOT/.aether/aether-utils.sh" \
+          pheromone-snapshot-inject --from-branch "$base" --from-commit "$main_head" \
+        >/dev/null 2>&1 || true
+      )
+    fi
+
+    # Build result JSON
+    local result
+    result=$(jq -n \
+        --arg path "$worktree_dir" \
+        --arg branch "$branch" \
+        --arg base "$base" \
+        --arg worktree_dir "$worktree_dir" \
+        --arg task_id "${task_id:-null}" \
+        '{
+            path: $path,
+            branch: $branch,
+            base: $base,
+            worktree_dir: $worktree_dir,
+            task_id: (if $task_id == "null" then null else $task_id end)
+        }')
+
+    json_ok "$result"
+}
+
+# _worktree_cleanup
+# Removes a git worktree and cleans up tracking.
+#
+# Usage: _worktree_cleanup --branch <branch-name> [--force]
+# Returns JSON: {ok:true, result:{removed, branch, path}}
+_worktree_cleanup() {
+    local branch=""
+    local force=false
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --branch) branch="${2:-}"; shift 2 ;;
+            --force)  force=true; shift ;;
+            *) shift ;;
+        esac
+    done
+
+    # Validate required arguments
+    if [[ -z "$branch" ]]; then
+        json_err "$E_VALIDATION_FAILED" "Usage: worktree-cleanup --branch <branch-name> [--force]"
+    fi
+
+    # Sanitize branch name
+    if [[ "$branch" == *..* ]] || [[ "$branch" == */* ]] || [[ "$branch" == *\\* ]]; then
+        json_err "$E_VALIDATION_FAILED" "Branch name must not contain '..', '/', or backslashes"
+    fi
+
+    local worktree_dir="$WORKTREE_BASE_DIR/$branch"
+
+    # Check if worktree exists
+    if [[ ! -d "$worktree_dir" ]]; then
+        json_err "$E_RESOURCE_NOT_FOUND" "No worktree found for branch '$branch'"
+    fi
+
+    # Check for uncommitted changes (unless --force)
+    # Exclude .aether/ files since they are branch-local state copies, not user changes
+    if [[ "$force" == "false" ]]; then
+        local dirty_count
+        dirty_count=$(git -C "$worktree_dir" status --porcelain 2>/dev/null \
+            | grep -v '\.aether/' \
+            | wc -l \
+            | tr -d ' ') || dirty_count=0
+
+        if [[ "$dirty_count" -gt 0 ]]; then
+            json_err "$E_VALIDATION_FAILED" "Worktree '$branch' has $dirty_count uncommitted changes. Use --force to remove anyway."
+        fi
+    fi
+
+    # Remove the worktree using git worktree remove
+    if ! git -C "$AETHER_ROOT" worktree remove "$worktree_dir" --force 2>/dev/null; then
+        # Fallback: manual cleanup if git worktree remove fails
+        rm -rf "$worktree_dir" 2>/dev/null || true
+        # Also prune stale worktree entries
+        git -C "$AETHER_ROOT" worktree prune 2>/dev/null || true
+    fi
+
+    # Attempt to delete the branch (best-effort -- may fail if branch is checked out elsewhere)
+    git -C "$AETHER_ROOT" branch -D "$branch" >/dev/null 2>&1 || true
+
+    # Build result JSON
+    local result
+    result=$(jq -n \
+        --arg branch "$branch" \
+        --arg path "$worktree_dir" \
+        '{removed: true, branch: $branch, path: $path}')
+
+    json_ok "$result"
+}

package/.claude/commands/ant/colonize.md

@@ -69,6 +69,8 @@ Read `.aether/data/COLONY_STATE.json`.
 
 **If the file exists:** continue.
 
+**If `milestone` == `"Crowned Anthill"`:** output "This colony has been sealed. Start a new colony with `/ant:init \"new goal\"`.", stop.
+
 **If `plan.phases` is not empty:** output "Colony already has phases. Use /ant:continue.", stop.
 
 ### Step 2: Quick Surface Scan (for session context)

package/.claude/commands/ant/council.md

@@ -9,9 +9,208 @@ You are the **Queen Ant Colony**. Convene the council to clarify user intent and
 ## Instructions
 
 Parse `$ARGUMENTS`:
+- If starts with `--deliberate`: set `deliberate_mode = true`, extract proposal text after `--deliberate`
 - If contains `--no-visual`: set `visual_mode = false` (visual is ON by default)
 - Otherwise: set `visual_mode = true`
 
+**If `deliberate_mode` is true:** Skip to [Deliberation Mode](#deliberation-mode) and stop after it.
+
+---
+
+## Deliberation Mode
+
+When `--deliberate "<proposal>"` is passed, run a structured Advocate/Challenger/Sage deliberation.
+
+### Step D1: Check Budget
+
+Run using the Bash tool with description "Checking deliberation budget...":
+```bash
+bash .aether/aether-utils.sh council-budget-check
+```
+
+Parse result. If `allowed` is `false`:
+```
+📜🐜🏛️🐜📜 COUNCIL — BUDGET EXHAUSTED
+
+Spawn budget is fully allocated. Complete or close existing deliberations before starting new ones.
+Run /ant:council to review existing deliberations.
+```
+Stop here.
+
+### Step D2: Open Deliberation
+
+Run using the Bash tool with description "Opening deliberation...":
+```bash
+bash .aether/aether-utils.sh council-deliberate --proposal "<proposal>"
+```
+
+Capture `deliberation_id` from `result.id`.
+
+Display:
+```
+📜🐜🏛️🐜📜 COUNCIL DELIBERATION OPENED
+
+Proposal: "<proposal>"
+ID: {deliberation_id}
+Budget: {budget} spawns available
+
+Convening Advocate, Challenger, and Sage...
+```
+
+### Step D3: Spawn Advocate Scout
+
+Spawn an Advocate scout to argue **in favor** of the proposal.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Advocate on the Ant Colony council.
+Your role is to argue STRONGLY IN FAVOR of the proposal.
+Present the strongest possible case for why this proposal should be adopted.
+Be specific. Focus on concrete benefits and outcomes.
+Keep your argument under 200 words.
+Reply with ONLY your argument text — no preamble or meta-commentary.
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Present your strongest argument in favor of this proposal.
+```
+
+Capture the advocate's argument as `advocate_argument`.
+
+
+Record the argument:
+```bash
+bash .aether/aether-utils.sh council-advocate \
+  --deliberation-id "<deliberation_id>" \
+  --argument "<advocate_argument>"
+```
+
+Display:
+```
+⚖️  ADVOCATE:
+{advocate_argument}
+```
+
+### Step D4: Spawn Challenger Scout
+
+Spawn a Challenger scout to argue **against** the proposal.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Challenger on the Ant Colony council.
+Your role is to argue STRONGLY AGAINST the proposal.
+Present the strongest possible case for why this proposal should be rejected or deferred.
+Be specific. Focus on concrete risks, costs, and downsides.
+Keep your argument under 200 words.
+Reply with ONLY your argument text — no preamble or meta-commentary.
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Present your strongest argument against this proposal.
+```
+
+Capture the challenger's argument as `challenger_argument`.
+
+
+Record the argument:
+```bash
+bash .aether/aether-utils.sh council-challenger \
+  --deliberation-id "<deliberation_id>" \
+  --argument "<challenger_argument>"
+```
+
+Display:
+```
+⚔️  CHALLENGER:
+{challenger_argument}
+```
+
+### Step D5: Spawn Sage Scout
+
+Spawn a Sage scout to synthesize both positions and provide a recommendation.
+
+
+Use the Task tool to spawn a scout with the following system prompt:
+```
+You are the Sage on the Ant Colony council.
+You have heard both the Advocate and Challenger arguments.
+Your role is to synthesize both positions into balanced wisdom and provide a clear recommendation.
+Your recommendation must be one of: adopt, reject, defer, or adopt-with-conditions.
+Keep your synthesis under 150 words.
+Reply with JSON only:
+{"synthesis": "<your balanced synthesis>", "recommendation": "adopt|reject|defer|adopt-with-conditions"}
+```
+
+And user message:
+```
+Proposal: "<proposal>"
+
+Advocate argued: "<advocate_argument>"
+
+Challenger argued: "<challenger_argument>"
+
+Synthesize both positions and provide your recommendation.
+```
+
+Parse the JSON response. Capture `synthesis` and `recommendation`.
+
+
+Record the sage synthesis:
+```bash
+bash .aether/aether-utils.sh council-sage \
+  --deliberation-id "<deliberation_id>" \
+  --synthesis "<synthesis>" \
+  --recommendation "<recommendation>"
+```
+
+### Step D6: Display Result
+
+```
+📜🐜🏛️🐜📜 COUNCIL DELIBERATION COMPLETE
+
+Proposal: "<proposal>"
+
+⚖️  Advocate:
+{advocate_argument}
+
+⚔️  Challenger:
+{challenger_argument}
+
+🧙 Sage Synthesis:
+{synthesis}
+
+Recommendation: {recommendation}
+```
+
+If recommendation is `adopt` or `adopt-with-conditions`:
+```
+✅ Council recommends proceeding.
+   Run /ant:focus "<proposal summary>" to inject guidance for the colony.
+```
+
+If recommendation is `reject`:
+```
+❌ Council recommends against this proposal.
+   Run /ant:redirect "<proposal summary>" if you want to make this a hard constraint.
+```
+
+If recommendation is `defer`:
+```
+⏸️  Council recommends deferring this decision.
+   Return when more context is available.
+```
+
+---
+
+
 
 ### Step 0: Initialize Visual Mode (if enabled)
 
@@ -29,6 +228,12 @@ No colony initialized. Run /ant:init first.
 ```
 Stop here.
 
+If `milestone` == `"Crowned Anthill"`:
+```
+This colony has been sealed. Start a new colony with /ant:init "new goal".
+```
+Stop here.
+
 Capture the current state for context:
 - `prior_state` = state field value (READY, EXECUTING, PLANNING, etc.)
 - `current_phase` = current_phase field value