aspirations-precheck

name	aspirations-precheck
description	Runs pre-selection checks at the start of every aspirations-loop iteration: completion runners, aspiration health, guardrail checks, blocker resolution re-probe, zombie-aspiration scan (Phase 0.5.0a), and recurring-goal surfacing. Use whenever the aspirations loop starts a new iteration and needs to tidy state before /aspirations-select runs. Internal sub-skill — invoked only from inside the orchestrator, never by the user.
user-invocable	false
parent-skill	aspirations
conventions	["aspirations","infrastructure","goal-schemas"]
minimum_mode	autonomous
execution_history	{"total_invocations":0,"outcome_tracking":{"successful":0,"unsuccessful":0,"success_rate":0},"last_invocation":null}
revision_id	skill-bootstrap-aspirations-precheck-f82982
previous_revision_id	null

/aspirations-precheck — Pre-Selection Checks

Runs all checks that must happen BEFORE goal selection each iteration. Ensures completion runners fire, aspiration health is maintained, guardrails are checked, blockers are resolved, and recurring goals are tracked.

Step 0: Load Conventions — Bash: load-conventions.sh with each name from the conventions: front matter.

Step 0a: Budget Meter Start (Magic Wand 2 — g-115-509) — initialize the precheck cost meter. The meter returns "drop" for deferrable sweeps ONLY when the zone is tight (zone_drop_rules.tight). Always-run sweeps (Phase 0-pre, 0-pre2, 0-pre3) NEVER drop. The former wall-clock budget-overrun drop path was REMOVED (g-115-1489 — elapsed measured inter-tool-call LLM latency, not script cost, so it dropped EVERY deferrable sweep every iteration and starved the fresh-eyes/felt-sense/health-regression cadence rituals). elapsed-ms is still logged for telemetry. Decisions log to agents/<agent>/session/precheck-drops.jsonl.

Bash: bash core/scripts/aspirations-precheck-budget-meter.sh start

Before any sweep that the table below marks as medium or deferrable, call meter check <sweep-name> and skip the phase when the response is drop. Always-run sweeps skip the check (they never drop). At the bottom of this SKILL.md (after Phase 1) call meter end to write the summary record.

Phase	Sweep name (for meter check)	Tier
0-pre	tree-debt-gate	always-run
0-pre2	experience-archival-gate	always-run
0-pre2.5	evolution-finalize-gate	always-run
0-pre3	fresh-eyes-code-gate	always-run
0 (Recurring Safety Net)	aspirations-recover-recurring	medium
0 (Monitor Stale)	monitor-stale-check	medium
0.5.0	precheck-eval	medium
0.5b.0.5	blocker-recheck	medium
0.5b.1b	inbox-alert-age-check	always-run
0.5b.2b	handoff-aging-check	always-run
0.5b.3	precondition-defer-recheck	medium
0.5b.4	defer-recheck	medium
0.5b.5	pending-questions-sweep	deferrable
0.5b.6	parent-supersession-sweep	deferrable
0.5b.7	unblock-parent-status-sweep	deferrable
0.5b.8	routing-audit-target-status-sweep	deferrable
0.5b.9	credential-defer-recheck	deferrable
0.5b.10	defer-drift-check	deferrable
0.5b.11	reason-less-blocked-check	deferrable
0.5c	recurring-precondition-sweep	deferrable
0.5e	fresh-eyes-cadence	deferrable
0.5e.5	fresh-eyes-program-cadence	deferrable
0.5e.7	fresh-eyes-tree-cadence	deferrable
0.5f	felt-sense-cadence	deferrable
0.5g	l1-skew-cadence	deferrable
0.5h	health-regression-cadence	deferrable
0.5i	curriculum-cadence	deferrable
0.5j	evolution-cadence	deferrable

Drop semantics — the meter ONLY drops sweeps when:

1. tier == always-run → never drop
2. zone == tight AND tier ∈ zone_drop_rules.tight (default [deferrable]) (The former rule 3 — tier == deferrable AND elapsed_ms > cap_ms — was REMOVED in g-115-1489: wall-clock-since-meter-start is dominated by inter-tool-call LLM latency, not script cost, so it dropped every deferrable sweep every iteration and starved the cadence rituals. Zone-drop is now the sole drop path; elapsed_ms / cap_ms are telemetry-only.)

Fail-open: any meter error returns run. The meter is velocity optimization, not safety gating — never block the loop on a meter bug.

Inputs (from orchestrator)

• Aspirations compact data (loaded at loop entry or refreshed here)

Outputs (to orchestrator)

• Compact aspirations refreshed in context
• Blockers updated in working memory
• Any auto-completed goals logged

Phase 0-pre.0: Live Partner Snapshot

Read the live cross-agent snapshot once per iteration (cheap — single YAML read with file lock). Surface partner.in_flight in the iteration header so the LLM sees it before any reasoning about partner state. See core/config/conventions/coordination.md "in_flight Field".

Bash: team-state-read.sh --json
partner = read agent_status.<partner-name>  # bravo if MIND_AGENT=alpha, vice versa
IF partner.in_flight is non-null:
    age_min = (now - partner.in_flight.claimed_at).total_seconds() / 60
    Output: "▸ Partner ({partner-name}): in_flight {partner.in_flight.goal_id} '{partner.in_flight.title[:40]}' phase={partner.in_flight.phase} ({age_min:.0f}m ago)"
ELSE IF partner.last_active:
    age_min = (now - partner.last_active).total_seconds() / 60
    Output: "▸ Partner ({partner-name}): no in_flight | last_active {age_min:.0f}m ago"

# Inbox-alert backlog surface (g-115-849). Read inbox_alert_backlog from the
# SAME team-state JSON already loaded above (no extra read). The domain inbox
# sweep writes it via core/scripts/inbox-backlog-update.py (null when zero);
# surface the aggregate queue depth so the iteration header shows how many
# alert-derived Unblock goals are waiting un-claimed. Complements the
# Phase 0.5b.1b age-escalation (single-alert notification) with a count.
backlog = team_state.get("inbox_alert_backlog")  # absent/None -> treat as null
IF backlog is a non-null dict AND backlog.get("count", 0) > 0:
    Output: "▸ inbox-alert-backlog={backlog.count} oldest={backlog.oldest_age_hours}h goal={backlog.oldest_goal_id}"
# ELSE: silent (null backlog or zero count)

# Stash partner snapshot in iteration context for downstream phases (select drops
# partner.in_flight.goal_id from candidates; execute Phase 4 re-reads for the
# claim-conflict gate — re-read keeps single source of truth even if partner
# transitioned between this read and the claim attempt).

Phase 0-pre.0a: Partner-Belief Contradiction Check (g-306-29)

Theory-of-Mind contradiction-triggered forced reflection — the CONSUME-side completion of the partner-belief loop (g-306-18 storage → g-306-28 write+consume). Right after the live partner snapshot above (which already surfaced each partner's current_focus), compare that fresh observation against the domain-belief THIS agent holds about each partner. On N CONSECUTIVE contradicting observations (default 2 → no false-trigger on the FIRST), the held belief is REVISED (confidence lowered, or superseded) and the surprise is recorded. A belief only carries a checkable domain when fresh-eyes-review Phase 2.6c wrote it with --domain; free-form beliefs are skipped (conservative — the source of the no-false-trigger guarantee for un-domained beliefs).

Single bash call — daemon read + pure compute (_belief_contradiction.py, unit-tested) + conditional daemon write, all FAIL-OPEN (never blocks the loop).

Bash: bash core/scripts/belief-contradiction-check.sh
# Reads team-state (each partner's current_focus + self.beliefs) + the
# agent-private belief_contradiction_streaks WM slot, runs
# _belief_contradiction.process_all, and on a sustained contradiction lowers/
# supersedes the held belief via team-state-update + records the surprise to the
# evolution log. Prints a one-line summary ("clean" when no domain-belief
# contradiction exists). Tunables: BELIEF_CONTRADICTION_N (default 2),
# BELIEF_CONTRADICTION_MODE (lower|supersede, default lower). Self-limiting: a
# lowered belief decays below threshold and stops re-triggering, so the forced
# reflection fires once per sustained contradiction, not every iteration.

Phase 0-pre.0b: Boredom Signal Surface (observability, no action)

Surfaces the routine-drift counters that Phase 4.1 of the aspirations loop mutates (Blocks A/B/C of signal mutation — see core/config/aspirations-loop-digest.md §Signal Mutation and core/config/rationale/signal-mutation.md). The auto-deep flips still fire in Phase 4.1 whether or not this display runs — this phase is pure observability so the LLM sees its own pattern-matching risk BEFORE selecting the next goal. Mirrors the bash-emitted one-line pattern of Phase 0-pre.0.

No state mutation. Fail-open: if wm-read.sh loop_state returns null (first iteration, fresh session, or counters not yet seeded), skip the display entirely.

Bash: wm-read.sh loop_state
Parse:
    global     = loop_state.session_signals.routine_streak_global   (int, default 0)
    per_goal   = loop_state.routine_streaks                          (dict, default {})
    total_rt   = loop_state.session_signals.routine_count_total      (int, default 0)
    completed  = loop_state.goals_completed_this_session             (list, default [])

IF loop_state is null OR (global == 0 AND no per_goal value > 0):
    SKIP — clean streak state, no signal to surface

# Build one-line summary:
top3       = sorted per_goal entries by value desc, keep value > 0, take 3
per_goal_s = ", ".join(f"{gid}={n}" for gid,n in top3) or "none"
ratio_s    = f"{total_rt}/{len(completed)} routine" if completed else f"{total_rt} routine"

IF global >= 4:
    # Near-threshold warning. global is capped in {0..4}: Block C flips
    # outcome->deep AT routine_streak_global_ceiling=5 and resets to 0
    # (recurring-loop-state-mutate.py), so the stored value never exceeds 4
    # and global==4 means the NEXT routine close auto-deep-flips.
    # Bravo's complaint (2026-04-23): "When 7 routines stack up, I start
    # pattern-matching rather than reasoning." This surface makes the
    # counter visible BEFORE the flip, not silently after.
    Output: "▸ ⚠ BOREDOM: routine_streak_global={global} (auto-deep at 5) | per-goal: {per_goal_s} | session: {ratio_s} — pattern-matching risk, deepen reasoning on next selection"
ELSE:
    # Informational only — streak exists but below near-threshold.
    Output: "▸ Boredom: routine_streak_global={global} (auto-deep at 5) | per-goal: {per_goal_s} | session: {ratio_s}"

Phase 0-pre.0c: Stash Carryover Probe (g-115-1133)

Cheap per-iteration observability surface in the same cluster as Phase 0-pre.0 (partner snapshot) and 0-pre.0b (boredom). Surfaces non-empty git stash entries, which are invisible to git status and therefore an undetectable cross-session/cross-agent working-tree carryover risk. Origin incident (g-115-1127): an externally-created stash (92543f81 at 12:15) silently shelved ~10 min of alpha-LLM working-tree work before manual recovery via git checkout 92543f81 -- <files>. Defense-in-depth observability, NOT a gate — it never blocks, defers, or mutates state; it only warns.

No state mutation. Fail-open: any git error (no repo, detached state) is swallowed — never blocks the loop. Quiet on the common empty case.

# Single local git read (sub-second; reads .git/refs/stash).
Bash: git stash list 2>/dev/null
IF output is non-empty:
    count  = number of stash entries (lines)
    first5 = first 5 entries
    Output: "▸ ⚠ STASH CARRYOVER: {count} non-empty git stash(es) — invisible to `git status`, possible cross-session/cross-agent working-tree carryover. First {min(5,count)}:"
    FOR EACH entry in first5: Output: "    {entry}"
    Output: "    Recover via `git stash show -p stash@{N}` then `git stash pop`, or `git stash drop` once confirmed obsolete (g-115-1127)."
# ELSE: clean — emit nothing (quiet on the common empty case).

Phase 0-pre.0d: Sentinel Battery (g-115-2303 — ONE call replaces the six per-phase wm-reads)

The six force-gate/pending sentinel gates below (Phases 0-pre..0-pre6) are enumerated by ONE script call. The script owns the slot list (core/scripts/_sentinel_registry.py — shared with stale-sentinel-canary.py, single source of truth), so a phase can never silently fall out of the protocol: post-autocompact, "run the battery" is the only line that must survive summarization; the output re-derives the full battery. (Origin g-115-2302: a reconstructed protocol carried 3 of 6 phases and a set sentinel sat unread for 3 iterations.) Adding a new sentinel gate = one registry entry + its consumer phase section below.

Bash: bash core/scripts/precheck-sentinel-battery.sh
IF output says "all N registered sentinels null — no gates to dispatch":
    SKIP directly past Phases 0-pre..0-pre6 (no per-phase wm-reads needed).
FOR EACH "▸ SENTINEL: <slot> (phase <phase>) payload=<json> → dispatch: <section>" line:
    Handle it via the NAMED phase section below. The payload is on the line —
    do NOT re-run wm-read for that slot. The phase bodies keep ownership of
    action + dispatch-stamp + clear (the battery is READ-ONLY).
IF output reports wrapper_failed or error=...:
    Fall back to the per-phase wm-read preambles below (each phase section
    still documents its slot). The battery must never block the loop.

Phase 0-pre: Tree-Debt Critical Gate (g-115-81, source-dispatch g-115-721)

Runs BEFORE Phase 0 completion checks. Consumes the force_tree_maintain WM signal set by:

• iteration-close.sh learning-gate when tree debt exceeds tree_debt_check.debt_threshold * 3 (default 60). Heavy: invoke /tree maintain --backlog.
• tree-encoding-drift-gate.py dual-write (g-115-700) when encoding-drift threshold crossed (default 3). Lightweight: drift acknowledged via log-and-clear; no /tree maintain invocation. Without source-based dispatch, encoding-drift fires /tree maintain --backlog every 3 closes regardless of actual tree-debt (witnessed iter-19/21/23 of bravo session, backlog 145 stays static, 0-action passes accumulate). g-115-721 fix.

Prevents the LLM-abbreviation drift that grew backlog 85→151 over sessions 48-50 — the obligation is now bash-emitted and mandatory, not an advisory INFO line that gets skipped under context pressure.

signal = Phase 0-pre.0d battery payload for force_tree_maintain
         (fallback only if battery errored: Bash: wm-read.sh force_tree_maintain --json)
IF signal is not null:
    source = signal.get("source", "tree-debt-critical")
    IF source == "encoding-drift":
        Output: "▸ TREE-ENCODING-DRIFT GATE: force_tree_maintain source=encoding-drift threshold={threshold} — drift acknowledged, no /tree maintain invocation (lightweight path, g-115-721)"
        # No /tree maintain. The encoding work was supposed to fire via
        # aspirations-state-update Step 8 force_tree_encoding consumer but
        # the routing path bypassed it. The dual-write (g-115-700) was meant
        # as a backstop but /tree maintain --backlog is the wrong action for
        # encoding-drift (it does decompose/distill backlog drain, not
        # missing-encoding catch-up). Acknowledging the drift via clear-only
        # path lets the agent continue without 0-action heavy maintenance.
        # When tree-debt actually becomes critical (debt > threshold * 3 = 60),
        # iteration-close.sh learning-gate writes the signal with
        # source=tree-debt-critical (or missing), routing to the heavy path.
    ELSE:
        # source=tree-debt-critical or missing (legacy/learning-gate path)
        Output: "▸ TREE-DEBT GATE: force_tree_maintain set (source={source}, count > threshold)"
        invoke /tree maintain --backlog
    # Stamp consumer-dispatch timestamp BEFORE clearing — consumption-aware canary
    # requires this; stamp FIRST so interrupts leave the safe direction.
    # Rationale (WHY consumption-aware stamp): core/config/rationale/precheck-gates.md
    printf '"%s"' "$(date +%Y-%m-%dT%H:%M:%S)" | Bash: wm-set.sh force_tree_maintain_last_dispatch
    # Clear signal after handling (one-shot; next iteration's drift gate or
    # learning-gate re-sets if still indicated).
    echo 'null' | Bash: wm-set.sh force_tree_maintain
    # Continue to Phase 0 (compact data may now be stale — Phase 0.5 re-reads it).

Phase 0-pre2: Experience Archival Gate (rb-428)

Runs AFTER tree-debt gate, BEFORE Phase 0 completion checks. Consumes the force_experience_archival WM signal set by experience-staleness-check.sh when experience.jsonl is stale beyond the configured threshold (default 12h, tunable via EXPERIENCE_STALENESS_HOURS or experience_archival_gate.staleness_hours in core/config/aspirations.yaml). Forces the LLM to compose and submit the missed experience record before goal selection proceeds. Prevents the 30–76h drift that g-248-07 surfaced — the bash canary (g-248-16) detects it, this gate forces action.

Pattern mirrors the tree-debt gate above verbatim — wm-read → if non-null → action → wm-set 'null'. One-shot retry: if composition fails, the sentinel persists and the gate fires again next iteration until the LLM succeeds.

signal = Phase 0-pre.0d battery payload for force_experience_archival
         (fallback only if battery errored: Bash: wm-read.sh force_experience_archival)
IF signal is not null:
    Output: "▸ EXPERIENCE-ARCHIVAL GATE: force_experience_archival set (last entry {last_entry_id}, {age_hours}h stale)"
    # Compose the missed experience record per Phase 4.25 instructions
    # (execute-protocol-digest.md §4.25). Use the most-recent deep goal's
    # context reconstructible from:
    #   - working memory: wm-read.sh goals_completed_this_session
    #   - prior iteration's journal entry: agents/<agent>/journal/YYYY/MM/YYYY-MM-DD.md
    #   - retrieval-session.json (tree_nodes_loaded)
    # If no deep goal is reconstructible (e.g., routine-only streak), write a
    # minimal placeholder record with a short `note` explaining the gap, AND
    # clear the sentinel — do not loop.
    # FORCED-FLIP GUARD (g-xw-20260717T220413-01): a "deep" close whose
    # last_outcome_origin is forced (Block C anti-drift streak flip) carries
    # ROUTINE content — its deep label is streak mechanics, not substance.
    # Treat forced-flip closes like routine for THIS gate: if every deep close
    # since the last experience entry was a forced flip, do NOT compose a full
    # experience record from its routine content (that manufactures a
    # contentless filler entry). Take the placeholder path instead (note:
    # "window contained only forced-flip deep closes — no genuine deep content
    # to archive") and clear the sentinel. Genuineness check: the goal record's
    # last_outcome_origin field ("genuine" vs "forced"), or the close output's
    # outcome_in=routine/outcome_out=deep line.
    <compose experience-add.sh JSON payload>
    echo '<payload-json>' | Bash: experience-add.sh
    # Clear signal after successful write (one-shot).
    echo 'null' | Bash: wm-set.sh force_experience_archival
    # Continue to Phase 0.

The gate does NOT write stop-requested or stop-loop — it blocks goal selection via the precheck pattern (LLM sees sentinel, acts, clears it) rather than terminating the loop.

Phase 0-pre2.5: Evolution-Stub Finalize Gate (g-115-2180, rb-428 family)

Runs AFTER the experience-archival gate, BEFORE the fresh-eyes-code gate. Consumes the force_evolution_finalize WM sentinel set by evolution-stub-pending-check.sh (wired into iteration-close.sh's productivity-check maintenance tick, beside evolution-stub-expiry.py).

Why this gate exists. evolution-record.py writes an awaiting_completion stub on every self.md / program.md edit. The LLM is then supposed to call evolution-complete.sh, which records the WHY and — for a MATERIAL agent_self change — fires the guard-380 user notification. Nothing ever prompted that call. 24h later evolution-stub-expiry.py honestly transitions the stub to expired (it refuses to fabricate a rationale, which is correct — see its docstring). Measured 2026-07-14: of 65 material Self edits fleet-wide only 11 (17%) ever reached the user; 22 EXPIRED unnotified — the agent's identity changed and the user was never told. On 2026-04-22 the user explicitly traded "ask first" for "notify after, revert if wrong"; the notify-after half was silently not executing, which made the autonomy unearned. This gate is the missing PROMPT; the expiry sweep remains the honest fallback.

Every sibling obligation in the rb-428 family (tree-debt 0-pre, experience-archival 0-pre2, fresh-eyes-code 0-pre3, metric-encoding 0-pre4) already had a forcing consumer. Self-evolution finalization was the one that did not.

Pattern mirrors Phase 0-pre2 verbatim — wm-read → if non-null → action → clear. One-shot with retry: the producer re-fires the sentinel every iteration until the stub is finalized, so a failed completion is never lost.

Bash: wm-read.sh force_evolution_finalize --json
IF signal is not null AND signal.count > 0:
    Output: "▸ EVOLUTION-FINALIZE GATE: {signal.count} awaiting_completion stub(s) ({signal.material_count} MATERIAL) past {signal.threshold_minutes}min — finalizing before goal selection"
    FOR EACH stub in signal.stubs:
        # Reconstruct the WHY from the session's own record — the journal entry,
        # the goal that motivated the edit, the .history snapshot named in the
        # stub, or the diff_excerpt carried on the stub itself.
        #
        # NEVER FABRICATE. If the rationale genuinely cannot be reconstructed
        # (e.g. the edit was made by a prior session whose context is gone), do
        # NOT invent one — leave the stub and let evolution-stub-expiry.py record
        # `expired` honestly at 24h. A fabricated reasoning string is worse than
        # an absent one (verify-before-assuming.md; and it is exactly what the
        # expiry script's docstring refuses to do). Log the skip and move on.
        Bash: bash core/scripts/evolution-complete.sh \
                --revision-id {stub.revision_id} \
                --reasoning "<>=80-char rationale, reconstructed from real evidence>" \
                --signal-source {sq-012 | fresh-eyes-review | user-directive | ...} \
                --signal-evidence '[{"type":"goal","id":"<goal-id>"}, ...]'
        # For change_class=material + file_kind=agent_self, evolution-complete's
        # Phase 5 AUTO-posts the decisions board AND AUTO-emails the user
        # (guard-380). No manual notification call is needed here.
    # Clear after the pass. If a completion failed, the producer re-sets the
    # sentinel next iteration — do not hand-retry in a loop here.
    Bash: `echo 'null' | wm-set.sh force_evolution_finalize`
    # Continue to Phase 0-pre3.

The gate does NOT write stop-requested or stop-loop — same precheck pattern as its siblings. Reversibility: raise --threshold-minutes in iteration-close.sh to an unreachable value (or remove the one-line call) to stop sentinel writes without touching this consumer.

Scope note. The producer covers the self + program streams ONLY — the two carrying the guard-380 promise. It deliberately does NOT cover script/skill/rule: script-evolution.jsonl measured 152 pending / 1992 expired vs 23 final (a 99% expiry rate) on 2026-07-14, so widening the gate there would fire every iteration forever and train the agent to ignore the sentinel. That backlog is a separate finding with its own goal.

Phase 0-pre3: Fresh-Eyes-Code Dispatch Gate (g-115-281)

Runs AFTER experience-archival gate, BEFORE Phase 0 completion checks. Consumes the fresh_eyes_dispatch_pending WM signal set by iteration-close.sh do_state_update when post-state-update-gate.sh fires (default thresholds: ≥3 core files changed OR ≥150 LOC OR new script under core/scripts/). Forces /fresh-eyes-code dispatch before goal selection so the deferred review backlog cannot accumulate across iterations the way it did before this gate existed (33 core files / 605 LOC silently buffered when no consumer was wired).

Pattern mirrors Phase 0-pre and Phase 0-pre2 verbatim — wm-read → if non-null → action → stamp fresh_eyes_last_dispatch → wm-set 'null'. The signal payload is the full gate JSON ({"fired":true,"core_count":N,"loc_changed":N,"reason":"...","files":[...],"set_at":"..."}), so the dispatcher has the file list + reason without re-running the gate. Rationale (WHY fresh_eyes_last_dispatch stamp): core/config/rationale/precheck-gates.md

signal = Phase 0-pre.0d battery payload for fresh_eyes_dispatch_pending
         (battery omits fired!=true payloads — a printed line IS actionable;
          fallback only if battery errored: Bash: wm-read.sh fresh_eyes_dispatch_pending --json)
IF signal is not null AND signal.fired == true:
    Output: "▸ FRESH-EYES-CODE GATE: fresh_eyes_dispatch_pending set ({signal.core_count} core files, {signal.loc_changed} LOC, reason={signal.reason}) — invoking /fresh-eyes-code before goal selection"
    invoke /fresh-eyes-code with files = signal.files
    # Stamp consumer-dispatch timestamp BEFORE clearing — canary requires advancing
    # timestamp to detect bypass vs. keeping-up. Stamp FIRST for interrupt safety.
    # Rationale (WHY fresh_eyes_last_dispatch stamp): core/config/rationale/precheck-gates.md
    printf '"%s"' "$(date +%Y-%m-%dT%H:%M:%S)" | Bash: wm-set.sh fresh_eyes_last_dispatch
    # Clear signal after dispatch.
    echo 'null' | Bash: wm-set.sh fresh_eyes_dispatch_pending
    # Continue to Phase 0.

The gate does NOT write stop-requested or stop-loop — same precheck pattern as Phase 0-pre and Phase 0-pre2. Reversibility: post-state-update-gate.sh has its own cooldown logic (compares current file set against last-fire snapshot in WM); flipping its threshold envs (CORE_FILE_THRESHOLD, LOC_THRESHOLD) to unreachable values stops sentinel writes without touching this consumer.

Phase 0-pre4: Metric-Encoding Dispatch Gate (g-115-724, rb-917)

Runs AFTER fresh-eyes-code dispatch gate, BEFORE Phase 0 completion checks. Consumes the force_metric_encoding_pending WM signal set by iteration-close.sh do_state_update when post-state-update-metric-gate.sh fires on deep-outcome closures. Content-gate sibling to the rb-428 counter-gate family (tree-debt, experience-archival, fresh-eyes-code, tree-encoding-drift) — catches "LLM did the encoding step on the wrong content" rather than "LLM skipped the encoding step entirely."

Rationale (WHY metric-encoding gate): core/config/rationale/precheck-gates.md (canonical incident g-115-707)

Pattern mirrors Phase 0-pre/0-pre2/0-pre3 verbatim — wm-read → if non-null → action → wm-set 'null'. The signal payload includes candidates, candidate_node_key, candidate_node_file, distinct_count, reason, so the LLM has the extracted findings + recommended target node without re-running the gate or re-scanning prose.

signal = Phase 0-pre.0d battery payload for force_metric_encoding_pending
         (battery omits fired!=true payloads;
          fallback only if battery errored: Bash: wm-read.sh force_metric_encoding_pending --json)
IF signal is not null AND signal.fired == true:
    Output: "▸ METRIC-ENCODING GATE: force_metric_encoding_pending set ({signal.distinct_count} distinct findings, target node={signal.candidate_node_key}, reason={signal.reason}) — encoding into tree before goal selection"
    # LLM action: encode the extracted findings as Verified Values into the
    # recommended tree node (candidate_node_file). Use the candidates list
    # (each entry "value :: context") to assemble the Verified Values block.
    # If the recommended node feels wrong for the findings (e.g., category
    # match was weak), pick a better-fit node — the gate's suggestion is
    # advisory, not authoritative. tree-edit-since.py probes mtimes, so any
    # in-iteration tree edit clears the gate's preconditions for next time.
    Edit {signal.candidate_node_file} OR /tree edit {better-fit-key}:
        Add a Verified Values entry naming each candidate
        Include the source goal-id + completion timestamp
        Cross-reference rb-917 / g-115-707 for the pattern lineage
    # Stamp consumer-dispatch timestamp BEFORE clearing — the stale-sentinel-canary
    # is consumption-aware for this sentinel (g-115-1746), keyed on
    # force_metric_encoding_last_dispatch. Advancing it on ANY handling (encode-and-
    # clear here, OR a guard-655 justified no-dispatch clear when the candidate node
    # is partner-attributed/phantom) tells the canary the consumer kept up, so a
    # keeping-up consumer no longer false-fires the "stale sentinel set for N
    # iterations" Investigate. Stamp FIRST for interrupt safety (mirrors Phase
    # 0-pre / Phase 0-pre3).
    printf '"%s"' "$(date +%Y-%m-%dT%H:%M:%S)" | Bash: wm-set.sh force_metric_encoding_last_dispatch
    # Clear signal after encoding (one-shot; next iteration's iteration-close
    # re-fires the gate if state-update produces new substantive metrics).
    echo 'null' | Bash: wm-set.sh force_metric_encoding_pending
    # Continue to Phase 0.

The gate does NOT write stop-requested or stop-loop — same precheck pattern as Phase 0-pre/0-pre2/0-pre3. Reversibility: edit post-state-update-metric- gate.sh's DISTINCT_COUNT_THRESHOLD to a high value (e.g. 999) to stop sentinel writes without touching this consumer.

Phase 0-pre5: Pipeline-Reconcile Gate (rb-428 family)

Runs AFTER the metric-encoding gate, BEFORE Phase 0 completion checks. Consumes the pipeline_reconcile_pending WM sentinel set by iteration-close.sh do_state_update (Step 8.79b domain-overlay seam) when the just-closed goal was pipeline-affecting — a goal that touched the domain's external lead/outreach/ contact pipeline. Forces a reconcile before goal selection so external pipeline state (e.g. a remote CRM or external pipeline store) is never left stale after a relevant goal closes — the freshness guarantee the hook exists to provide.

Domain-agnostic by construction: the sentinel JSON NAMES the skill to invoke (signal.skill, set by the domain gate at $WORLD_DIR/scripts/pipeline-reconcile-gate.sh). This phase invokes whatever skill the domain named — core hardcodes no domain skill. A fresh world that never sets the sentinel makes this a one-wm-read no-op.

Pattern mirrors Phase 0-pre/0-pre2/0-pre3/0-pre4 verbatim — wm-read -> if non-null -> act -> wm-set 'null'. One-shot with retry: leave the sentinel set if the reconcile fails so the next iteration retries.

signal = Phase 0-pre.0d battery payload for pipeline_reconcile_pending
         (battery omits fired!=true payloads;
          fallback only if battery errored: Bash: wm-read.sh pipeline_reconcile_pending --json)
IF signal is not null AND signal.fired == true:
    skill = signal.skill            # domain-named consumer; core stays agnostic
    goals = signal.goals            # the just-closed pipeline-affecting goal id(s)
    Output: "▸ PIPELINE-RECONCILE GATE: {goals} was pipeline-affecting ({signal.reason}) — invoking {skill} reconcile before goal selection"
    invoke {skill} with args "reconcile --goals {comma-joined goals}"
    # Clear ONLY after the reconcile ran (one-shot; on failure leave the
    # sentinel so the next iteration retries — same fail-open contract as the
    # sibling gates).
    echo 'null' | Bash: wm-set.sh pipeline_reconcile_pending
    # Continue to Phase 0.

The gate does NOT write stop-requested or stop-loop — same precheck pattern as the sibling sentinel gates. Reversibility: the domain gate's PIPELINE_HOOK_ENABLED=0 stops sentinel writes upstream; removing or renaming $WORLD_DIR/scripts/pipeline-reconcile-gate.sh makes the core seam a no-op. Either disables the feature without touching this consumer.

Phase 0-pre6: Pre-Apply-Consult Drift Gate (g-115-2201)

Runs AFTER the pipeline-reconcile gate, BEFORE Phase 0 completion checks. Consumes the force_pre_apply_consult WM sentinel set by iteration-close.sh do_learning_gate (via pre-apply-consult-drift-gate.py) when N consecutive framework-touching deep closes logged retrieval-summary: performed=false (default N=2, --threshold). .claude/rules/code-review-protocol.md step 4 — the pre-apply consultation (retrieve.sh before editing any framework file) — is honor-system and drifted to a 100% miss rate on framework deep goals (g-115-2194 / g-115-2195 / g-115-2179, 2026-07-14; measured cost ~1h re-deriving a guardrail one retrieve.sh would have surfaced). An advisory cannot fix a 3/3 miss — advisory is what step 4 already is — so this ENFORCES it. Complementary to the per-goal advisory pre-apply-consult-gate.py (g-115-826), which fires only on cross-agent Applies; this one keys on work_class == framework (any authorship), closing the own-authored gap those three misses fell through.

Pattern mirrors the sibling gates verbatim — wm-read → if non-null → action → wm-set 'null'. Dormant unless the sentinel is set (only on actual drift), so it is NOT a tax on every close. Does NOT hard-block the Edit tool (a fail-closed per-edit gate can wedge the loop, spec WORK item 3) — same non-wedging precheck pattern as 0-pre..0-pre5.

signal = Phase 0-pre.0d battery payload for force_pre_apply_consult
         (fallback only if battery errored: Bash: wm-read.sh force_pre_apply_consult --json)
IF signal is not null:
    Output: "▸ PRE-APPLY-CONSULT DRIFT GATE: force_pre_apply_consult set ({signal.streak} consecutive framework-deep closes with retrieval performed=false, last={signal.goal_id}) — code-review-protocol step 4 skipped {signal.streak}× on framework work."
    # ACT before goal selection — satisfy ONE branch:
    #  (a) DEFAULT: run the pre-apply consult NOW to re-ground in the discipline
    #      and surface guardrails / reasoning-bank entries that constrain
    #      framework edits (this IS the step the drift skipped):
    #        Bash: retrieve.sh --category "code-review-protocol pre-apply consultation framework edit guardrails" --depth shallow
    #      Read the returned reasoning_bank + guardrails. THEN, when THIS
    #      iteration's selected goal touches a framework file (core/, .claude/,
    #      core/config/, world/conventions/), run retrieve.sh again scoped to
    #      that specific fix BEFORE the first Edit (code-review-protocol step 4).
    #  (b) If this iteration's work provably touches NO framework file, log one
    #      line in the journal instead: "PRE-APPLY-CONSULT GATE: not applicable —
    #      no framework edit this iteration" (the ACCEPTANCE "explicitly logging
    #      why it is not applicable" branch).
    # Clear the sentinel after acting (one-shot; iteration-close re-sets it on
    # continued drift — a single framework-deep close that DID consult resets
    # the streak upstream so it never re-fires).
    echo 'null' | Bash: wm-set.sh force_pre_apply_consult
    # Continue to Phase 0.

The gate does NOT write stop-requested or stop-loop — same precheck pattern as the sibling sentinel gates. Reversibility: raise the drift threshold at the pre-apply-consult-drift-gate.py call site in iteration-close.sh do_learning_gate (--threshold, default 2) to an unreachable value to stop sentinel writes without touching this consumer.

Phase 0: Automated Completion Checks

Run completion check runners to auto-detect completed goals.

File Existence Checks

For each goal with verification.checks containing type: "file_check":

• If goal.recurring: skip
• If file exists at path: mark goal completed, log

Pipeline Count Checks

For each goal referencing pipeline counts:

• If goal.recurring: skip
• Bash: pipeline-read.sh --counts — if threshold met: mark completed

Config State Checks

For each goal referencing config fields:

• If goal.recurring: skip
• Read config file, check field value — if matches: mark completed

Readiness Gate Checks

Check each readiness gate from aspirations-read.sh --meta. Bash: aspirations-meta-update.sh --source world readiness_gates '<JSON>'

Recurring Goal Safety Net

Bash: aspirations-recover-recurring.sh --source world
Bash: aspirations-recover-recurring.sh --source agent

Bash-enforced (g-001-160, rb-295): the script recovers both (a) recurring=true AND status=completed and (b) shape-recurring corrupted goals (recurring=false AND status=completed AND interval_hours AND lastAchievedAt). Idempotent — safe to call every iteration. Prints JSON {recovered: N, goals: [...]}.

Previously an LLM-executed pseudocode step with archive-sweep as the only bash backstop; drift across iterations let corrupted goals persist for days (g-226-22 went 6 days before iter-51 of bravo session 51 caught it manually). The bash command is now the primary path; the archive-sweep recovery branch remains as a full-cycle fallback.

Monitor Stale Check (g-240-37)

Bash: monitor-stale-check.sh --apply

Bash-enforced: for each pending/in-progress Monitor goal whose title contains proc-NNNNNNNNNN, compares the embedded proc-ID against the current run_dir reported by processor-run.sh check-complete. If the goal's ID is older AND its age exceeds 48h, the script auto-completes it with outcome_note: superseded-by-newer-run. Fails open: if processor-run.sh returns no run_dir (fresh install, no completed runs yet), the sweep skips entirely. Prevents Monitor goals from lingering as permanent pipeline debris after their target runs complete.

Hypothesis Expiration Checks

For each goal with hypothesis_id AND status pending/in-progress:
    if now > goal.resolves_by:
        mark status = "expired"
        move pipeline file to archived/

Phase 0.5: Aspiration Health Check

Bash: load-aspirations-compact.sh → IF path returned: Read it
active_count = count of aspirations with status "active"
if active_count < 2:
    invoke /create-aspiration from-self --plan
    log "Aspiration health: below minimum, created new aspirations"

# Consolidation health snapshot — writes the consolidation_health WM slot
# consumed by /create-aspiration Step 1 (consolidation-gate), /aspirations-
# select Phase 2.55 (near-complete/stalled bias), and /aspirations-evolve
# Step E (gap-analysis refusal when portfolio fragmented). Before this
# write, all three readers fail-open on missing slot — gates were silently
# no-op. Fix: 2026-04-22 signal-lifecycle-gate finding.
# Single-writer rule: this is the ONLY writer for consolidation_health.
# Fail-open: wrapper is pure computation + wm-set; errors log to stderr
# and do not block the loop.
Bash: bash core/scripts/consolidation-health.sh --write >/dev/null || echo "[precheck] WARN: consolidation-health snapshot failed (non-fatal; gates will fail-open this iteration)"

Phase 0.5.0-pre2: Self-Drift Gate (Tranche C.5 — rb-390)

Escalation path for class_balance drift. When work_class distribution stays below a critical fraction of its configured target, file an Unblock goal forcing the agent to correct the mix or retune the target. Config: aspirations.yaml → self_drift_gate. Natural-gated (SSOT, rb-395): inactive until BOTH class_balance.targets is non-empty AND self_drift_gate.target_aspiration_id is set. Fail-open: no targets, no target aspiration, or insufficient iterations all exit 0 with no side effects. Cooldown-gated so the same drift does not spawn goal after goal.

Bash: bash core/scripts/self-drift-gate.sh 2>/dev/null || true
# Reads wm.goals_completed_this_session + aspirations.yaml config.
# When fires: writes one Unblock goal per drifted work_class via
#   aspirations-add-goal.sh --source agent, posts a coordination board
#   status, logs to agents/<agent>/session/self-drift-log.jsonl for cooldown.
# Cheap — just fraction arithmetic. No external calls.
# MUST invoke the .sh wrapper — `bash self-drift-gate.py` parses the
# Python docstring as shell and silently no-ops under `|| true`.

Phase 0.5.0-pre: Signal-Refresh Hook (Tranche C — rb-390)

Hook slot for domain-supplied signal refresh before goal selection. Consumed by goal-selector.py criterion 7d (user_signal_boost) — when a fresh snapshot is present the scorer picks up inbox replies, pending-question silence, directives; when absent the scorer contributes zero. Fail-open at every layer — a missing or broken hook does NOT block iteration entry.

Pattern B hook slot (signal-refresh). See core/config/conventions/domain-hooks.md. Core names the slot, the world convention (if it exists) names what to run.

Bash: load-conventions.sh signal-refresh → IF path returned: Read it
# Procedural convention — gate on file EXISTENCE, not load status.
Bash: source core/scripts/_paths.sh && test -f "$WORLD_DIR/conventions/signal-refresh.md" && echo "exists"
IF exists:
    Follow each Step in the convention.
    Any step that fails SHOULD be logged and swallowed — never abort precheck.
ELSE:
    # No domain signal-refresh convention exists (fresh agent). Nothing to do.
    # goal-selector's user_signal_boost dimension will see no snapshot and
    # contribute zero — correct fail-open behavior.

Phase 0.5.0: Scripted Precheck

A single Python invocation performs the entire precheck sweep (zombies, pipeline depth, hypothesis health, accuracy, consolidation, unproductive cycles, user-goal reclassification). Read the JSON summary, act on each flag, then SKIP directly to Phase 0.5a.

This is the ONLY path. The previous toggle + LLM-fallback pseudocode was removed 2026-04-20 — the script is the single source of truth. Any bug in precheck-eval.py MUST be fixed in the script, not patched around by reintroducing a shadow LLM path here.

Bash: bash core/scripts/execution-diary.sh phase-start phase-0.5.0-scripted
Bash: bash core/scripts/precheck-eval.sh run-all
Bash: bash core/scripts/execution-diary.sh phase-end phase-0.5.0-scripted
# Parse the JSON. `flags[]` entries are prefixed with their subcommand
# (e.g. `zombies:needs_complete_review`) because run-all merges sub-reports.
# Action data lives in `results.<subcommand>.*` — the flag signals which
# action block to enter; the payload lives with the subcommand's result.
#
#   zombies:needs_complete_review      → for each entry in results.zombies.zombies[]:
#                                        invoke /aspirations-complete-review Phase 7.4
#                                        with that aspiration and reason="zombie-scan"
#   pipeline-depth:thin_pipeline       → invoke /create-aspiration from-self
#   hypothesis-health:stalled_pipeline → /review-hypotheses --resolve
#   accuracy:accuracy_low              → file Investigate goal targeting
#                                        results.accuracy.worst_strategies
#   consolidation:shallow_portfolio    → consolidation pressure — state-update
#                                        scoring handles it (no direct action)
#   consolidation:stalled_aspirations  → surface results.consolidation.stalled[]
#                                        in output for user visibility
#   cycles:cycles_detected             → for each entry in results.cycles.cycles[]:
#                                        file Investigate goal, using entry.reason
#                                        ("repeated_failure" or "zero_learning_velocity")
#                                        to shape the goal description
#   user-goals:reclassifiable_user_goals → for each entry in
#                                        results.user-goals.candidates[]: invoke
#                                        aspirations-update-goal.sh participants '["agent"]'
#   temp-pressure:temp_drain_needed    → file results.temp-pressure.suggested_goal
#                                        via aspirations-add-goal.sh (title/priority
#                                        HIGH/participants ["agent"]/description from
#                                        the payload) into asp-001, then the loop
#                                        executes /drain-temp. Dedup is already done
#                                        by the check (it suppresses this flag when an
#                                        open drain goal exists — emits temp_drain_pending
#                                        instead). temp_pressure_warn / temp_drain_pending
#                                        are visibility-only — surface in output, no goal.

Phase 0.5a: Pre-Selection Guardrail Check

Bash: bash core/scripts/execution-diary.sh phase-start phase-0.5a-guardrails
Bash: matched=$(bash core/scripts/guardrail-check.sh --context any --phase pre-selection --type both 2>/dev/null)
IF matched.matched_count > 0:
    FOR EACH guardrail in matched.matched:
        Bash: <run {guardrail.action_hint}>
        IF output reveals issues:
            → invoke CREATE_BLOCKER(affected_skill, issue_description, ...)
Bash: bash core/scripts/execution-diary.sh phase-end phase-0.5a-guardrails

Phase 0.5b: Blocker Resolution Check

Bash: bash core/scripts/execution-diary.sh phase-start phase-0.5b-blockers
Bash: wm-read.sh known_blockers --json
IF known_blockers is non-empty:
    FOR EACH blocker WHERE resolution is null:
        # PRIMARY: Did unblocking goal complete?
        IF blocker.unblocking_goal completed: resolve

        # Pre-probe retrieval (G5 / R7): load prior probe-attempt RB before
        # firing the canonical companion script. Without this, repeated
        # blocker re-probes use the same synthetic shape session after session
        # and miss the canonical-probe lesson encoded in rb-246 / guard-147.
        # Per .claude/rules/retrieve-before-deciding.md decision point 4
        # ("re-probing a blocker") and .claude/rules/probe-with-canonical-code-path.md.
        Bash: retrieve.sh --category "blocker probe {blocker.component} canonical companion script" --depth shallow
        From the returned JSON:
          - guardrails[] mentioning canonical-probe, companion-script, synthetic-probe
          - reasoning_bank[] entries describing prior probes of {blocker.component}
            or its sibling components (same skill family)
        Surface to the probe step below:
          - The exact companion_script name(s) the canonical probe should call
          - Failure modes of synthetic probes for this component (rb-246, rb-225)
          - Any prior probe-attempt RB that already established the component
            is fail-open / no-probe (skip the probe, go straight to resolution)
        Fail-open: if retrieve.sh errors, log and proceed to the probe.

        # SECONDARY: Probe infrastructure — but no_probe means "unknown", not "broken"
        Bash: result=$(bash core/scripts/infra-health.sh check {component})
        IF status == "ok": resolve
        ELIF status == "provisionable": attempt provisioning
        ELIF status == "no_probe":
            # No probe exists — can't verify either way.
            # After 3 sessions, clear the blocker and let goals fail-fast if still broken.
            # Re-encountering the failure will re-create the blocker with fresh evidence.
            IF blocker.detected_session + 3 <= current_session:
                resolve with reason "no_probe: cleared after 3-session expiry (fail-open)"
                Log: "BLOCKER EXPIRED (no_probe): {blocker.blocker_id} — letting goals attempt"
        ELSE: log probe failed

    # Phase 0.5b.0.5: Capability Recheck Sweep (see core/scripts/blocker-recheck.sh)
    # For aged blockers routed to [user] or [agent, user], re-run the capability
    # gate against the original failure_reason. If the gate now matches an
    # agent-provisionable capability that was overlooked at creation time,
    # auto-clear the blocker and write an Investigate goal so the retrieval
    # lapse gets learned from instead of buried.
    #
    # Runs BEFORE Phase 0.5b.1 so the user is not notified about a blocker
    # that is actually agent-fixable right now. Dry-run by default — pass
    # --apply to actually clear. Recommended cadence: every aspiration-loop
    # iteration, max-age-hours = config.proactive_escalation.blocker_age_hours.
    IF known_blockers is non-empty:
        Bash: bash core/scripts/blocker-recheck.sh \
                --max-age-hours {config.proactive_escalation.blocker_age_hours} \
                --apply
        # The script's JSON output includes `cleared` count and
        # `investigate_goals_created`. If cleared > 0, those blockers are
        # already resolved in working memory and their unblocking goals are
        # pending; skip to next iteration.

    # Phase 0.5b.1: Proactive escalation for aged blockers
    IF config.proactive_escalation.blocker_age_hours:
        Bash: wm-read.sh proactive_escalation_log --json
        FOR EACH blocker WHERE resolution is null:
            age_hours = hours_since(blocker.detected_at)
            IF age_hours >= config.proactive_escalation.blocker_age_hours:
                # Re-send cooldown uses re_escalation_hours (default 24), NOT blocker_age_hours
                # (first-fire age only). Before g-115-2400 blocker_age_hours served both roles,
                # so the protocol letter demanded a repeat email every 2h (effective 1h with the
                # meta override) for a standing human-gated blocker — a cadence no session obeyed,
                # producing the silent-skip-judgment pattern instead. Coverage entries appended by
                # /notify-user Step 3 (any outbound notification naming the blocker_id, e.g. a
                # completion-report digest) count as escalations here — newest sent_at wins.
                last_escalation = newest entry in proactive_escalation_log where blocker_id == blocker.blocker_id
                IF last_escalation is null OR hours_since(last_escalation.sent_at) >= config.proactive_escalation.re_escalation_hours:
                    Notify the user:
                        category: blocker
                        subject: "Blocker persisting {age_hours:.0f}h: {blocker.reason}"
                        message: |
                            Blocker {blocker.blocker_id} has been active for {age_hours:.0f} hours.
                            Type: {blocker.type}
                            Affected goals: {blocker.affected_goals}
                            Unblocking goal: {blocker.unblocking_goal}

                            The one thing that would unblock this:
                            {action_description_based_on_blocker_type}
                    echo '{"blocker_id":"{blocker.blocker_id}","sent_at":"{now}"}' | Bash: wm-append.sh proactive_escalation_log

    echo '<updated_blockers_json>' | Bash: wm-set.sh known_blockers
Bash: bash core/scripts/execution-diary.sh phase-end phase-0.5b-blockers

Phase 0.5b.1b: Inbox-Alert Age Escalation (g-115-848 — closes g-115-822 finding 2)

Sibling to Phase 0.5b.1 — but the surface scanned is the GOAL QUEUE (asp-115) instead of the working-memory known_blockers slot. When world/scripts/alert-sweep.sh files an Unblock goal for an inbound alert email it stamps origin_signal=f"alert-email:{s3_key}". If no agent claims that Unblock within a few hours, the alert silently ages — no upstream escalation existed before this phase. The bash gate consolidates the scan + cooldown + notify logic into a single script call (rb-428 pattern).

Rationale (WHY severity ladder and shared cooldown): core/config/rationale/precheck-gates.md

Fail-open at every layer: missing config, daemon unreachable, missing asp-115, a failed board scan (-> empty cooldown set, everything eligible fires), and per-goal email-send failures all log to stderr and continue. inbox-alert-age-check.py posts the inbox-alert-aged board breadcrumb it reads back as the shared cooldown; the SKILL.md call is the single invoker.

# Always-run safety gate (g-115-1526) — NOT meter-gated. This gate escalates
# aged unclaimed alert-derived Unblock goals to the user (external party), so it
# must fire reliably even in the tight zone; the cost is one daemon read +
# cooldown check. Sibling of the always-run handoff-aging-check (Phase 0.5b.2b);
# both notification-age safety gates always run. (Medium tier never dropped it
# anyway — zone_drops=[deferrable] only — but the prior `meter check` call
# emitted a spurious unknown-sweep WARN every iteration; sweep_tier() now
# registers it always-run.)
Bash: bash core/scripts/inbox-alert-age-check.sh --apply
# Iterates asp-115 (the alert-sweep target queue). For each pending/in-progress
# Unblock goal with origin_signal=alert-email:* whose age >= threshold:
#   - Scans the coordination board for a recent `inbox-alert-aged` breadcrumb
#     for this goal_id from ANY agent (shared+durable cooldown, g-115-1533).
#   - On miss: fires email-send.sh notification (subject "Unclaimed alert >Nh:
#     <goal title>", body includes goal_id + classifier subject + age + severity).
#   - Posts an `inbox-alert-aged,<goal_id>,severity:<sev>` board breadcrumb
#     regardless of email-send outcome (prevents retry storm on transient email
#     failures — the breadcrumb IS the shared cooldown the next sweep reads).
# JSON output includes `applied`, `skipped_cooldown`, and `failed`. Failure
# counts are stderr-noted only — they do NOT block precheck.

Phase 0.5b.2: Dependency Timeout Escalation

Proactive escalation for dependency-blocked goals approaching the dependency_timeout_hours threshold. This catches goals stuck behind unresolved blocked_by chains — the fail-open timeout in goal-selector.py will eventually clear them, but this gives early warning and takes differentiated action based on the root cause.

Read core/config/aspirations.yaml → multi_agent.dependency_timeout_hours (default 48)
escalation_threshold = dependency_timeout * 0.75  # Notify at 75% of timeout (36h default)

Bash: goal-selector.sh blocked
parsed_blocked = parse JSON output
dependency_blocked = [e for e in parsed_blocked.blocked_goals WHERE block_reason == "dependency"]

IF dependency_blocked is empty: SKIP to Phase 0.5c

Bash: load-aspirations-compact.sh → IF path returned: Read it
Bash: wm-read.sh proactive_escalation_log --json

FOR EACH entry in dependency_blocked:
    blocked_goal = look up entry.goal_id in aspirations compact
    blocked_age = hours_since(blocked_goal.blocked_since)
    IF blocked_age is null: SKIP  # No timestamp — will expire at next goal-selector run (fail-open)
    IF blocked_age < escalation_threshold: SKIP  # Not yet approaching timeout

    # Trace root cause from bottleneck data
    root = find entry in parsed_blocked.bottlenecks where goal_id matches root of chain
    root_goal = look up root.goal_id in aspirations compact

    # Differentiated escalation based on root cause
    IF root goal has participants containing "user":
        # User-action dependency approaching timeout — notify user
        last_dep_esc = find entry in proactive_escalation_log where blocker_id == "dep_{entry.goal_id}"
        IF last_dep_esc is null OR hours_since(last_dep_esc.sent_at) >= escalation_threshold:
            Notify the user about the stale dependency.
            (Check world/forged-skills.yaml for a skill whose triggers match
            "notify the user" and invoke it with a blocker-category payload:
              subject: "Dependency stale {blocked_age:.0f}h: {entry.goal_id} waiting on user"
              message:
                Goal {entry.goal_id} ({entry.title}) has been blocked for {blocked_age:.0f}h
                waiting on {root.goal_id}: {root.title}

                That goal requires user action (participants: [user]).

                If not resolved within {(dependency_timeout - blocked_age):.0f}h,
                the dependency will be cleared automatically (fail-open) and the
                blocked goal will attempt execution.

                The one thing that would help:
                {root_goal.description or root.title}
            If no matching skill is registered, fall back to a participants: [agent, user]
            goal via aspirations-add-goal.sh. Never block on notification failure.)
            echo '{"blocker_id":"dep_{entry.goal_id}","sent_at":"{now}"}' | Bash: wm-append.sh proactive_escalation_log

    ELIF root goal has participants containing "agent" AND root goal status == "pending":
        # Agent-resolvable — boost the blocking goal's priority
        IF root_goal.priority != "HIGH":
            Bash: aspirations-update-goal.sh --source {root_source} {root.goal_id} priority HIGH
            Log: "DEPENDENCY ESCALATION: boosted {root.goal_id} to HIGH (blocking {entry.goal_id} for {blocked_age:.0f}h)"

    # All causes: log the aging dependency for visibility
    Log: "DEPENDENCY AGING: {entry.goal_id} blocked {blocked_age:.0f}h by {root.goal_id} ({root.cause})"

Phase 0.5b.2b: Handoff Aging Escalation (Item 3; bash-enforced g-115-1524)

Cross-agent handoff goals that sit in the world+agent queues past handoff_aging.escalate_hours (default 72) get a coordination-board visibility note so the target agent doesn't miss them. Goal-selector already applies an escalating scoring bonus after warn_hours; this phase is the visibility escalation beyond that.

Bash-enforced (g-115-1524): the previous LLM-iterated pseudocode had NO bash backstop and silently skipped under abbreviation — a fresh-eyes-review on 2026-06-18 found 6 handoffs aged 78-782h with an EMPTY escalation log. handoff-aging-check.{py,sh} consolidates the scan + cooldown + board-post into one script call (rb-428 sentinel-gate family), the bash-enforced sibling of Phase 0.5b.1b's inbox-alert-age-check. Runs unconditionally (no budget-meter gate — same as the original pseudocode; it is a cheap single daemon read + a safety gate whose whole point is that it ALWAYS runs).

Bash: bash core/scripts/handoff-aging-check.sh --apply
# Iterates world + agent queues. For each pending/in-progress goal with
# handoff_to != self AND handoff_created_at age >= handoff_aging.escalate_hours
# AND no cooldown entry within escalate_hours: posts a coordination-board note
# (msg "Handoff aged Nh: <title> [<id>] waiting on <ht>", tags
# handoff-aged,<id>,<handoff_to>) and appends a cooldown entry keyed
# handoff_<id> to wm.proactive_escalation_log. Single-invoker, idempotent
# (cooldown), fail-open at every layer (additive board escalation — a missing
# source just escalates fewer this run; contrast defer-recheck.py's guard-383
# fatal posture, which protects a DESTRUCTIVE defer-clear). JSON output:
# applied / skipped_cooldown / failed.

Note: the target agent ALSO picks this up via its boot-time pending-handoffs scan (boot/SKILL.md Step 1.7) and via goal-selector's escalating handoff_bonus.

Phase 0.5b.3: Structured Precondition Auto-Clear Sweep

Counterpart to the pre-claim re-check in aspirations-execute. Scans goals deferred due to unmet structured preconditions and auto-clears the deferral when the predicates now pass. Without this sweep, a goal deferred by the pre-claim re-check would only re-enter the pool after the 120h defer_reason_timeout_hours fail-open — unacceptable latency when the dependency is actually satisfied minutes later.

See core/config/conventions/preconditions.md for predicate semantics.

Bash-enforced (g-302-02): the previous LLM-iterated loop was replaced by a single Python pass that calls predicate.evaluate_all in-process. This avoids the vacuous-truth bug at the CLI exit-code level — when a goal's preconditions list contains ONLY string/free-form entries, the pre-filter yields zero structured predicates and the script SKIPS rather than clearing (zero predicates ≠ "all pass"). Mirrors defer-recheck.sh / blocker-recheck.sh / monitor-stale-check.sh / pending-questions-sweep.sh bash-consolidation pattern (rb-428 family).

Bash: bash core/scripts/precondition-defer-recheck.sh --max-age-hours 2 --apply
# Iterates world + agent active queues. For each goal with defer_reason
# starting "precondition_unmet:" and age >= --max-age-hours:
#   - Pre-filters verification.preconditions for dict-structured entries
#     (mirrors goal-selector.py L967-981).
#   - If pre-filter empty: SKIP with reason="no structured preconditions
#     to evaluate — defer is free-form, LLM judgment required". Do NOT clear.
#   - Else: predicate.evaluate_all(struct_pcs, mode="all"). When ALL pass,
#     clear defer_reason + defer_reason_set_at via aspirations.py update-goal.
# Metrics log: <WORLD_PATH>/precondition-defer-recheck-metrics.jsonl
# (run_summary per call; precondition_defer_cleared per actual clear).
# Fail-open at every layer: exits 0 even on partial failures.

Cost: one Python pass over active queues per iteration, in-process predicate evaluation. Cheap predicates (file_exists_after, goal_completed_after, file_check) are local I/O. command_succeeds is subject to its configured timeout and allowlist; metric_threshold invokes its allowlisted script.

Phase 0.5b.4: Stale-Defer Dependency Sweep (g-115-154)

Counterpart to Phase 0.5b.3 for free-form dependency defers. Scans goals whose defer_reason names one or more dependency goal-ids (g-NNN-NN) and auto-clears the defer when ALL cited deps are status: completed.

Rationale (WHY stale-defer dependency sweep): core/config/rationale/precheck-gates.md

Bash: bash core/scripts/defer-recheck.sh --max-age-hours 2 --apply
# Reads world+agent queues, sweeps eligible goals in one pass.
# `cleared` count in JSON output names the goal-ids whose defer was lifted.
# Fail-open: script exits 0 on all paths; a non-zero exit is a script bug.

Phase 0.5b.5: Pending-Questions Sentinel-Lifecycle Sweep (g-115-486)

Rationale (WHY pending-questions sentinel sweep): core/config/rationale/precheck-gates.md

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check pending-questions-sweep)
IF decision == "drop": SKIP this phase; continue to Phase 0.5c
Bash: bash core/scripts/pending-questions-sweep.sh sweep --apply
# Reads world+agent aspiration queues to build the completed/superseded
# goal-id set, evaluates the heuristic chain, and (when --apply) atomically
# marks verdict=auto_resolve entries as status=resolved with timestamp.
# Fail-open at every layer: missing files, parse errors, write failures
# all yield empty results without aborting the sweep.

Phase 0.5b.6: Parent-Goal Supersession Sweep (g-248-85)

Rationale (WHY parent-supersession sweep): core/config/rationale/precheck-gates.md (g-268-10, rb-842)

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check parent-supersession-sweep)
IF decision == "drop": SKIP this phase; continue to Phase 0.5c
Bash: bash core/scripts/parent-supersession-sweep.sh --max-age-hours 24 --min-siblings 2 --apply
# Iterates world + agent queues. For each Apply:-parent with reference
# timestamp + ≥2 superseding Design/Apply siblings (sprint-scope only),
# marks parent status=completed with outcome_note "superseded by sibling
# decomposition". Single-writer, idempotent, fail-quiet — same pattern as
# defer-recheck.sh / pending-questions-sweep.sh.
# Metrics log: <WORLD_PATH>/parent-supersession-sweep-metrics.jsonl

Phase 0.5b.7: Unblock-Parent-Status Sweep (g-250-76, rb-908)

Rationale (WHY unblock-parent-status sweep): core/config/rationale/precheck-gates.md (g-250-73, rb-908)

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check unblock-parent-status-sweep)
IF decision == "drop": SKIP this phase; continue to Phase 0.5c
Bash: bash core/scripts/unblock-parent-status-sweep.sh --apply
# (engine: core/scripts/unblock-parent-status-sweep.py behind the wrapper)
# Iterates world + agent queues. For each pending "Unblock:" with a
# parseable parent goal-id whose parent.status is terminal, marks the
# Unblock status=skipped with outcome_note
# "parent resolved without action needed (parent_id=<X>, parent.status=<Y>)".
# Single-writer, idempotent (outcome_note prefix check), fail-quiet —
# same rb-428 pattern as defer-recheck.sh / pending-questions-sweep.sh /
# parent-supersession-sweep.sh.
# Metrics log: <WORLD_PATH>/unblock-parent-status-sweep-metrics.jsonl

Phase 0.5b.8: Routing-Audit Target-Status Sweep (g-115-1353, rb-1478)

Rationale (WHY routing-audit target-status sweep): core/config/rationale/precheck-gates.md (rb-1478)

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check routing-audit-target-status-sweep)
IF decision == "drop": SKIP this phase; continue to Phase 0.5c
Bash: bash core/scripts/routing-audit-target-status-sweep.sh --apply
# Iterates world + agent queues. For each pending/in-progress routing-audit goal
# (discovered_by=post-decompose-routing-audit OR origin_signal/title routing-*)
# with a parseable TARGET id whose target.status is terminal, marks the audit
# goal status=skipped with outcome_note "routing-audit target resolved without
# action needed (target_id=<X>, target.status=<Y>)". Single-writer, idempotent
# (outcome_note prefix check), fail-quiet — same rb-428 pattern as
# unblock-parent-status-sweep.sh / parent-supersession-sweep.sh.
# Metrics log: <WORLD_PATH>/routing-audit-target-status-sweep-metrics.jsonl

Phase 0.5b.8.5: Sweep-Mutation Visibility Surface (g-115-2676)

The three sweeps above (0.5b.6/7/8) mutate a goal's status to a TERMINAL value but nothing surfaces it — a swept goal leaves BOTH the selector candidate list AND its blocked list (rb-4149), so the filer never notices. Canonical incident (2026-07-19): 7 goals silently skipped for days, one a heartbeat-writer fix whose absence had already produced a live near-miss. This consumer reads the EXISTING per-sweep metrics logs (no sweep edits — decoupled, single-source-of-truth) and surfaces apply-mutations newer than a per-agent watermark. ALWAYS-RUN (no budget meter): a visibility surface must never be dropped, else the invisibility bug returns. Cheap (3 tail reads + a watermark r/w); quiet on the common empty case. Fail-open — never blocks the loop.

# --announce posts ONE findings-board message per NEW own-applied mutation
# (own-only: with per-agent watermarks, un-filtered every agent would re-announce
# the same mutation → N board posts). The stdout header line surfaces ALL new
# mutations to THIS agent (that IS the cross-agent visibility); the board post is
# the single cross-agent notification, made once by the applier.
Bash: py -3 core/scripts/sweep-mutation-surface.py --announce
IF stdout contains "SWEEP AUTO-CLOSE":
    Surface the line in the iteration header. If a surfaced goal is one YOU filed
    and you did NOT intend it closed, re-open it
    (aspirations-update-goal.sh <id> status pending). Otherwise informational.
# ELSE: quiet — no new sweep mutations since last surface.

Phase 0.5b.9: Credential Defer Auto-Clear (g-115-1709)

Rationale (WHY credential-defer conservative guard): core/config/rationale/precheck-gates.md

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check credential-defer-recheck)
IF decision == "drop": SKIP this phase; continue to Phase 0.5b.10
Bash: bash core/scripts/credential-defer-recheck.sh --apply
# Scans world + agent queues. For each pending/in-progress goal with
# defer_reason starting "human_blocked:" that is older than max_age_hours (2h):
#   1. Extract env-var key from defer text using conservative pattern set
#      (explicit env-read.sh has KEY > credential KEY > env var/key KEY > fallback)
#   2. If no key extractable → skipped_no_key (human-only defer, never cleared)
#   3. Run: bash core/scripts/env-read.sh has <KEY> → exit 0 means present
#   4. If key still absent → skipped_probe_fail (defer stays)
#   5. If key now present → clears defer_reason via aspirations.py update-goal
#      (calls Python directly, not via bash, for Windows reliability)
# Age gate (2h default): prevents thrash on freshly-set defers.
# Metrics log: <WORLD_PATH>/credential-defer-recheck-metrics.jsonl
# JSON output: {"scanned":N, "eligible":N, "skipped_no_key":N,
#               "skipped_probe_fail":N, "cleared":N, "would_clear":[...],
#               "details":[...]}

Phase 0.5b.10: Defer-Drift Detective Check (g-115-1406, rb defer-drift)

Rationale (WHY defer-drift detective): core/config/rationale/precheck-gates.md (2026-06-12 asp-304 incident)

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check defer-drift-check)
IF decision == "drop": SKIP this phase; continue to Phase 0.5b.11
Bash: bash core/scripts/defer-drift-check.sh --output json
Parse drift_count + drifted[].
IF drift_count == 0:
    continue silently to Phase 0.5b.11   # the clean, common case
ELSE:
    Output: "▸ ⚠ DEFER-DRIFT: {drift_count} goal(s) with a PAST deferred_until + structured-defer marker (deferred_readiness pollution risk)"
    FOR EACH d in drifted[:5]:
        Output: "    {d.goal_id} ({d.source}): deferred_until={d.deferred_until} {d.hours_past}h past | {d.defer_prefix} | pc={d.precondition_status}"
    # File ONE deduplicated Investigate so the drift gets re-gated by judgment.
    # Dedup: skip if an open Investigate with origin_signal
    # "investigate:defer-drift-audit" already exists (a single open re-gate pass
    # covers all current drift — mirrors the rb-428 sweep family's idempotency
    # posture). Uses --goal-field origin_signal (EXACT match on the stable dedup
    # key), NOT --title-contains: the title is prose while the machine key lives
    # in origin_signal, so a title-substring search would be VACUOUS and fail
    # open into a duplicate (g-115-2196 — the exact bug class this call site had
    # with the old nonexistent --status/--contains flags).
    # The key MUST carry the "investigate:" prefix: origin-signal-gate
    # ALLOWED_PREFIXES has no bare "defer-drift-audit" form, so an unprefixed
    # key gets Layer-D auto-derive REWRITTEN to investigate:<title-slug> at
    # filing time and the exact-match dedup here goes vacuous — the sweep then
    # re-files a duplicate every iteration the drift persists (observed
    # 2026-07-17, g-115-2475; second instance of the g-115-2196 vacuous-dedup
    # class, this time on the VALUE not the flag).
    Bash: existing=$(bash core/scripts/aspirations-query.sh --goal-status pending,in-progress --goal-field origin_signal "investigate:defer-drift-audit")
    IF existing is empty:
        Compose an Investigate listing each drifted goal + its precondition_status
        (prose -> re-gate deferred_until to the correct future date from the
        defer_reason; ready -> the gate is merely stale, clear the defer;
        still_unmet -> re-gate). File via aspirations-add-goal.sh into asp-115
        (participants: [agent], category framework-architecture, priority MEDIUM,
        origin_signal "investigate:defer-drift-audit").

Phase 0.5b.11: Reason-Less-Blocked Sweep (g-115-2595, g-115-2591 lineage)

Rationale (WHY reason-less-blocked sweep): a status=blocked goal with an EMPTY Blocker Reference Schema — blocker_ref None, blocked_by [], defer_reason None — escapes EVERY existing guard. gates/blocker_ref.py validates a blocker_ref's structure only when it is paired with a defer_reason; blocker-create-gate.py fires at CREATE time (these goals flip to blocked LATER via a direct status update); blocker-recheck.py only re-probes goals that HAVE a blocker. So when a peer-dependency blocker completes, nothing auto-unblocks the dependent — it strands invisibly (canonical: g-115-2198-b / g-115-2200 stranded ~2 days until felt-sense RAW-read the queue; surfaced by g-115-2591).

SELF-CONTAINED --apply (rb-428 family — NOT the defer-drift detective pattern of 0.5b.10). The SCRIPT files ONE deduplicated reconcile Investigate itself (dedup by the SAME active read that finds the blocked goals — guard-487 fail-closed, guard-383 fatal-on-read-error so it can never file blindly) when reason-less goals exist and no open audit does. The LLM's ONLY job here is to surface the WARN — do NOT compose or file the Investigate (the --apply flag already did, bash-side). This is deliberate: the exact failure g-115-2595 fixes is LLM-discretionary steps drifting (guard-616/rb-616), so the filing must be bash-enforced, not left to LLM memory.

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check reason-less-blocked-check)
IF decision == "drop": SKIP this phase; continue to Phase 0.5c
Bash: bash core/scripts/reason-less-blocked-check.sh --apply --output json
Parse reason_less_count + reason_less[] + investigate_filed + open_audit_goal_id.
IF reason_less_count == 0:
    continue silently to Phase 0.5c   # the clean, common case
ELSE:
    Output: "▸ ⚠ REASON-LESS-BLOCKED: {reason_less_count} status=blocked goal(s) with an EMPTY Blocker Reference Schema (no blocker_ref / blocked_by / defer_reason) — invisible to selection, blocker-recheck, AND quiescence"
    FOR EACH e in reason_less[:5]:
        Output: "    {e.goal_id} ({e.source}) [{e.aspiration_id}] intended={e.intended_agent}: {e.title}"
    IF investigate_filed:
        Output: "    → filed reconcile Investigate {investigate_filed} (asp-115) — reconstruct each real blocker into blocked_by/blocker_ref, OR unblock to pending if the premise is gone (route lane-owned goals to their owner, do NOT appropriate)"
    ELIF open_audit_goal_id:
        Output: "    → open reconcile Investigate {open_audit_goal_id} already covers these (dedup — no duplicate filed)"
    # No LLM filing here — the --apply flag already filed-or-deduped bash-side
    # (drift-proof, the whole point of g-115-2595). Continue to Phase 0.5c.

Phase 0.5c: Recurring-Goal Precondition-Filter lastAchievedAt Sweep

Rationale (WHY shape-recurring-trap sweep): core/config/rationale/precheck-gates.md

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check recurring-precondition-sweep)
IF decision == "drop": SKIP this phase; continue to Phase 0.5e
Bash: py core/scripts/recurring-precondition-sweep.py
# Iterates world + agent queues. For each recurring goal past its time
# gate with a failing structured precondition, advances lastAchievedAt
# to now via aspirations.py update-goal. Does NOT increment
# consecutive_routine (the goal was shelved, not closed).
# Fail-open: always exits 0. Output is one line per advance.

Companion to cargo-cult auto-extend in core/scripts/cargo-cult-detector.py: auto-extend fixes the "detector fires too often" symptom; this sweep fixes one of the root causes for precondition-gated goals.

Phase 0.5e: Fresh-Eyes Cadence Check

Periodic autonomous portfolio review. Every 25 completed goals (configured in core/config/aspirations.yaml → fresh_eyes_review.goal_cadence), produce a local portfolio-direction briefing examining:

1. Is the current Self still right?
2. Are we working on the right problems?

The briefing is archived to agents/<agent>/temp/ and the agent self-assesses the outcome (act_now / act_later / no_change). No email is sent and no pending-question is filed — the user reviews via git log and tracked signals at their own pace.

The cadence gate is script-enforced (fresh-eyes-cadence-check.sh) and fail-open — if it errors, the loop continues without review. Cadence is purely goal-count-based (the skip_if_pending gate was removed 2026-05-19 — see fresh-eyes-cadence-check.py header).

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check fresh-eyes-cadence)
IF decision == "drop": SKIP this phase; continue to Phase 0.5e.5
Bash: core/scripts/fresh-eyes-cadence-check.sh
IF exit 0 (fire):
    Output: "▸ Fresh-eyes review cadence crossed — assembling briefing"
    Invoke /fresh-eyes-review --cadence
IF exit 1 (noop):
    # Cadence not crossed OR config disabled — continue silently (no output)
    continue
Bash: echo "aspirations-precheck phase documented"

Distinct from sq-012 (post-goal, narrow) and strategic-scan S3b (autonomous, category coverage only) — this is the periodic local self-audit that produces a portfolio-direction briefing on a deliberate low-frequency cadence. See .claude/skills/fresh-eyes-review/SKILL.md.

Phase 0.5e.5: Fresh-Eyes PROGRAM Cadence Check

Sibling to Phase 0.5e. Every 100 completed goals (configured in core/config/aspirations.yaml → fresh_eyes_program.goal_cadence), produce a local briefing targeting world/program.md (The Program — the world's shared purpose) examining two questions:

1. Is The Program still the right shared purpose for this world?
2. Do both agents' Selfs still serve The Program, or have they drifted?

Same infrastructure as fresh-eyes-review (fresh-eyes-cadence-check.sh, fresh-eyes-record-tick.sh), parametrized via --config-block fresh_eyes_program so the two rituals use disjoint config blocks and WM slots. Closes the "program.md has no systematic evolution path" gap called out in core/config/conventions/domain-hooks.md → Directional Context.

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check fresh-eyes-program-cadence)
IF decision == "drop": SKIP this phase; continue to Phase 0.5f
Bash: core/scripts/fresh-eyes-cadence-check.sh --config-block fresh_eyes_program
IF exit 0 (fire):
    Output: "▸ Fresh-eyes PROGRAM cadence crossed — assembling shared-purpose briefing"
    Invoke /fresh-eyes-program --cadence
IF exit 1 (noop):
    # Cadence not crossed OR config disabled — continue silently (no output)
    continue

Lower-frequency than fresh-eyes-review (100 vs 25) because shared purpose changes much less frequently than individual agent identity. See .claude/skills/fresh-eyes-program/SKILL.md.

Phase 0.5e.7: Fresh-Eyes TREE Cadence Check (S5)

Sibling to Phase 0.5e and 0.5e.5. Every 200 completed goals (configured in core/config/aspirations.yaml → fresh_eyes_tree.goal_cadence), produce a local briefing targeting the knowledge tree's top-level taxonomy (the L1 set) examining:

Are the four L1s still the right top-level cuts for the knowledge tree?

Same infrastructure as the two sibling rituals (fresh-eyes-cadence-check.sh, fresh-eyes-record-tick.sh), parametrized via --config-block fresh_eyes_tree so the three rituals use disjoint config blocks and WM slots. If taxonomy changes are desired, the user invokes the S8 apply scripts (l1-domain-rename.sh, l1-domain-add.sh) manually.

# Budget meter — Magic Wand 2 (g-115-509). Skip when zone==tight.
Bash: decision=$(bash core/scripts/aspirations-precheck-budget-meter.sh check fresh-eyes-tree-cadence)
IF decision == "drop": SKIP this phase; continue to Phase 0.5f
Bash: core/scripts/fresh-eyes-cadence-check.sh --config-block fresh_eyes_tree
IF exit 0 (fire):
    Output: "▸ Fresh-eyes TREE cadence crossed — assembling L1 taxonomy briefing"
    Invoke /fresh-eyes-tree --cadence
IF exit 1 (noop):
    # Cadence not crossed OR config disabled — continue silently (no output)
    continue
Bash: echo "aspirations-precheck phase documented"

Distinct from /tree maintain (per-node structural ops, autonomous + manual), /reflect Step 7 Tree Health Lint (per-node staleness + width), and l1-skew-check.py (S1 passive measurement at 50 goals). Those check NODE health or accumulate quantitative skew evidence; this ritual asks the structural-design question that no automated gate ever surfaces. Lower-frequency than program (200 vs 100) because L1 changes are high-blast-radius. See .claude/skills/fresh-eyes-tree/SKILL.md.

Phase 0.5f: Felt-Sense Check-In Cadence

Periodic autonomous structured 7-lane self-audit. Every 75 completed goals (configured in core/config/aspirations.yaml → felt_sense.goal_cadence), the agent runs the full sweep: memory hygiene, out-of-cycle completions, unblocks, forward backlog,