aether-colony 5.3.1 → 5.3.3

package/.aether/utils/trust-scoring.sh

@@ -0,0 +1,347 @@
+#!/bin/bash
+# Trust Scoring utility functions — Aether Structural Learning Stack
+# Provides: _trust_calculate, _trust_decay, _trust_tier
+#
+# These functions are sourced by aether-utils.sh at startup.
+# All shared infrastructure (json_ok, json_err, json_warn, atomic_write,
+# DATA_DIR, COLONY_DATA_DIR, SCRIPT_DIR, error constants) is available.
+#
+# This is a pure calculation module — no state is read or written.
+# All functions accept --flag <value> arguments and return JSON via json_ok.
+
+# ============================================================================
+# _trust_calculate
+# Calculate a weighted trust score from source, evidence, and activity inputs.
+#
+# Weights: source 40%, evidence 35%, activity 25%
+# Activity uses a 60-day half-life decay from days_since_last_use.
+# Floor: score is never below 0.2.
+#
+# Usage: trust-calculate --source <type> --evidence <type> --days-since <N>
+#
+# Source types and weights:
+#   user_feedback   1.0
+#   error_resolution 0.9
+#   success_pattern 0.8
+#   observation     0.6
+#   heuristic       0.4
+#
+# Evidence types and weights:
+#   test_verified   1.0
+#   multi_phase     0.9
+#   single_phase    0.7
+#   anecdotal       0.4
+#
+# Output: {score, source_score, evidence_score, activity_score, tier}
+# ============================================================================
+_trust_calculate() {
+    local source_type=""
+    local evidence_type=""
+    local days_since=""
+
+    # Parse --flag value arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --source)
+                source_type="${2:-}"
+                shift 2
+                ;;
+            --evidence)
+                evidence_type="${2:-}"
+                shift 2
+                ;;
+            --days-since)
+                days_since="${2:-}"
+                shift 2
+                ;;
+            *)
+                json_err "$E_VALIDATION_FAILED" "Usage: trust-calculate --source <type> --evidence <type> --days-since <N>"
+                return
+                ;;
+        esac
+    done
+
+    [[ -z "$source_type" || -z "$evidence_type" || -z "$days_since" ]] && \
+        json_err "$E_VALIDATION_FAILED" "Usage: trust-calculate --source <type> --evidence <type> --days-since <N>"
+
+    # Map source type to score
+    local source_score
+    case "$source_type" in
+        user_feedback)    source_score="1.0" ;;
+        error_resolution) source_score="0.9" ;;
+        success_pattern)  source_score="0.8" ;;
+        observation)      source_score="0.6" ;;
+        heuristic)        source_score="0.4" ;;
+        *)
+            json_err "$E_VALIDATION_FAILED" "Unknown source type: $source_type. Valid: user_feedback, error_resolution, success_pattern, observation, heuristic"
+            return
+            ;;
+    esac
+
+    # Map evidence type to score
+    local evidence_score
+    case "$evidence_type" in
+        test_verified) evidence_score="1.0" ;;
+        multi_phase)   evidence_score="0.9" ;;
+        single_phase)  evidence_score="0.7" ;;
+        anecdotal)     evidence_score="0.4" ;;
+        *)
+            json_err "$E_VALIDATION_FAILED" "Unknown evidence type: $evidence_type. Valid: test_verified, multi_phase, single_phase, anecdotal"
+            return
+            ;;
+    esac
+
+    # Validate days_since is a non-negative integer
+    if ! [[ "$days_since" =~ ^[0-9]+$ ]]; then
+        json_err "$E_VALIDATION_FAILED" "--days-since must be a non-negative integer, got: $days_since"
+        return
+    fi
+
+    # Calculate activity score using 60-day half-life decay
+    # activity = 0.5 ^ (days / 60)
+    local activity_score
+    activity_score=$(_trust_halflife_decay "1.0" "$days_since" "60")
+
+    # Weighted formula: 0.4 * source + 0.35 * evidence + 0.25 * activity
+    local raw_score
+    if command -v bc &>/dev/null; then
+        raw_score=$(echo "scale=6; 0.4 * $source_score + 0.35 * $evidence_score + 0.25 * $activity_score" | bc)
+    else
+        raw_score=$(awk "BEGIN{printf \"%.6f\", 0.4 * $source_score + 0.35 * $evidence_score + 0.25 * $activity_score}")
+    fi
+
+    # Apply floor of 0.2
+    local score
+    score=$(_trust_apply_floor "$raw_score" "0.2")
+
+    # Derive tier from final score
+    local tier
+    tier=$(_trust_score_to_tier "$score")
+
+    json_ok "$(jq -n \
+        --argjson score "$score" \
+        --argjson source_score "$source_score" \
+        --argjson evidence_score "$evidence_score" \
+        --argjson activity_score "$activity_score" \
+        --arg tier "$tier" \
+        '{
+            score: $score,
+            source_score: $source_score,
+            evidence_score: $evidence_score,
+            activity_score: $activity_score,
+            tier: $tier
+        }')"
+}
+
+# ============================================================================
+# _trust_decay
+# Apply time-based half-life decay to an existing trust score.
+# The score never drops below the floor of 0.2.
+#
+# Formula: decayed = max(0.2, score * (0.5 ^ (days / 60)))
+#
+# Usage: trust-decay --score <float> --days <N>
+# Output: {original, decayed, days, half_life: 60}
+# ============================================================================
+_trust_decay() {
+    local score=""
+    local days=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --score)
+                score="${2:-}"
+                shift 2
+                ;;
+            --days)
+                days="${2:-}"
+                shift 2
+                ;;
+            *)
+                json_err "$E_VALIDATION_FAILED" "Usage: trust-decay --score <float> --days <N>"
+                return
+                ;;
+        esac
+    done
+
+    [[ -z "$score" || -z "$days" ]] && \
+        json_err "$E_VALIDATION_FAILED" "Usage: trust-decay --score <float> --days <N>"
+
+    # Validate score is a positive number
+    if ! [[ "$score" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
+        json_err "$E_VALIDATION_FAILED" "--score must be a non-negative number, got: $score"
+        return
+    fi
+
+    # Validate days is a non-negative integer
+    if ! [[ "$days" =~ ^[0-9]+$ ]]; then
+        json_err "$E_VALIDATION_FAILED" "--days must be a non-negative integer, got: $days"
+        return
+    fi
+
+    local decayed
+    decayed=$(_trust_halflife_decay "$score" "$days" "60")
+    local final
+    final=$(_trust_apply_floor "$decayed" "0.2")
+
+    json_ok "$(jq -n \
+        --argjson original "$score" \
+        --argjson decayed "$final" \
+        --argjson days "$days" \
+        --argjson half_life 60 \
+        '{
+            original: $original,
+            decayed: $decayed,
+            days: $days,
+            half_life: $half_life
+        }')"
+}
+
+# ============================================================================
+# _trust_tier
+# Map a trust score to a named tier.
+#
+# Tier table:
+#   0.90–1.00  canonical   (index 0) — proven across multiple contexts
+#   0.80–0.89  trusted     (index 1) — reliable with strong evidence
+#   0.70–0.79  established (index 2) — consistent but limited evidence
+#   0.60–0.69  emerging    (index 3) — promising, needs more validation
+#   0.45–0.59  provisional (index 4) — early stage, minimal evidence
+#   0.30–0.44  suspect     (index 5) — weak evidence or conflicting signals
+#   0.20–0.29  dormant     (index 6) — inactive, near floor
+#
+# Usage: trust-tier --score <float>
+# Output: {score, tier, tier_index}
+# ============================================================================
+_trust_tier() {
+    local score=""
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --score)
+                score="${2:-}"
+                shift 2
+                ;;
+            *)
+                json_err "$E_VALIDATION_FAILED" "Usage: trust-tier --score <float>"
+                return
+                ;;
+        esac
+    done
+
+    [[ -z "$score" ]] && \
+        json_err "$E_VALIDATION_FAILED" "Usage: trust-tier --score <float>"
+
+    # Validate score is a non-negative number
+    if ! [[ "$score" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
+        json_err "$E_VALIDATION_FAILED" "--score must be a non-negative number, got: $score"
+        return
+    fi
+
+    local tier
+    local tier_index
+    tier=$(_trust_score_to_tier "$score")
+    tier_index=$(_trust_tier_to_index "$tier")
+
+    json_ok "$(jq -n \
+        --argjson score "$score" \
+        --arg tier "$tier" \
+        --argjson tier_index "$tier_index" \
+        '{
+            score: $score,
+            tier: $tier,
+            tier_index: $tier_index
+        }')"
+}
+
+# ============================================================================
+# Internal helpers — not exposed as subcommands
+# ============================================================================
+
+# _trust_halflife_decay: compute score * (0.5 ^ (days / half_life))
+# Usage: _trust_halflife_decay <score> <days> <half_life>
+# Outputs the decayed value as a float string
+_trust_halflife_decay() {
+    local score="$1"
+    local days="$2"
+    local half_life="$3"
+
+    if command -v bc &>/dev/null; then
+        echo "scale=6; $score * e(l(0.5) * ($days / $half_life))" | bc -l
+    else
+        awk "BEGIN{printf \"%.6f\", $score * (0.5 ^ ($days / $half_life))}"
+    fi
+}
+
+# _trust_apply_floor: return max(floor, value)
+# Usage: _trust_apply_floor <value> <floor>
+# Outputs the floored value as a float string
+_trust_apply_floor() {
+    local value="$1"
+    local floor="$2"
+
+    if command -v bc &>/dev/null; then
+        local cmp
+        cmp=$(echo "$value < $floor" | bc -l)
+        if [[ "$cmp" == "1" ]]; then
+            echo "$floor"
+        else
+            echo "$value"
+        fi
+    else
+        awk "BEGIN{v=$value; f=$floor; printf \"%.6f\", (v < f ? f : v)}"
+    fi
+}
+
+# _trust_score_to_tier: map a numeric score to a tier name
+# Usage: _trust_score_to_tier <score>
+# Outputs the tier name string
+_trust_score_to_tier() {
+    local score="$1"
+
+    if command -v bc &>/dev/null; then
+        if [[ $(echo "$score >= 0.90" | bc -l) == "1" ]]; then
+            echo "canonical"
+        elif [[ $(echo "$score >= 0.80" | bc -l) == "1" ]]; then
+            echo "trusted"
+        elif [[ $(echo "$score >= 0.70" | bc -l) == "1" ]]; then
+            echo "established"
+        elif [[ $(echo "$score >= 0.60" | bc -l) == "1" ]]; then
+            echo "emerging"
+        elif [[ $(echo "$score >= 0.45" | bc -l) == "1" ]]; then
+            echo "provisional"
+        elif [[ $(echo "$score >= 0.30" | bc -l) == "1" ]]; then
+            echo "suspect"
+        else
+            echo "dormant"
+        fi
+    else
+        awk "BEGIN{
+            s = $score
+            if (s >= 0.90)      print \"canonical\"
+            else if (s >= 0.80) print \"trusted\"
+            else if (s >= 0.70) print \"established\"
+            else if (s >= 0.60) print \"emerging\"
+            else if (s >= 0.45) print \"provisional\"
+            else if (s >= 0.30) print \"suspect\"
+            else                print \"dormant\"
+        }"
+    fi
+}
+
+# _trust_tier_to_index: map tier name to integer index
+# Usage: _trust_tier_to_index <tier_name>
+# Outputs the index as an integer string
+_trust_tier_to_index() {
+    local tier="$1"
+    case "$tier" in
+        canonical)    echo "0" ;;
+        trusted)      echo "1" ;;
+        established)  echo "2" ;;
+        emerging)     echo "3" ;;
+        provisional)  echo "4" ;;
+        suspect)      echo "5" ;;
+        dormant)      echo "6" ;;
+        *)            echo "-1" ;;
+    esac
+}

package/.aether/utils/worktree.sh

@@ -187,3 +187,100 @@ _worktree_cleanup() {
 
     json_ok "$result"
 }
+
+# _worktree_merge
+# Merges a worktree branch back to the target branch with safety checks.
+#
+# Usage: _worktree_merge --branch <branch-name> [--target <target-branch>] [--force]
+# Returns JSON: {ok:true, result:{merged, branch, target, sha, commits_merged}}
+_worktree_merge() {
+    local branch=""
+    local target=""
+    local force=false
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --branch) branch="${2:-}"; shift 2 ;;
+            --target) target="${2:-}"; shift 2 ;;
+            --force)  force=true; shift ;;
+            *) shift ;;
+        esac
+    done
+
+    if [[ -z "$branch" ]]; then
+        json_err "$E_VALIDATION_FAILED" "Usage: worktree-merge --branch <branch-name> [--target <target-branch>]"
+    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"
+
+    # Default target to current branch
+    if [[ -z "$target" ]]; then
+        target=$(git -C "$AETHER_ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")
+    fi
+
+    # Safety check 1: worktree must exist
+    if [[ ! -d "$worktree_dir" ]]; then
+        json_err "$E_RESOURCE_NOT_FOUND" "No worktree found for branch '$branch'"
+    fi
+
+    # Safety check 2: worktree must have committed changes (unless --force)
+    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. Commit or stash before merging."
+        fi
+    fi
+
+    # Safety check 3: worktree must have commits ahead of target
+    local ahead_count
+    ahead_count=$(git -C "$AETHER_ROOT" rev-list --count "${target}..${branch}" 2>/dev/null || echo "0")
+    if [[ "$ahead_count" -eq 0 ]]; then
+        # Nothing to merge — just clean up
+        _worktree_cleanup --branch "$branch" --force
+        return $?
+    fi
+
+    # Safety check 4: check for merge conflicts (dry run)
+    local conflict_check
+    conflict_check=$(git -C "$AETHER_ROOT" merge-tree $(git -C "$AETHER_ROOT" merge-base "$target" "$branch") "$target" "$branch" 2>/dev/null | grep -c "changed in both" || echo "0")
+    if [[ "$conflict_check" -gt 0 ]] && [[ "$force" == "false" ]]; then
+        json_err "$E_VALIDATION_FAILED" "Merge would produce $conflict_check conflict(s). Resolve manually or use --force."
+    fi
+
+    # Perform the merge
+    local merge_sha
+    if ! git -C "$AETHER_ROOT" merge "$branch" --no-edit --no-ff -m "merge: worktree branch $branch into $target" >/dev/null 2>&1; then
+        # Merge failed — abort
+        git -C "$AETHER_ROOT" merge --abort 2>/dev/null || true
+        json_err "$E_GIT_ERROR" "Merge of '$branch' into '$target' failed. Aborted."
+    fi
+
+    merge_sha=$(git -C "$AETHER_ROOT" rev-parse HEAD 2>/dev/null || echo "unknown")
+
+    # Export pheromones from the worktree branch before cleanup
+    if [[ -f "$worktree_dir/.aether/data/pheromones.json" ]]; then
+        mkdir -p "$AETHER_ROOT/.aether/exchange"
+        cp "$worktree_dir/.aether/data/pheromones.json" \
+           "$AETHER_ROOT/.aether/exchange/pheromone-branch-export.json" 2>/dev/null || true
+    fi
+
+    # Cleanup the worktree
+    _worktree_cleanup --branch "$branch" --force 2>/dev/null || true
+
+    local result
+    result=$(jq -n \
+        --arg branch "$branch" \
+        --arg target "$target" \
+        --arg sha "$merge_sha" \
+        --argjson ahead "$ahead_count" \
+        '{merged: true, branch: $branch, target: $target, sha: $sha, commits_merged: $ahead}')
+    json_ok "$result"
+}

package/.claude/commands/ant/entomb.md

@@ -444,7 +444,7 @@ Write the result to .aether/HANDOFF.md using the Write tool.
 Display:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   C O L O N Y   E N T O M B E D
+⚰️ C O L O N Y   E N T O M B E D
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Entombed v{colony_version}

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

@@ -41,7 +41,6 @@ Do not touch during init:
 - .aether/dreams/ (user notes)
 - .aether/chambers/ (archived colonies)
 - .env* files
-- .claude/settings.json
 - .github/workflows/
 </read_only>
 
@@ -156,7 +155,7 @@ Strip `(Colony: ...)` suffixes using sed. If grep finds nothing, variables remai
 Display a brief header:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   A E T H E R   C O L O N Y   I N I T
+🥚 A E T H E R   C O L O N Y   I N I T
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
@@ -470,30 +469,48 @@ Display "Import skipped. Starting fresh colony." and proceed to Step 8.
 **If xml_import_available is false (no chambers, no XML, or no xmllint):**
 
 Skip silently -- proceed directly to Step 8 without any mention of import (per D-11).
+### Step 7.5: Install Clash Detection Hook
+
+If `.aether/utils/clash-detect.sh` exists, run:
+
+```bash
+bash .aether/aether-utils.sh clash-setup --install 2>/dev/null || true
+```
+
+This installs the PreToolUse hook that prevents conflicting edits across worktrees.
+Non-blocking — if it fails, init continues normally.
+
+Also configure the merge driver for package-lock.json:
+
+```bash
+git config merge.lockfile.driver "bash .aether/utils/merge-driver-lockfile.sh %O %A %B" 2>/dev/null || true
+git config merge.lockfile.name "npm lockfile auto-merge" 2>/dev/null || true
+```
+
 ### Step 8: Display Result
 
 Display the success header and result block:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   A E T H E R   C O L O N Y
+🥚 A E T H E R   C O L O N Y
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Queen has set the colony's intention
+👑 Queen has set the colony's intention
 
    "{approved_intent}"
 
-   Colony Status: READY
+   🟢 Colony Status: READY
 
-{If re-init: "   Mode: Re-init (charter updated, state preserved)"}
-{If fresh and seeded_count > 0: "   Hive wisdom: {seeded_count} cross-colony pattern(s) seeded into QUEEN.md"}
+{If re-init: "   🔄 Mode: Re-init (charter updated, state preserved)"}
+{If fresh and seeded_count > 0: "   🧠 Hive wisdom: {seeded_count} cross-colony pattern(s) seeded into QUEEN.md"}
 
-State persisted -- safe to /clear, then run /ant:plan
+💾 State persisted -- safe to /clear, then run /ant:plan
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   Next Up
+🐜 Next Up
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   /ant:plan                 Generate execution plan
-   /ant:status               Check colony state
-   /ant:focus                Set initial focus
+   /ant:plan                 📊 Generate execution plan
+   /ant:status               📋 Check colony state
+   /ant:focus                🎯 Set initial focus
 ```

package/.claude/commands/ant/oracle.md

@@ -278,6 +278,41 @@ Describe the research topic in detail. The more specific, the better the Oracle'
 
 (The user will type their topic via the "Other" free-text option.)
 
+**Question 1.5: Research Brief — Formulate and Approve**
+
+Take the user's raw topic (from `$ARGUMENTS` or Question 1) and reformulate it into a structured research brief. The user may have typed casual natural language — your job is to sharpen it into a clear, well-scoped research prompt that will produce better results.
+
+Display the brief for approval:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔮 R E S E A R C H   B R I E F
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Topic:** {reformulated topic — clear, specific, actionable}
+**Core Question:** {the single most important question this research should answer}
+**Context:** {what we already know from the codebase or user input}
+**Success Criteria:** {what a good answer looks like — what would make this research useful}
+```
+
+Guidelines for formulation:
+- Turn vague topics into specific ones ("auth stuff" → "Authentication architecture: session-based vs token-based for this Node.js API")
+- Add codebase context if relevant (tech stack, existing patterns)
+- Make the core question answerable — not open-ended philosophy
+- Keep success criteria concrete ("A recommendation with trade-offs" not "understand everything")
+
+Then ask the user to approve:
+
+```
+Does this capture what you're looking for? (approve / edit)
+```
+
+- If the user approves: use the reformulated topic as the research topic going forward
+- If the user edits: incorporate their changes, display the updated brief, and ask again
+- Max 2 revision rounds (same as init). After 2, ask for final approval or cancel.
+
+The approved **Topic** from the brief becomes the topic used in all subsequent steps (state.json, plan.json, research-plan.md).
+
 **Question 2: Research Template**
 
 ```

package/.claude/commands/ant/patrol.md

@@ -79,7 +79,7 @@ Extract from COLONY_STATE.json:
 Display audit header:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   C O L O N Y   A U D I T
+🔍 C O L O N Y   A U D I T
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Goal: {goal}
@@ -501,7 +501,7 @@ Display the formatted audit summary:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   A U D I T   R E S U L T S
+📋 A U D I T   R E S U L T S
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Goal: {goal}

package/.claude/commands/ant/run.md

@@ -49,7 +49,7 @@ If `--dry-run`: read COLONY_STATE.json, list remaining incomplete phases
 (applying `--max-phases` cap), display the plan, then stop without executing.
 
 ```
-━━━ A U T O P I L O T   P R E V I E W ━━━
+━━━ 🤖 A U T O P I L O T   P R E V I E W ━━━
 Goal: {goal} | Current: Phase {N} | Remaining: {count} | Max: {max or "all"}
 
   Phase {id}: {name} ({task_count} tasks) -> build -> continue -> advance
@@ -187,7 +187,7 @@ If `--continue` flag was passed: skip this check entirely (user dismissed replan
 If `result.should_replan == true`: **PAUSE** with replan suggestion banner:
 
 ```
-━━━ R E P L A N   S U G G E S T E D ━━━
+━━━ 🔄 R E P L A N   S U G G E S T E D ━━━
 Phases auto-completed: {N} | Learnings accumulated: {learnings_since_last}
 
 The colony has completed {N} phases since the last plan review.
@@ -205,7 +205,7 @@ If `result.should_replan == false`: proceed normally (no pause).
 ### Step 6: Final Summary
 
 ```
-━━━ A U T O P I L O T   C O M P L E T E ━━━
+━━━ ✅ A U T O P I L O T   C O M P L E T E ━━━
 Phases completed: {N} | Elapsed: {Xm Ys} | Now at: Phase {current}
 
 {all complete}  -> Colony goal achieved! Run /ant:seal

package/.claude/commands/ant/swarm.md

@@ -238,7 +238,7 @@ Cross-compare all findings:
 Rank fix options:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-              S O L U T I O N   R A N K I N G
+🏆 S O L U T I O N   R A N K I N G
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 #1 [0.85 confidence] {best solution}

package/.opencode/commands/ant/build.md

@@ -879,6 +879,41 @@ bash .aether/aether-utils.sh activity-log "FLAG" "Watcher" "Created blocker: {is
 
 This ensures verification failures are persisted as blockers that survive context resets. Chaos Ant findings are flagged in Step 5.7.
 
+### Stage Audit Gate (Pre-Synthesis Check)
+
+**This gate runs before Step 5.9. All build stages must have completed before synthesizing results.**
+
+Verify that each of the following stages has a recorded completion status:
+
+| Stage | Steps | Required |
+|-------|-------|----------|
+| Builder waves | Steps 5.1–5.3 | At least 1 worker completed (status "completed") |
+| Watcher | Steps 5.4–5.5 | Watcher returned a result (any status) |
+| Chaos | Steps 5.6–5.7 | Chaos ant returned a result (any status) |
+
+Check by reviewing the in-memory worker results accumulated during Steps 5.1–5.7:
+- `builder_results` — results from all builder wave tasks
+- `watcher_result` — result from Step 5.5
+- `chaos_result` — result from Step 5.7
+
+**If any stage result is absent (stage did not run or returned no result):**
+- HALT — do not proceed to Step 5.9
+- Display:
+  ```
+  Stage Audit FAILED — cannot synthesize results.
+
+  Missing or incomplete stages:
+    {list each missing stage: "Builders — no results recorded" / "Watcher — did not complete" / "Chaos — did not complete"}
+
+  Recovery options:
+    1. Re-run /ant:build to restart this phase
+    2. Run /ant:flags to review blockers
+    3. Run /ant:swarm to auto-repair failed tasks
+  ```
+- Return `{"status": "failed", "summary": "Stage audit failed — stages did not complete"}` and stop.
+
+**If all stages have results (even if some workers failed):** proceed to Step 5.9.
+
 ### Step 5.9: Synthesize Results
 
 **This step runs after all worker tasks have completed (Builders, Watcher, Chaos).**