aspirations-state-update

name	aspirations-state-update
description	Runs the State Update Protocol (Phase 8 of the aspirations loop) after EVERY goal execution: 9 steps plus Step 3.5 Team State, Step 8.5 Actionable Findings Gate, Step 8.75 Execution Reflection, Step 8.76 Skill Quality, Step 8.77 User-Notable Event Push Classifier, and Step 8.11 Execution Feedback. Use whenever a goal finishes executing. Outcome_class controls depth — routine: Steps 1-4 + abbreviated journal; deep: full protocol with immediate tree encoding. MANDATORY — skipping or abbreviating kills the learning loop.
user-invocable	false
parent-skill	aspirations
triggers	["run_state_update()"]
conventions	["aspirations","tree-retrieval","goal-schemas"]
minimum_mode	autonomous
revision_id	skill-bootstrap-aspirations-state-update-4155f1
previous_revision_id	null

State Update Protocol

Invoked after EVERY goal execution as Phase 8 of the aspirations loop. Accepts outcome_class (default: "deep").

Abbreviation Policy

Mandatory writes for this obligation: see core/config/obligation-schema.yaml → obligations.state. Abbreviation is permitted only when context_budget.zone == tight. Zone is distance-to-autocompact, not raw usage — see core/scripts/context-budget-status.py classify_zone for the source of truth. Before abbreviating, Bash: bash core/scripts/context-budget-banner.sh and quote its output; that line is the evidence that makes the "tight" claim verifiable. (Routine outcomes follow the Steps 1-4 + 7r path below — that is a scope-of-work distinction, NOT the abbreviated pattern.) When abbreviating, log TWO lines in the journal entry (in this order): OBLIGATION ABBREVIATED: state — {condition} CTX: raw N% | of-autocompact N% | zone tight | headroom N tokens | env ... | updated ... The banner line must be the actual output captured from the banner script. core/scripts/context-citation-audit.sh audits the pair. Then satisfy minimum_inline. Otherwise invoke this Skill literally. The learning-gate audit (Phase 9.5d) scans those journal lines and logs false claims to agents/<agent>/session/obligation-audit.jsonl.

Inputs (from orchestrator)

• outcome_class: Outcome tier ("routine" or "deep") — default "deep"
• source: Queue origin ("world" or "agent") — pass --source {source} to all aspirations-*.sh calls

For deep outcomes (default — all non-routine goals): all steps run (1-8, 8.5, 8.75). Step 8 performs IMMEDIATE tree encoding — the full precision manifest, curator quality gate, consistency scan, and tree write. This is the highest-fidelity path. Learning is the mission — every non-routine outcome gets immediate encoding.

For routine outcomes (recurring goal, no findings): Steps 1-4 run (bookkeeping), then an abbreviated Step 7 (journal), then RETURN. Steps 5-8.75 are skipped because there is genuinely no insight to encode, no triggers to check, and no capability to propagate.

The loop MUST NOT continue to Phase 9 until state update is complete.

---

Step 0: Load Conventions — Bash: load-conventions.sh with each name from the conventions: front matter. Read only the paths returned (files not yet in context). If output is empty, all conventions already loaded — proceed to next step.

State Update Protocol

After EVERY goal execution (Steps 1-8, plus Steps 8.5 and 8.75 for deep outcomes):

1. UPDATE goal status via Bash: `aspirations-update-goal.sh --source {source} <goal-id> status <status>`
   - `aspirations-update-goal.sh --source {source} <goal-id> completed_date <today>` if completed
   - `aspirations-update-goal.sh --source {source} <goal-id> achievedCount <N+1>`
   - Update streak counters via additional update-goal calls
   - If recurring: compute elapsed = hours_since(lastAchievedAt) BEFORE updating.
     Bash: `aspirations-update-goal.sh --source {source} <goal-id> lastAchievedAt "$(date +%Y-%m-%dT%H:%M:%S)"`
     If elapsed > 2 * interval_hours: new_streak = 1.
     Otherwise: new_streak = currentStreak + 1.
     ALWAYS update both: currentStreak = new_streak, longestStreak = max(new_streak, longestStreak).

1.1. CLEAR iteration-checkpoint (goal is finished — anchor no longer applies).
     The checkpoint was written by `/aspirations-select` Phase 2.95 and must be
     cleared now so a post-autocompact restart doesn't resume a completed goal.
     Fires for ALL outcome classes (routine and deep) — Step 1's goal-status
     update is the point-of-no-return. See `core/scripts/postcompact-restore.py`
     for the read side.
     Bash: rm -f agents/<agent>/session/iteration-checkpoint.json

2. Aspiration progress is updated automatically by update-goal when status changes

3. UPDATE last_session via Bash: `aspirations-meta-update.sh --source {source} last_updated <today>`
   - Append goal completion to goals_completed_this_session in working memory:
     # Keys read by goal-selector.py streak_momentum + recurring_saturation +
     # per_goal_saturation + class_balance_bonus — do not rename.
     # work_class is optional (Tranche C, rb-390): scorer's class_balance_bonus
     # reads it when present, excludes the entry from the distribution when absent.
     # Goals with no work_class field on the goal record: omit the key entirely
     # (do NOT write "work_class":"unclassified" — empty key = excluded).
     Bash: echo '{"goal_id":"<goal-id>","aspiration_id":"<aspiration-id>","recurring":<true|false>[,"work_class":"<class>"]}' | wm-append.sh goals_completed_this_session
   - Set aspiration_touched_last in working memory:
     Bash: echo '"<aspiration-id>"' | wm-set.sh aspiration_touched_last
   - Set current_goal_source in working memory:
     echo '"{source}"' | Bash: wm-set.sh current_goal_source
   - Set last_goal_category = goal's resolved category (from goal-selector.py output):
     Bash: echo '"<category>"' | wm-set.sh last_goal_category

3.5. TEAM STATE UPDATE (multi-agent situational awareness)
   # Update world/team-state.yaml with this goal completion.
   # Gives the other agent instant awareness of what just happened.
   Bash: team-state-update.sh --field recent_completions --operation append \
     --value '{"goal_id":"<goal-id>","title":"<goal.title>","completed_by":"<AGENT_NAME>","completed_at":"<now>","key_finding":"<one-line factual summary of what was produced/discovered>"}'
   Bash: team-state-update.sh --field agent_status.<AGENT_NAME>.last_active --value '"<now>"'
   Bash: team-state-update.sh --field agent_status.<AGENT_NAME>.current_focus --value '"<goal.category or aspiration title>"'
   # Increment session goal count in working memory (read current, +1)
   # The actual agent_status.session_goals_completed is updated at consolidation

4. INCREMENT session_count via Bash: `aspirations-meta-update.sh --source {source} session_count <N>`
   (Note: session_count increments once per /aspirations loop invocation,
    NOT once per goal. Goals within the same loop share a session.)

# ── Step 4.5: Outcome-Metrics Cadence Guard (routine outcomes) ─────
# Step 8.12 fires the outcome-observation hook for non-routine outcomes only.
# Routine-only sessions would otherwise skip the hook indefinitely and leave
# outcome-metrics.yaml silently stale (20-day window observed 2026-04-24 to
# 2026-05-14, see world/conventions/outcome-observation.md "Cadence Guarantee").
# This guard fires the same wrapper opportunistically when the metrics file
# is missing or > 24h stale. Wrapper exits 0 unconditionally — fail-open.
IF outcome_class == "routine":
    Bash: source core/scripts/_paths.sh && \
          METRICS_FILE="$WORLD_DIR/outcome-metrics.yaml"; \
          if [ ! -f "$METRICS_FILE" ] || \
             [ $(( ( $(date +%s) - $(stat -c %Y "$METRICS_FILE") ) / 3600 )) -ge 24 ]; then \
              bash core/scripts/outcome-observation-run.sh "{goal.id}" routine; \
          fi

# ── Routine outcome learning path ──────────────────────────────────
# Principle: we are here to learn. Even routine outcomes deserve operational scrutiny.
# This replaces the bare early return with lightweight but meaningful reflection.
IF outcome_class == "routine":

    # Step 5r: Lightweight operational reflection (NOT skipped for routine)
    # Ask ONE question from the routine_lens template, rotating so each
    # execution of a recurring goal gets a DIFFERENT question over time.
    Read core/config/reflection-templates.yaml → routine_lens.questions
    question_index = hash(goal.id + str(goal.achievedCount)) % len(routine_lens.questions)
    routine_q = routine_lens.questions[question_index]
    Evaluate: {routine_q} applied to this routine goal's outcome
    IF reflection produces a non-trivial insight (not a restatement of known facts):
        # Capture as a lightweight reasoning bank entry
        Bash: reasoning-bank-read.sh --category {goal.category}
        IF NOT semantically overlapping with existing entries:
            Create reasoning bank entry via reasoning-bank-add.sh:
              title: "Routine insight: {concise name}"
              type: success
              category: goal's category
              content: the operational insight
              applies_to: <any|framework|domain|specific>  # REQUIRED. routine ops insights about external services → domain; framework-internal → framework; cross-cutting → any
              when_to_use: when this insight applies
              source_goal: goal.id
              tags: ["routine-operational-insight"]
            Log: "ROUTINE OPERATIONAL INSIGHT: {title} from {goal.id}"
        routine_insight_found = true
        routine_insight_text = the operational insight (1-2 sentences)
    ELSE:
        routine_insight_found = false
        routine_insight_text = "No new insight."

    # 7r. WRITE enhanced journal entry — delegated to journal-append.sh
    #     (g-248-35, rb-428 family). The wrapper handles templating + citation
    #     scan + journal-index merge/add fallback as a single bash-enforced unit.
    #     iteration-close.sh do_state_update calls it automatically — this
    #     pseudocode documents the LLM-residue path for /reflect and ad-hoc
    #     callers that bypass iteration-close.
    Bash: `journal-append.sh --goal {goal.id} --outcome-class routine --summary "{routine_q[:60]}: {routine_insight_text}"`
    # The wrapper appends to agents/<agent>/journal/YYYY/MM/YYYY-MM-DD.md with
    # stable section headers (## title, Outcome:, Summary:) AND tries
    # journal-merge.sh first, falling back to journal-add.sh on no-existing-
    # session-record. NEVER inline the markdown assembly + index call here —
    # /verify-learning Section BE checks the wrapper is the single writer.

    # Step 8r: Routine accumulation check (every 5th routine for this goal)
    # Over time, accumulated routine executions can reveal trends worth encoding.
    IF goal.achievedCount >= 5 AND goal.achievedCount % 5 == 0:
        node=$(bash core/scripts/tree-find-node.sh --text "{goal.category}" --leaf-only --top 1)
        IF node found:
            Read node.file
            # Check: does the pattern of routine execution reveal a trend?
            # e.g., "always succeeds", "timing is consistent", "never produces findings"
            IF routine execution pattern reveals an encodable trend:
                Append one-line trend observation to node's Key Insights
                # T21 PostToolUse hook (tree-front-matter-sync.py) bumps
                # both the .md front matter AND _tree.yaml last_updated
                # automatically — no explicit register call needed.
                Log: "ROUTINE ACCUMULATION: {goal.category} trend encoded to {node.key}"

    RETURN  # Remaining deep-only steps (5-8.75) still skipped
# ── End routine outcome learning path ─────────────────────────────

5. CHECK evolution triggers — Read `core/config/evolution-triggers.yaml` (definitions) and `world/evolution-triggers.yaml` (state) and check performance-based triggers (see Phase 9 for full protocol). Fixed session-count trigger is DEPRECATED.
   # MR-Search exploration mode gating (Priority 3):
   # Exploration goals are shielded from negative evolution triggers.
   IF goal.execution_mode == "exploration":
       SKIP accuracy_drop and consecutive_losses trigger checks
       Log: "▸ Evolution triggers: SKIPPED (exploration mode — shielded from negative triggers)"
   # Standard goals: check all triggers normally

6. UPDATE readiness gates via Bash: `aspirations-meta-update.sh --source {source} readiness_gates '<JSON>'`
   - Re-run gate checks after any state change

7. WRITE journal entry — delegated to journal-append.sh (g-248-35, rb-428 family)
   The wrapper handles markdown templating + citation scan + journal-index
   merge/add fallback as a single bash-enforced unit. iteration-close.sh
   do_state_update calls it automatically — this pseudocode documents the
   LLM-residue path for /reflect, /aspirations-consolidate, and ad-hoc
   callers that bypass iteration-close.

   Bash: `journal-append.sh --goal {goal.id} --outcome-class {routine|deep} --summary "..."`

   The wrapper:
     - Appends to agents/<agent>/journal/YYYY/MM/YYYY-MM-DD.md with stable section
       headers (## title, Outcome:, Summary:) — /verify-learning Section BE
       checks this contract.
     - Scans summary for rb-NNN / guard-NNN citations and increments
       utilization.times_cited via reasoning-bank-increment.sh /
       guardrails-increment.sh.
     - Tries journal-merge.sh first, falls back to journal-add.sh on no
       existing session record (AUTHORITATIVE OWNER — only exception is
       /stop step 3.e for emergency cleanup).
     - Fail-open: write failures log to stderr but never block the iteration.

   NEVER inline the markdown assembly + index call here. Drift between this
   pseudocode and the wrapper is the failure mode rb-428 was filed against;
   keeping the wrapper as the single source of truth is the fix.
   /boot Step 11 writes journal .md content only — it does NOT touch the
   journal index.

8. REFRESH memory tree (dynamic lookup)

   The encoding mechanics from this step onward — scoring formula, curator
   gate, precision-manifest extraction, decision-rule append, capability
   propagation, and cross-agent coordination — live in
   `core/config/encoding-protocol-digest.md` (E16). This step is the
   autonomous-mode consumer of that digest; `/encode-session` Lane 1 is
   the chat-mode consumer. **Edit the digest BEFORE editing this step —
   drift between the two skills is what the digest exists to prevent.**

   PLACEMENT CHECK (rules vs. conventions): Before writing to
   `.claude/rules/*.md` or `core/config/conventions/*.md` (as part of an
   encoding side-effect), determine scope. If the content mentions a
   brand, product, domain-specific identifier, or external service name,
   it belongs in `world/conventions/` (the Pattern B hook slot per
   `domain-hooks.md`), NOT in a core rule or core convention. Core rules
   and conventions must remain domain-agnostic per
   `.claude/rules/domain-free-examples.md`.

   - Find target node:
     node=$(bash core/scripts/tree-find-node.sh --text "{goal.category}" --leaf-only --top 1)
     # Returns: {key, score, file, depth, summary, node_type}
   - Read node.file
   - Navigate to node.file (use `Edit` to update — never `Write` on existing node files)
   # MR-Search episode chain encoding (Priority 1):
   # When episode_history is present, encode the PROGRESSION of understanding,
   # not just the final outcome. The chain shows how the agent's approach evolved.
   # episode_history is already in context from Phase 4-chain (set via aspirations-update-goal.sh --source {source}).
   IF goal has episode_history AND episode_history is non-empty (multi-episode goal):
       Include episode progression in tree encoding:
       - "## Episode Progression" section: summarize how approach evolved
       - Note which approach finally succeeded and why prior attempts failed
       - Extract transferable lesson: "For similar goals, start with approach N"
       Log: "▸ Tree encoding: including {len(episode_history)} episode progression"
   # Meta-strategy encoding guidance
   Bash: meta-read.sh encoding-strategy.yaml
   # Apply precision_emphasis_categories, narrative_compression_level,
   # and decision_rule_preference as advisory guidance for tree encoding.

   # ── Investigation encoding obligation ──────────────────────────────
   # Investigation/research/audit goals produce findings as their PRIMARY output.
   # Unlike development goals that change external state, investigation goals
   # produce understanding. The "new insight" gate must account for this:
   # findings in the execution trace ARE the insight, even if nothing external changed.
   is_investigation_goal = goal.title starts with (Investigate, Research, Audit, Analyze, Diagnose, Trace, Review)
                        OR goal.category in ("analysis", "diagnosis", "research")
   IF is_investigation_goal AND len(result_text) > 500:
       force_encoding = true
       Log: "▸ Investigation encoding obligation: forcing insight branch ({len(result_text)} chars)"
   ELSE:
       force_encoding = false

   # ── Encoding anti-drift override (set by orchestrator Phase 8.0.6) ──
   Bash: wm-read.sh force_tree_encoding 2>/dev/null
   IF force_tree_encoding == "true":
       force_encoding = true
       echo '"false"' | Bash: wm-set.sh force_tree_encoding
       Log: "▸ Step 8: forced encoding from anti-drift safeguard"
   # ── End encoding obligation checks ─────────────────────────────────

   # ── Encoding decision (default: ENCODE) ─────────────────────────
   # The default is to ENCODE. Skip ONLY for structural reasons.
   # "Nothing new learned" is NOT a valid skip reason — the curator gate (c.5) filters quality.
   skip_encoding = false
   IF len(result_text) < 100:
       skip_encoding = true
       Log: "▸ Step 8: skipping encoding — insufficient output ({len(result_text)} chars)"
   ELIF goal.status in ("blocked", "skipped"):
       skip_encoding = true
       Log: "▸ Step 8: skipping encoding — goal was {goal.status}"
   # ── End encoding decision ──────────────────────────────────────

   - If NOT skip_encoding OR force_encoding:
     # ── Load experience record for full-fidelity encoding ──────────
     # Context window content fades by the time encoding runs.
     # The experience file preserves verbatim_anchors and full reasoning traces.
     IF goal has experience_ref (set by Phase 4.25):
         experience_content = Read agents/<agent>/experience/{experience_ref}.md
         # Use verbatim_anchors and full reasoning trace for precision extraction below,
         # supplementing whatever remains in the context window.
         Log: "▸ Step 8: loaded experience {experience_ref} for full-fidelity encoding"
     # ── End experience record loading ──────────────────────────────

     # ── E13 chunked-encoding consumer ──────────────────────────────
     # Phase 4.05 may have emitted chunked observations to sensory_buffer
     # when the execution was long-form. Each chunk is scored independently
     # against the encoding gate so multi-finding executions surface as
     # multiple tree updates instead of one collapsed paragraph. Schema
     # and pipeline: encoding-protocol-digest.md Section F.
     Bash: wm-read.sh sensory_buffer --json
     chunks_for_this_goal = [e for e in sensory_buffer
                             if e.source_goal == goal.id AND e.chunk_idx is defined]
     IF chunks_for_this_goal is non-empty:
         Log: "▸ Step 8: E13 found {len(chunks)} chunks for this goal — encoding each independently"
         For each chunk in chunks_for_this_goal:
             Run Section A encoding-gate against chunk.scores
             IF passes:
                 Build a per-chunk precision payload from chunk.chunk_text
                 Run Section B (curator) + Section C (tree write) on this chunk
             ELSE:
                 Drop (overflow handles re-consideration)
         # The chunked path REPLACES the single-bundle encoding below for
         # this goal. SKIP steps a-f after the chunk loop completes.
     # If no chunks: continue to step a (single-bundle encoding, the
     # original path).
     # ── End E13 chunked consumer ───────────────────────────────────

     a. EXTRACT PRECISION: Scan execution context for exact values. Build precision manifest —
        each item: {type, label, value (VERBATIM), unit, context}. Types: threshold, formula,
        constant, reference, measurement, config_value. Include ALL numbers, code refs, error codes,
        thresholds, formulas, config values, commit hashes, line numbers. When in doubt, INCLUDE.
        See core/config/conventions/precision-encoding.md for schema and extraction heuristics.
     b. COMPOSE PRECISION BLOCK: Build candidate "## Verified Values" entries from manifest.
        Format: - **{label}**: `{value}` {unit} — {context}
        # DO NOT write to tree yet — the branch below controls when writing happens.
     c. COMPOSE NARRATIVE: Compress qualitative insight into candidate "Key Insights" text.

     # ══ ENCODING COORDINATION CHECK (multi-agent semantic overwrite prevention) ══
     # Before writing to a shared tree node, check if the other agent is encoding
     # to the same node. If so, defer to consolidation queue instead of writing immediately.
     # This prevents semantic overwrites where both agents encode different findings
     # to the same node and the second write silently loses the first agent's insights.
     # (Informed by "LLM Teams as Distributed Systems" Finding 3: concurrent writes.)
     encoding_deferred_by_coordination = false
     IF target node is identified (node.key is known):
         Bash: board-read.sh --channel coordination --type encoding --since 30m --json
         IF any message has a tag matching node.key AND author != current agent:
             Output: "▸ Step 8: ENCODING DEFERRED — {other_agent} recently encoded to {node.key}"
             encoding_deferred_by_coordination = true
             # Defer encoding to consolidation when another agent recently wrote to same node
     # Post own encoding intent BEFORE writing (other agent will see this in their check)
     IF NOT encoding_deferred_by_coordination:
         echo "Encoding: {node.key}" | Bash: board-post.sh --channel coordination --type encoding --tags {node.key}

     # ══ DEEP tree encoding (immediate write) ══════════════════════
     # All non-routine outcomes get immediate tree encoding.
     # Learning is the mission — never defer encoding.
     # Exception: coordination deferral queues to encoding_queue to prevent
     # semantic overwrites when another agent recently wrote to the same node.

     IF outcome_class == "deep" AND NOT encoding_deferred_by_coordination:
         # ── IMMEDIATE TREE WRITE (full inline encoding) ──
         c.5. CURATOR QUALITY GATE (AutoContext-inspired):
        Read core/config/memory-pipeline.yaml curator_gate section
        Evaluate the compressed insight (from step c) against the target node:
        CURATOR Q1 (Coverage, 0-1): "What specific info does this add that isn't
          already in the target node?" Vague/reinforcing → 0.2, concrete new info → 0.8+
        CURATOR Q2 (Specificity, 0-1): "Can I state a concrete fact, threshold, or
          procedure from this insight?" Exact values → 0.8+, vague feelings → 0.2
        CURATOR Q3 (Actionability, 0-1): "What specific action does this tell me to
          take in similar situations?" "be more careful" → 0.1, "check X before Y" → 0.8
        # Investigation-aware scoring: reweight for investigation goals
        # (higher coverage weight, lower actionability — understanding IS the output)
        IF is_investigation_goal:
            curator_score = (coverage * 0.50) + (specificity * 0.30) + (actionability * 0.20)
        ELSE:
            curator_score = (coverage * 0.40) + (specificity * 0.35) + (actionability * 0.25)
        IF curator_score < pass_threshold (default 0.45):
            Output: "▸ CURATOR GATE: REJECTED (score {curator_score:.2f} < {pass_threshold}) — demoted to overflow"
            echo '{"observation": "<insight_text>", "target_node": "<node.key>", "curator_score": <score>, "reason": "below_threshold"}' | wm-set.sh curator_overflow
            SKIP steps d through f for this insight (do NOT write to tree)
            # Overflow items get second chance during session-end consolidation
        ELSE:
            Output: "▸ CURATOR GATE: PASSED (score {curator_score:.2f})"
            # c.6. MDL PARSIMONY ADVISORY (g-115-1468 / earn-the-keep Phase 1c):
            # Measurable lexical backstop to the curator's semantic coverage check.
            # The curator judges "does this add new info?" by LLM judgment; this adds
            # a MEASURABLE second signal so near-duplicates aren't waved through under
            # context pressure. ADVISORY ONLY — the curator's PASS stays authoritative;
            # this surfaces lexical restatement and recommends merge-over-append. Logs
            # a pass/block firing under gate id `mdl-encode-parsimony`
            # (core/config/gates.yaml) via run_assess. Proportionality: only worth
            # running when the node has enough existing content to BE redundant with.
            IF the target node already has >= 3 existing insights (Verified Values /
               Key Insights bullets):
                Write agents/<agent>/session/mdl-existing-corpus.jsonl
                  # transient scratch: one JSONL line {id, text} per existing node
                  # insight (id = short tag). session/ always exists (L1-clean),
                  # overwritten each close.
                Bash: py -3 core/scripts/mdl_gate.py gate \
                      --candidate "<the compressed insight from step c>" \
                      --existing agents/<agent>/session/mdl-existing-corpus.jsonl \
                      --node <node.key> --goal {goal.id} --caller aspirations-state-update
                  # args, not python source -> guard-165 N/A. exit 0 keep / 1 near-dup.
                Parse stdout JSON (keep, nearest_id, max_similarity, novelty, reason):
                IF keep == false:
                    Output: "▸ MDL ADVISORY: near-duplicate of {nearest_id} (sim {max_similarity:.2f}, nov {novelty:.2f}) — {reason}"
                    # Reconcile with the curator PASS (curator saw NEW semantic info;
                    # MDL sees lexical overlap):
                    #   - genuine restatement, no new fact -> MERGE into {nearest_id}
                    #     (Edit the existing node line) or demote to curator_overflow;
                    #     do NOT append a near-duplicate line.
                    #   - adds a concrete fact the lexical check missed -> append normally.
                ELSE:
                    Output: "▸ MDL ADVISORY: sufficiently novel (sim {max_similarity:.2f}, nov {novelty:.2f}) — proceed"
            # else: node too sparse to be redundant with — skip advisory.
            # Proceed to step d (PRECISION AUDIT).
     d. PRECISION AUDIT: Re-read node. Verify each manifest item appears in Verified Values.
     e. EXTRACT DECISION RULES: Bash-enforced via decision-rules-append.sh
        (rb-428 / guard-365). LLM residue: compose the IF clause (observable
        condition) and THEN clause (specific action). The wrapper does the
        format, token-overlap dedup (>=70% → skip), and insert. Empty stdin
        is legitimate ("no rule emerged") and emits a staleness signal for
        aggregate drift detection — see core/config/conventions/decision-rules.md.

        Rules must be concrete (no vague "consider"), testable (condition
        is observable), and actionable (a specific step, not "be careful").
        Not every goal produces decision rules — only emit when a clear
        IF-THEN emerges.

        IF a clear behavioral rule emerged:
            echo '{"if": "<observable condition>", "then": "<specific action>"}' \
              | bash core/scripts/decision-rules-append.sh \
                  --goal {goal.id} --node-path <node-md-path>
            # For multiple rules: echo a JSON array instead of a single object.
        ELSE:
            # Signal "no rule" explicitly so the staleness probe counts it.
            echo '' | bash core/scripts/decision-rules-append.sh \
                --goal {goal.id} --node-path <node-md-path>

        # Wrapper emits one line per rule:
        #   ▸ DECISION RULE: appended: - IF ... THEN ... — source: g-NNN-NN
        #   ▸ DECISION RULE: skipped (duplicate): - IF ... THEN ...
        # Final line: decision_rules_count=<N> appended=<M> skipped=<K>
        #   (reason=no_rule_passed when stdin was empty)
     f. CONSISTENCY SCAN: If the insight changes a factual claim already stated elsewhere
        in the node (count, threshold, formula, status), search the full node for stale
        references to the old value and update them. Use Edit replace_all for unambiguous
        strings. For ambiguous cases (e.g., "19" appears in unrelated contexts), fix each
        occurrence individually.
   - Update node metadata via batch:
     echo '{"operations": [
       {"op": "set", "key": "<node.key>", "field": "confidence", "value": <new-value>},
       {"op": "set", "key": "<node.key>", "field": "capability_level", "value": "<new-value>"}
     ]}' | bash core/scripts/tree-update.sh --batch
     # article_count: only increment here if Phase 8 itself wrote new content.
     # Skills that write to tree nodes (research-topic, reflect) handle their own increment.
     If Phase 8 wrote new insight above AND executing skill was NOT research-topic or reflect:
       Add {"op": "increment", "key": "<node.key>", "field": "article_count"} to the batch
   - Check growth triggers on the updated node:
     Read core/config/tree.yaml for decompose_threshold, split_threshold
     line_count = count lines in node .md body (excluding YAML front matter)
     If line_count > decompose_threshold AND node depth < D_max:
       bash core/scripts/tree-update.sh --set <node.key> growth_state ready_to_decompose
       Invoke /tree maintain
     Elif article_count > split_threshold:
       bash core/scripts/tree-update.sh --set <node.key> growth_state ready_to_split
       Invoke /tree maintain
   - Propagate changes up parent chain:
     result=$(bash core/scripts/tree-propagate.sh <node.key>)
     # Returns: {source_node, ancestors_updated: [...], capability_changes: [...]}
     IF result.capability_changes is non-empty:
       For each changed ancestor: update .md body text (capability map table in Key Insights)
   - If capability_level threshold crossed (check result.capability_changes):
     a. bash core/scripts/tree-update.sh --set root summary "<updated domain summary>"
     b. Log capability event via `echo '<json>' | bash core/scripts/evolution-log-append.sh`
     c. Announce: "CAPABILITY UNLOCK: {topic} → {new_level}"
     d. Read agents/<agent>/developmental-stage.yaml
     e. If new level > highest_capability → update highest_capability

   # CRITICAL — set flags at the deep branch level, not inside capability check.
   # Orchestrator drift tracking (Phase 8.0.5) gates on step_8_tree_encoded.
   # Step 8.5 and Step 8.75 gate on step_8_wrote_insight.
   step_8_wrote_insight = true
   step_8_tree_encoded = true

   # ── Knowledge-debt auto-detect fallback (anti-pattern 2) ─────────
   # A goal may resolve a knowledge_debt without having declared it at
   # decomposition time. If the node we just wrote matches an entry in
   # working-memory knowledge_debt[], back-populate closes_knowledge_debt
   # on the goal so the classifier's semantic override (in the NEXT goal's
   # Phase 4-post, or in reflection) can see the link. Also log for the
   # current session's debt-sweep.
   debt_match = $(bash core/scripts/wm-read.sh knowledge_debt --json | \
                  jq -r --arg k "<node.key>" '.[] | select(.node_key == $k) | .node_key')
   IF debt_match is non-empty:
     existing_field = goal.closes_knowledge_debt or []
     IF node.key not in existing_field:
       updated = existing_field + [node.key]
       bash core/scripts/aspirations-update-goal.sh --source {source} <goal.id> \
            closes_knowledge_debt "$(jq -c -n --argjson v '<updated_json>' '$v')"
       Log: "▸ Step 8: auto-detected debt closure — back-populated closes_knowledge_debt=[{node.key}] on {goal.id}"

   ELIF encoding_deferred_by_coordination:
     # ── COORDINATION DEFERRAL: queue encoding for consolidation ──────
     # Another agent recently encoded to the same node. Writing now would
     # silently overwrite their insight. Queue for consolidation instead.
     # DO NOT remove this branch — without it, insight is silently dropped
     # and the learning gate forces inline encoding, causing the exact
     # overwrite this check exists to prevent.
     encoding_payload = {
         source_goal: goal.id,
         source_type: "coordination_deferred",
         target_node_key: node.key,
         target_node_file: node.file,
         observation: compressed_narrative,
         precision_manifest: precision_manifest,
         decision_rules: candidate_rules,
         encoding_score: 0.65,
         curator_score: curator_score,
         target_article: node.file,
         metadata_updates: {
             confidence: <computed new value>,
             capability_level: <computed new value>
         },
         timestamp: now
     }
     echo '<encoding_payload_json>' | wm-append.sh encoding_queue
     Output: "▸ Step 8: COORDINATION DEFERRED — encoding queued for {node.key}"
     step_8_wrote_insight = true
     step_8_tree_encoded = false

   ELSE:
     # No new insight from this goal
     step_8_wrote_insight = false
     step_8_tree_encoded = false

# ── Step 8.5: Actionable Findings Gate ──────────────────────────────
# Catches findings encoded to tree (Step 8) that need their own goal.
# Runs AFTER tree encoding so the insight is already articulated.
# sq-013 (Phase 6) is complementary — it catches obvious work BEFORE
# encoding; this gate catches what crystallizes DURING encoding.
#
# Bash-enforced (rb-428 / guard-365). The wrapper does the 4-signal
# keyword scan with resolution filters, dedup against active + sibling-
# completed titles (reads aspirations-compact.json), and dispatches via
# aspirations-add-goal.sh. Emits `findings_count=N created=M` for
# downstream accounting. LLM residue: (a) the insight text itself (comes
# from Step 8), (b) the investigation-override binary — for
# Investigate: goals where no keyword fires, answer "does this finding
# require action?" and pass it as a flag.

IF step_8_wrote_insight:   # True when Step 8 entered "compress into Key Insights" branch
    insight_text = the compressed insight just written to the tree node  # Already in context
    is_investigation = goal.title.startsWith("Investigate:")
    parent_asp = goal's parent aspiration

    # Write the insight to a temporary file for --insight-file.
    Write agents/<agent>/session/findings-gate-insight.tmp.md with insight_text

    # LLM residue: investigation-override binary. Only answer if
    # is_investigation AND the insight contains NO keyword signals
    # (the wrapper runs the scan too — answer here just provides the
    # override). Conservative default: omit the flag if not certain.
    investigation_needs_action = (is_investigation AND finding_requires_action(insight_text))

    # Single dispatch — wrapper handles scan + dedup + goal creation.
    flags = "--goal {goal.id} --aspiration {parent_asp} --category {goal.category} --source {source} --insight-file agents/<agent>/session/findings-gate-insight.tmp.md"
    IF is_investigation: flags += " --is-investigation"
    IF investigation_needs_action: flags += " --investigation-needs-action"

    Bash: bash core/scripts/findings-gate.sh <flags>

    # Wrapper output format (one line per signal + final summary):
    #   ▸ FINDINGS GATE: created <title> in <asp_id> from <goal.id>
    #   ▸ FINDINGS GATE: skipped (dup) <title>
    #   findings_count=<N> created=<M>
    # If M > 0, append to journal: "Findings gate: N signal(s) → M new goal(s)"

    Delete agents/<agent>/session/findings-gate-insight.tmp.md
# If Step 8 did not write insight: silent pass (no output)

# ── Step 8.75: Execution Reflection ──────────────────────────────────
# Cross-references execution outcomes against institutional knowledge:
# pattern signature matching/creation, contradiction detection against
# tree nodes, and investigation goal creation for findings that need
# follow-up. Complements Phase 6.5 (guardrails + reasoning bank) and
# Step 8.5 (actionable findings from keywords). This step handles
# pattern-level and contradiction-level analysis.
#
# Runs AFTER Step 8 (tree encoding) and Step 8.5 (actionable findings)
# so the insight text and tree state are fresh.
# Skipped by routine outcome early return (line 51-59).
# Skipped when Step 8 did NOT write insight (nothing to reflect on).

IF step_8_wrote_insight:
    invoke /reflect --on-execution with: goal, result, outcome_class
    # Sub-skill handles: notability gate (cheap early-exit if nothing notable),
    # pattern signature matching/creation, contradiction detection,
    # investigation goal creation, experience archival, journal entry.
    # Guardrails and general reasoning-bank entries are NOT created here
    # (Phase 6.5 owns those). EXCEPTION: reusable multi-step PROCEDURE entries
    # (entry_type: procedure) are encoded by Step 8.75b below — a narrow,
    # non-overlapping carve-out (g-306-11).
    #
    # Positive-state claim discipline (verify-before-assuming.md
    # Positive File-State Claims): any file-state assertion the reflection
    # makes ("handoff.yaml reflects N", "X.jsonl was updated to Y") must be
    # backed by an in-turn Read. Belt-and-suspenders — the verify gate
    # (aspirations-verify Q1) is the hard check; this note is the advisory
    # reminder for reflection narratives. If a file-state claim appears
    # without a supporting Read in this turn, re-read before stating.

── Step 8.75b: Reusable Procedure Encoding (g-306-11) ───────────────

Narrow, NON-OVERLAPPING complement to Phase 6.5 (which captures general

reasoning patterns/heuristics + guardrails) and Step 8.75 (pattern-signature

+ contradiction analysis): THIS step owns reusable MULTI-STEP PROCEDURE

entries specifically — an ordered how-to sequence worth repeating when a

recurring CLASS of task appears. Tagging it entry_type: procedure makes it

targetable via retrieve.sh --entry-type procedure at Phase 4 of a future

similar goal. Skipped by the routine early return (deep-only tail).

Gate (LLM judgment, default SKIP): did THIS goal's execution produce a

reusable, ordered, multi-step procedure that a FUTURE goal of the same shape

would follow step-by-step? Most goals do NOT (a one-off fix, a single-file

edit, an observation → SKIP silently). Only a genuine repeatable sequence

qualifies — this is the "when one is produced" condition, not every iteration.

IF the goal produced a reusable multi-step procedure (ordered steps a future similar goal would repeat): # Dedup vs Phase 6.5: if spark already captured this exact procedure this # iteration, strengthen instead of duplicating (same pattern as spark). Bash: reasoning-bank-read.sh --category {goal.category} IF an existing active entry already states this procedure: Bash: reasoning-bank-increment.sh {entry.id} utilization.times_helpful Log: "PROCEDURE ENCODING: strengthened existing {entry.id} (no duplicate)" ELSE: Create reasoning bank entry via reasoning-bank-add.sh: # id + created auto-set by the script — omit both; capture the # assigned id from stdout's full-record JSON. title: "Procedure: {concise name of the repeatable task}" type: success category: goal's category content: the ordered, numbered steps, the preconditions under which the procedure applies, and any per-step gotchas applies_to: <any|framework|domain|specific> # REQUIRED entry_type: procedure # g-306-11 — retrievable via retrieve.sh # --entry-type procedure (the whole point) when_to_use: {conditions: ["{the recurring task shape}"], category: "{goal.category}"} source_goal: goal.id tags: ["procedure"] poignancy: <1-10> # how reusable/impactful the procedure is for future retrieval Log: "PROCEDURE ENCODING: created {rb-id from stdout} (entry_type=procedure) from {goal.id}"

ELSE: no reusable procedure produced — SKIP silently (the common case).

── Step 8.76: Skill Quality Assessment ───────────────────────────

SkillNet-inspired five-dimension quality scoring for the skill that

just executed. Accumulates in meta/skill-quality.yaml as a rolling

window of the last 20 evaluations per skill.

Skipped by routine outcome early return (same as 8.75).

Skipped when goal has no linked skill.

Bash-enforced auto-derivation (g-248-34, rb-428 pattern): the wrapper

computes 4-of-5 dimensions mechanically from execution signals, and

the LLM supplies ONLY cost_awareness (semantic retrieval-proportionality

judgment that genuinely cannot be derived from counters).

Mechanical: safety (from guardrail violations),

completeness (from outcomes-met/total ratio),

executability (from episode-chain count),

maintainability (base → "good"; forged → registry lookup)

LLM residue: cost_awareness

See core/config/conventions/skill-quality.md for dimension definitions

and core/scripts/skill-quality-score.py for derivation rules.

Sampling-bias fix (skill-telemetry-signal-master-plan Layer 3, 2026-05-12):

The original gate excluded routine outcomes AND null goal.skill, causing the

pipeline to silently dry up when the workload shifted to recurring/infra

goals (2026-04-16 silence root cause). Per the master plan, routine outcomes

still produce mechanical quality signal — only cost_awareness (LLM judgment)

is skipped; everything else fires. Null goal.skill on a non-routine outcome

now surfaces as an explicit warning (goal-creation gap upstream).

Name canonicalization: skill-quality-score.py strips leading "/", drops

post-whitespace, validates against canonical name list. LLM passes goal.skill

raw — no pre-normalization needed. See rb-885, guard-535.

IF goal.skill is set: skill_arg = goal.skill # raw; script.canonicalize_skill_name handles it

# Four mechanical execution-signal inputs (LLM gathers from this iteration):
outcomes_met   = count of goal.verification.outcomes met during verify
outcomes_total = len(goal.verification.outcomes)
episodes       = episode_chain_count from execute phase (0 if clean)
violations     = guardrail-fire count during execute (0 if none)

# cost_awareness: deep outcomes earn full LLM judgment; routine outcomes
# get the default "good" (fast-path — keeps eval firing without spending
# judgment cycles on expected-routine work).
IF outcome_class == "routine":
    cost_awareness = "good"  # default — routine doesn't warrant LLM cycles
ELSE:
    # One semantic-judgment input (LLM decides; no mechanical proxy exists):
    #   good    = items loaded proportional to items used; no wasted reads
    #   average = loaded >> used, OR redundant reads of the same file
    #   poor    = excessive bloat, repeated reads of unused context
    cost_awareness = LLM judgment on retrieval proportionality this iteration

Bash: skill-quality-score.sh score \
    --skill {skill_arg} --goal {goal.id} \
    --outcomes-met {outcomes_met} --outcomes-total {outcomes_total} \
    --episode-chain-count {episodes} --guardrail-violations {violations} \
    --cost-awareness {cost_awareness}
# Wrapper acquires <meta>/skill-quality.yaml.lock before invoking
# skill-evaluate.py — protects against concurrent-agent write races.
# Emits a human-readable score line plus a machine-readable JSON trailer
# with the derived grades (auditable + consumable by downstream steps).
# On invalid skill name: script exits 1 with explicit error rather than
# silently writing a denormalized YAML key (previous bad-state mode).

ELIF outcome_class != "routine": # Deep outcome with null goal.skill = goal-creation gap. Surface it loud # so upstream goal creators learn to tag skill on creation. This was the # 2026-04-16 silence root cause — pipeline silently dried up on null-skill # workload. Do not silently skip when the outcome is deep. Report: "WARN: Step 8.76 skipped — deep outcome on goal {goal.id} with no goal.skill. Tag the skill at goal-creation time for proper quality signal."

IF outcome_class == "routine" AND goal.skill is null: silently skip (expected

for some routine infra goals; no novel signal to score, no warning needed).

### Scripted Audit Pass (Steps 8.8-8.10)

`state-update-audit.sh run-all` runs velocity (8.8), backpressure (8.85),
temporal credit (8.9), and relative advantage (8.10) in one Python pass —
pure arithmetic, no LLM judgment. 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 `state-update-audit.py` MUST be
fixed in the script, not patched around by reintroducing a shadow LLM
path here.

Steps 8.5 (Actionable Findings Gate), 8.75 (Execution Reflection), 8.76
(Skill Quality), and 8.11 (Execution Feedback) stay on the LLM path —
those require judgment that `run-all` does not cover.

IF outcome_class != "routine": # LLM gathers four inputs from this iteration's state. These MUST be # passed — omitting any flag silently produces learning_value=0 # (state-update-audit.compute_learning_value uses argparse defaults). # The script owns the arithmetic; the LLM owns the inputs. tree_updated = true iff Step 8 wrote an insight node to the tree artifacts_count = count(reasoning_bank + guardrails + pattern_sigs created this iteration) encoding_score = from Step 2.7 encoding gate if it fired, else 0.0 findings_count = count(Step 8.5 Actionable Findings gated this iteration)

Bash: bash core/scripts/state-update-audit.sh run-all \
    --goal {goal.id} \
    --outcome-class {outcome_class} \
    --category {goal.category} \
    --experience-id {experience_id} \
    [--tree-updated if tree_updated] \
    --artifacts-count {artifacts_count} \
    --encoding-score {encoding_score} \
    --findings-count {findings_count} \
    [--exploration if goal.execution_mode == "exploration"]
# Reads the JSON. Flags to watch for (each prefixed by subcommand):
#   velocity:impk_snapshot_failed  → meta-impk.sh unreachable; investigate stderr
#   backpressure:rollbacks_applied → one or more meta-strategy fields
#                                    auto-reverted — note in output
#   backpressure:check_failed      → meta-backpressure.sh unreachable; investigate stderr

── Step 8.86: Self/Program/Skill/Rule Evolution Backpressure ───────

Per world/conventions/self-program-evolution.md

Runs AFTER 8.10 (meta-strategy backpressure) and BEFORE 8.77.

Re-samples the metric vector for every active evolution monitor

(monitor_kind ∈ {self_evolution, program_evolution, skill_evolution,

rule_evolution}). Fires auto-rollback when consecutive_below_baseline

crosses the per-kind regression_window. Fires graduation when

consecutive_above_baseline crosses graduation_window.

Skips entirely when outcome_class == "routine" — routine goals do not

perturb the metric vector enough to be informative, and sampling on

every routine iteration would flood the script. The §14.5 windows

(6-15 iterations) are sized for deep/exploration iterations only.

IF outcome_class == "routine": SKIP silent

Bash: bash core/scripts/meta-backpressure.sh evolution-check # Returns JSON with: # rollback_actions[] → each: {revision_id, monitor_kind, file_path, # worst_signal, worst_drop, rolled_back, # rollback_error?} # graduated[] → each: {revision_id, monitor_kind, file_path, # samples_collected} # active_monitors_count → total post-check (rolled_back + graduated removed) # # If rollback_actions is non-empty: surface in iteration close output — # e.g., "ROLLBACK: skill_evolution {rev_id} reverted — worst signal # {worst_signal} dropped {worst_drop}". The rollback record is already # appended to the corresponding -evolution.jsonl by the engine. # # If subprocess fails (timeout, ImportError): log "WARN: 8.86 evolution- # check failed: {stderr}" and continue. NEVER block iteration close on # backpressure infra failure — the monitors will resume on the next # successful iteration.

── Step 8.77: User-Notable Event Push Classifier ────────────────────

Proactive user notification on goal outcomes that cross a "user would

want to know" threshold. Catches the gap Alpha named 2026-04-23:

coordination-board updates flow constantly, but user-facing signal

fires only via fresh-eyes-review (cadence 25) + blocker alerts +

explicit invocations. No per-goal middle tier — until now.

This step is a CLASSIFIER, not a new transport. Dispatch routes through

the existing /notify-user skill (which owns self-identification,

30m same-subject dedup, email + fallback cascade, and

wm.notification_log append). This step decides WHEN to fire; /notify-user

decides HOW to deliver.

Runs AFTER Step 8.76 (skill quality) and BEFORE Step 8.78 (fresh-eyes

gate) — placed so reflection/quality outputs are in context but the

more expensive fresh-eyes dispatch is still downstream.

── Skip conditions (fail-closed; default is NO push) ──

IF outcome_class == "routine": SKIP silent # routine outcomes already degate via Part A's auto-deep at 5 IF NOT goal_succeeded: SKIP silent # failures route via CREATE_BLOCKER → /notify-user category=blocker IF goal.category == "blocker" OR goal.title starts with "Blocker:": SKIP silent # double-push avoidance — CREATE_BLOCKER already dispatched

── Skip condition #4: user-only mute ──

User can mute Step 8.77 entirely by writing the slot:

bash core/scripts/wm-set.sh suppress_user_push true

Useful when on-call / focusing — agent keeps working but stops pushing

user-notable events. Clear with ... wm-set.sh suppress_user_push false

(or wm-clear.sh suppress_user_push). Intentionally has no programmatic

writer — agent must never auto-mute itself. Whitelisted in

signal-lifecycle-gate.py phantom-reads CATEGORY 2.

Bash: wm-read.sh suppress_user_push IF signal is not null AND signal == "true": Output: "▸ Step 8.77: suppress_user_push set (user-muted) — skipping classifier" SKIP

── Trigger evaluation (match any — multiple triggers per goal is valid) ──

triggers = [] # list of (trigger_id, category, subject, message)

---- Trigger 1: shipped — a new capability landed ----

Signal: deep outcome AND ship-verb title OR insight_text contains shipping language.

Keeps false-positive rate low by requiring the deep-outcome precondition

(only non-routine, verified-successful, material outcomes reach here).

IF outcome_class == "deep": title_matches_ship = re.match(r"^(ship|deploy|release|build|create|add)\b", goal.title, re.I) insight_has_ship = any(s in (insight_text or "").lower() for s in ["shipped", "deployed", "released to", "landed in"]) IF title_matches_ship OR insight_has_ship: subject = f"Alpha shipped: {goal.title[:60]}" message = (insight_text or goal.title)[:400] triggers.append(("shipped", "info", subject, message))

---- Trigger 2: resolved-long-blocker — Unblock goal closed after >= 7d open ----

Single source of truth for age = goal.created_at (aspirations schema).

DO NOT add fallback fields (created, created_date, blocked_since) — if

created_at is missing, the age signal is untrustworthy and the trigger

MUST skip. Fail-open matches user-stated design rule ("when in doubt,

don't protect"). 40/50 Unblock goals in the live store lack created_at

as of 2026-04-23 — guard-first or crash (datetime - None → TypeError).

IF goal.title starts with "Unblock:" AND goal.created_at is not None: age_days = (now - parse_iso(goal.created_at)).days IF age_days >= 7: title_trimmed = goal.title[9:65].strip() if len(goal.title) > 9 else goal.title subject = f"Unblocked after {age_days}d: {title_trimmed}" message = (insight_text or "")[:400] + f"\n\nBlocker had been open {age_days} days." triggers.append(("resolved-long-blocker", "info", subject, message))

---- Trigger 3: recovered — infra/session/job recovery ----

Matches output language from recovery-gate, stale-scanner, crash recovery

notices. Same keyword set used by Part A's recovery-notice display.

IF goal.title starts with "Recover:" OR any( k in (insight_text or "").lower() for k in [ "crashed runner recovered", "stale_scanner killed", "stale scanner killed", "reaped", "infrastructure recovered", "recovery-gate fired", ] ): subject = f"Recovered: {goal.title[:60]}" message = (insight_text or goal.title)[:400] triggers.append(("recovered", "info", subject, message))

---- Future extensions (NOT shipped in this MVP — documented for next pass) ──

Trigger 4: hypothesis-confirmed — requires /review-hypotheses integration

(read outcome + confidence from pipeline record resolved this

iteration). Would fire for correct high-conviction resolutions

AND for wrong-but-high-confidence (surprise) resolutions.

Trigger 5: participant-user-goal-created — requires a goal-creation delta

(compact snapshot before/after this iteration) OR a WM counter

that aspirations-add-goal bumps when --participants includes user.

Collapses the original "something to say" flag into the push

classifier. MVP omits because the delta signal isn't wired.

── Short-circuit if nothing triggered ──

IF triggers is empty: SKIP silent

── Rate cap: max 3 immediate pushes per rolling hour ──

SINGLE SOURCE OF TRUTH for send history: wm.notification_log (owned by

/notify-user; written on successful send only). DO NOT introduce a

parallel counter — dual stores drift. Entry shape: {subject, category,

sent_at: <ISO 8601 string>}. LLM parses sent_at via datetime.fromisoformat

before comparing.

Bash: wm-read.sh notification_log recent_pushes = [e for e in (notification_log or []) if datetime.fromisoformat(e.sent_at) >= now - timedelta(seconds=3600)] push_slots_remaining = max(0, 3 - len(recent_pushes))

── Dispatch (preserve trigger order; first N under cap go out immediate) ──

Over-cap pushes are DROPPED, not queued. Rationale: a user-notable moment

has decay — a push 6h later stamps the wrong time (rb-464 stale-narrative).

Suppression surfaces in the iteration Output line only; do NOT write a

shadow journal entry (orphaned — no index via journal-add.sh).

FOR (trigger_id, category, subject, message) in triggers: IF push_slots_remaining <= 0: Output: f"▸ Step 8.77: user-push suppressed ({trigger_id}, rate cap) — {subject}" CONTINUE # Canonical prose form per .claude/rules/forged-skill-resolution.md so a # domain-registered notify forge-override can intercept. /notify-user owns # 30m same-subject dedup AND the notification_log append — this step # decides WHEN, /notify-user decides HOW. Notify the user about {trigger_id} with category={category}, subject={subject}, message={message}. push_slots_remaining -= 1 Output: f"▸ Step 8.77: user-push fired ({trigger_id}) — {subject}"

── Step 8.78: Post-State-Update Fresh-Eyes Gate (guard-343 bash-enforced) ─

Bash decides WHETHER (threshold gate), LLM decides WHAT (Skill dispatch).

The gate fires only for deep outcomes with material core/ changes. See

core/scripts/post-state-update-gate.sh for the threshold spec (core_files>=3,

loc>=100, or new script in core/scripts). If the gate fires, the LLM

dispatches /fresh-eyes-code on the returned file list. rb-393 + guard-343.

IF outcome_class == "deep": Bash: core/scripts/post-state-update-gate.sh deep gate_json = parse stdout as JSON IF gate_json.fired: Output: "▸ Step 8.78: fresh-eyes gate fired ({gate_json.reason})" Skill('fresh-eyes-code') with args: space-separated paths from gate_json.files # ELSE: silent pass — gate.reason already logged in gate_json for audit

ELSE: gate is always false for routine — skip silently

── Step 8.11: Execution Feedback (Cross-Agent Goal Quality) ─────

When executing a goal created by another agent, post structured quality

feedback to world/board/feedback.jsonl. Creates a backward learning signal

so the goal creator can improve future goal descriptions.

See board.md Execution Feedback Schema for field definitions.

IF outcome_class != "routine" AND source == "world": # Determine who created the goal. For world goals, check if there's a # created_by field or infer from the aspiration author / board handoff. goal_created_by = goal.get("created_by") or goal.get("discovered_by") or "unknown"

IF goal_created_by != AGENT_NAME AND goal_created_by != "unknown":
    # Rate the goal on three dimensions (1-5 each)
    # Based on actual execution experience:
    clarity = <1-5: was the description clear and actionable?>
    scope_accuracy = <1-5: was the effort estimate right? 1=wildly off, 5=spot on>
    verification_quality = <1-5: were checks testable and sufficient?>
    friction = <"low"|"medium"|"high": overall execution friction>
    notes = <optional: what was missing or wrong — only if friction >= medium>

    feedback_json = {
        "goal_id": goal.id,
        "created_by": goal_created_by,
        "executed_by": AGENT_NAME,
        "clarity": clarity,
        "scope_accuracy": scope_accuracy,
        "verification_quality": verification_quality,
        "friction": friction,
        "notes": notes
    }

    echo '<feedback_json>' | Bash: board-post.sh --channel feedback \
        --type execution-feedback --tags "{goal.id},created_by:{goal_created_by}"
    Output: "▸ Execution feedback: clarity={clarity} scope={scope_accuracy} verify={verification_quality} friction={friction}"

── Step 8.12: Outcome-Observation Hook (Tranche C — rb-390) ──────

Hook slot for domain-supplied outcome observation after state update. The

process side (goals completed, productive_ratio) can inflate while nothing

material moves; an outcome-observation convention PULLS evidence from the

actual systems the work is supposed to affect, producing the process-vs-

outcome divergence signal downstream consumers (agent-completion-report

"Outcome Delta" section) report on.

Pattern B hook slot (outcome-observation). See

core/config/conventions/domain-hooks.md. Core names the slot, the world

convention (if it exists) names what to run. Skipped for routine outcomes

(the routine early-return above already returned). Fail-open — a missing

or broken convention does NOT abort state-update.

IF outcome_class != "routine": Bash: paths=$(bash core/scripts/load-conventions.sh outcome-observation 2>/dev/null) IF paths is non-empty: Read the file at the returned path # Procedural convention — gate on file EXISTENCE, not load status. Bash: source core/scripts/_paths.sh && test -f "$WORLD_DIR/conventions/outcome-observation.md" && echo "exists" IF exists: Follow each Step in the convention. Any step that fails SHOULD be logged and swallowed — never abort state-update. ELSE: # No domain outcome-observation convention exists (fresh agent). # Nothing to do — downstream Outcome Delta section will show # "no outcome signal configured" and consumers degrade gracefully.

## Return Protocol

See `.claude/rules/return-protocol.md` — last action must be a tool call, not text.

## Chaining

- **Called by**: `/aspirations` orchestrator (Phase 8)
- **Calls**: `aspirations-update-goal.sh --source {source}`, `aspirations-meta-update.sh --source {source}`, `aspirations-add-goal.sh --source {source}`, `wm-set.sh`, `wm-read.sh`, `wm-append.sh`, `skill-evaluate.sh`, `meta-impk.sh`, `meta-backpressure.sh`, `experience-update-field.sh`, `team-state-update.sh`, `board-post.sh`, `/notify-user` (Step 8.77 user-notable event push classifier)
- **Reads**: Goal object, execution result, `core/config/evolution-triggers.yaml`, `core/config/memory-pipeline.yaml`, `meta/encoding-strategy.yaml`