agentfootprint 10.3.0 → 10.4.0

package/dist/influence-core/types.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * influence-core types — the ONE embedding-based scoring contract.
+ *
+ * Pattern: Strategy seam (plug-and-play meta-pattern) — the frame and
+ *          rule engine are the library's; the `Embedder` is consumer-
+ *          injected, exactly like NarrativeFormatter / reliability /
+ *          permission / commentary strategies.
+ * Role:    `src/influence-core/` leaf module. Shared by the FDL paper pipeline
+ *          (Visible Reasoning, Eq. 1–6), RFC-002's tool-catalog lint +
+ *          margin recorder (C1/C4/C5), and RFC-003 Part B's LLM-edge
+ *          weigher (D7). Extracted as RFC-003 block D6 so all three
+ *          consumers share one scoring engine and one embedding cache.
+ *
+ * ## Honest claim (RFC-002 §2, the FDL discipline)
+ *
+ * Every score produced under these types is a PROXY computed from
+ * embedding geometry — cosine similarity over consumer-injected
+ * embeddings. None of it reads model internals. Scores mean "high
+ * semantic alignment", never "the model chose/answered BECAUSE".
+ * Scores are not additive across items and are not causal attribution
+ * — counterfactual ablation (RFC-003 stage 4) is where causal claims
+ * live.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLEAR_WINNER_RATIO = exports.DEFAULT_SHORTLIST_BAND = exports.DEFAULT_CLEAR_WINNER_MARGIN = exports.DEFAULT_MARGIN_THRESHOLD = exports.DEFAULT_PERSISTENCE_THRESHOLD = exports.DEFAULT_INFLUENCE_WEIGHTS = void 0;
+/** Paper defaults: α=0.40, β=0.30, γ=0.20, δ=0.10 (sum to 1.0). */
+exports.DEFAULT_INFLUENCE_WEIGHTS = Object.freeze({
+    fa: 0.4,
+    avg: 0.3,
+    persist: 0.2,
+    depth: 0.1,
+});
+/** Paper default for the PERSIST threshold T (Eq. 3). */
+exports.DEFAULT_PERSISTENCE_THRESHOLD = 0.3;
+/** RFC-002 §4 default: margins below this flag the choice as `narrow`. */
+exports.DEFAULT_MARGIN_THRESHOLD = 0.05;
+/**
+ * RFC-003 default: an influence ranking whose top-1 vs top-2 score margin is
+ * below this has NO clear winner — a shortlist, not a verdict. Escalate to
+ * ablation.
+ *
+ * UNCALIBRATED proxy starting point, chosen for interpretability. `margin`
+ * is an ABSOLUTE difference on the same scale as `scoreInfluence`'s composite
+ * (S ∈ ≈[−0.7, 1]), so this threshold is EMBEDDER-RELATIVE — recalibrate by
+ * sweeping clear-winner vs flat rankings on your embedder. The numeric
+ * coincidence with `DEFAULT_MARGIN_THRESHOLD` is NOT a shared derivation: that
+ * one measures `scoreMargin`'s chosen-vs-not-chosen distribution, a different
+ * statistic.
+ */
+exports.DEFAULT_CLEAR_WINNER_MARGIN = 0.05;
+/**
+ * RFC-003 default: when there is no clear winner, suspects scoring within this
+ * band of the top form the shortlist ablation should COVER (the culprit may be
+ * any of them — or, for absence bugs, none). UNCALIBRATED proxy; embedder-
+ * relative (see `DEFAULT_CLEAR_WINNER_MARGIN`).
+ */
+exports.DEFAULT_SHORTLIST_BAND = 0.1;
+/**
+ * RFC-003 default for `ratioStrategy`: the top-2 gap as a FRACTION of the top
+ * score `(s0 − s1) / |s0|`. Unlike the absolute margin this is scale-invariant,
+ * so it transfers across embedders / answer lengths. UNCALIBRATED proxy.
+ */
+exports.DEFAULT_CLEAR_WINNER_RATIO = 0.05;
+//# sourceMappingURL=types.js.map

package/dist/influence-core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/influence-core/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AA0BH,mEAAmE;AACtD,QAAA,yBAAyB,GAAqB,MAAM,CAAC,MAAM,CAAC;IACvE,EAAE,EAAE,GAAG;IACP,GAAG,EAAE,GAAG;IACR,OAAO,EAAE,GAAG;IACZ,KAAK,EAAE,GAAG;CACX,CAAC,CAAC;AAEH,yDAAyD;AAC5C,QAAA,6BAA6B,GAAG,GAAG,CAAC;AAEjD,0EAA0E;AAC7D,QAAA,wBAAwB,GAAG,IAAI,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACU,QAAA,2BAA2B,GAAG,IAAI,CAAC;AAEhD;;;;;GAKG;AACU,QAAA,sBAAsB,GAAG,GAAG,CAAC;AAE1C;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,IAAI,CAAC"}

package/dist/injection-engine/SkillRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkillRegistry.js","sourceRoot":"","sources":["../../src/injection-engine/SkillRegistry.ts"],"names":[],"mappings":"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"}

package/dist/injection-engine/buildInjectionEngineSubflow.js

@@ -0,0 +1,574 @@
+"use strict";
+/**
+ * Injection Engine — subflow builder.
+ *
+ * Pattern: Subflow Builder (returns a FlowChart mountable via
+ *          `addSubFlowChartNext`). Each subflow stands alone.
+ * Role:    Layer-3 context-engineering primitive. Sits BEFORE the
+ *          three slot subflows in any primitive (Agent, LLMCall) that
+ *          uses Injections. Evaluates every Injection's trigger once
+ *          per iteration.
+ *
+ * Four small, readable stages (was one monolithic `evaluate`):
+ *   1. Gather   — snapshot the turn's inputs (iteration, history size,
+ *                 last tool, LLM-activated count). Observability only.
+ *   2. Evaluate — run every trigger → `activeInjections` (the REAL output
+ *                 the slot subflows read). Logic is UNCHANGED from the old
+ *                 single stage: `activeInjections` is byte-identical, so the
+ *                 slots are 100% unaffected. (Safety invariant.)
+ *   3. Route    — partition `activeInjections` into per-slot buckets
+ *                 (`activeByslot`), mirroring how the slots filter. Pure
+ *                 annotation — the slots still do their own filtering.
+ *   4. Delta    — diff this turn's buckets vs last turn's (`slotDelta`):
+ *                 per slot, what activated / deactivated / stayed. The
+ *                 explainability win ("tools +skill X, system-prompt
+ *                 unchanged"). Reads last turn via `priorActiveByslot`
+ *                 carried by the mount's input/output mappers.
+ *
+ * Nothing here SKIPS a slot — Route/Delta only annotate. See
+ * docs (injection-algorithm blog) + memory agentfootprint_slot_plan_review
+ * for why per-turn skip was deferred.
+ *
+ * Emits:   `agentfootprint.context.evaluated` at the Evaluate stage, with
+ *          aggregate metadata. The per-slot route/delta ride visible stage
+ *          STATE (`activeByslot` / `slotDelta`) so the lens reads them from
+ *          the commit log without a new event-type contract.
+ *
+ * Mount with:
+ *   builder.addSubFlowChartNext(
+ *     SUBFLOW_IDS.INJECTION_ENGINE,
+ *     buildInjectionEngineSubflow({ injections }),
+ *     'Injection Engine',
+ *     {
+ *       inputMapper: (parent) => ({
+ *         iteration: parent.iteration,
+ *         userMessage: parent.userMessage,
+ *         history: parent.history,
+ *         lastToolResult: parent.lastToolResult,
+ *         toolResults: parent.toolResults, // the whole batch, in call order
+ *         activatedInjectionIds: parent.activatedInjectionIds ?? [],
+ *         priorActiveByslot: parent.activeByslot ?? EMPTY_ACTIVE_BY_SLOT,
+ *       }),
+ *       outputMapper: (sf) => ({
+ *         activeInjections: sf.activeInjections,
+ *         activeByslot: sf.activeByslot, // carried so next turn's Delta can diff
+ *       }),
+ *     },
+ *   )
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffActiveBySlot = exports.routeActiveInjections = exports.buildInjectionEngineSubflow = exports.EMPTY_ACTIVE_BY_SLOT = void 0;
+const footprintjs_1 = require("footprintjs");
+const typedEmit_js_1 = require("../recorders/core/typedEmit.js");
+const iterationBudget_js_1 = require("../lib/iterationBudget.js");
+const evaluator_js_1 = require("./evaluator.js");
+const types_js_1 = require("./types.js");
+const skillGraph_js_1 = require("./skillGraph.js");
+const routingPolicy_js_1 = require("./routingPolicy.js");
+const skillSteps_js_1 = require("./skillSteps.js");
+const leases_js_1 = require("./leases.js");
+const lease_js_1 = require("../maps/engagement/lease.js");
+const parkCard_js_1 = require("../maps/engagement/parkCard.js");
+/** Empty buckets — turn-1 prior, and the safe default for the mappers. */
+exports.EMPTY_ACTIVE_BY_SLOT = {
+    systemPrompt: [],
+    messages: [],
+    tools: [],
+};
+/**
+ * Build the Injection Engine subflow — Gather → Evaluate → Route → Delta.
+ */
+function buildInjectionEngineSubflow(config) {
+    const injections = config.injections;
+    return (0, footprintjs_1.flowChart)('Gather', gatherStage, 'gather', {
+        description: "Snapshot this turn's injection inputs (iteration, history, last tool, LLM-activated)",
+    })
+        .addFunction('Evaluate', makeEvaluateStage(injections, config.nextSkill, config.explainNextSkill, config.supersededEntries, config.stepPlanFor, config.reachableSkills, config.engagement), 'evaluate', 'Evaluate every Injection trigger; produce activeInjections + metadata')
+        .addFunction('Route', routeStage, 'route', 'Partition active injections into per-slot buckets (system-prompt / messages / tools)')
+        .addFunction('Delta', deltaStage, 'delta', 'Per-slot delta vs last turn: what activated / deactivated / stayed')
+        .build();
+}
+exports.buildInjectionEngineSubflow = buildInjectionEngineSubflow;
+// ── Stage 1: Gather ──────────────────────────────────────────────────────
+/** Observability-only: record what this turn is being evaluated against. */
+function gatherStage(scope) {
+    const args = scope.$getArgs();
+    scope.$setValue('injectionContextSummary', {
+        iteration: args.iteration ?? 1,
+        historyLength: args.history?.length ?? 0,
+        lastToolName: args.lastToolResult?.toolName,
+        activatedInjectionCount: args.activatedInjectionIds?.length ?? 0,
+    });
+}
+// ── Stage 2: Evaluate (logic identical to the old single stage) ──────────
+function makeEvaluateStage(injections, nextSkill, explainNextSkill, supersededEntries, stepPlanFor, reachableSkills, engagementPlan) {
+    return (scope) => {
+        const args = scope.$getArgs();
+        // The accepted transition proposal (9.19.0), VALID only on the iteration
+        // after its grant — one-shot by data, the same one-shot-ness the pick
+        // gets from being rewritten, with zero clearing writes (an agent whose
+        // tools never propose keeps its exact committed keys).
+        const iteration = args.iteration ?? 1;
+        const proposal = args.pendingToolTransition !== undefined &&
+            args.pendingToolTransition.iteration + 1 === iteration
+            ? args.pendingToolTransition
+            : undefined;
+        const baseCtx = {
+            iteration,
+            // The action budget, as ONE fact with two spellings (9.57.0). Written
+            // together so the pairing invariant — both or neither — is a property
+            // of this object literal rather than a rule somebody has to remember.
+            ...(args.maxIterations !== undefined && {
+                maxIterations: args.maxIterations,
+                iterationsRemaining: (0, iterationBudget_js_1.iterationsRemainingOf)(args.maxIterations, iteration),
+            }),
+            userMessage: args.userMessage ?? '',
+            history: args.history ?? [],
+            ...(args.lastToolResult && { lastToolResult: args.lastToolResult }),
+            ...(args.toolResults && { toolResults: args.toolResults }),
+            activatedInjectionIds: args.activatedInjectionIds ?? [],
+            ...(args.currentSkillId !== undefined && { currentSkillId: args.currentSkillId }),
+            ...(args.pendingSkillPick !== undefined && { pendingSkillPick: args.pendingSkillPick }),
+            ...(proposal !== undefined && {
+                pendingToolTransition: { targetSkillId: proposal.targetSkillId },
+            }),
+            ...(args.entryScores !== undefined && { entryScores: args.entryScores }),
+            ...(args.entryScorer !== undefined && { entryScorer: args.entryScorer }),
+            ...(args.turnRoute !== undefined && { turnRoute: args.turnRoute }),
+        };
+        // KEYSTONE cursor advance — derive the next cursor from the SAME ctx the
+        // route triggers gate on (`nextSkill(ctx) === id`), so the active set and the
+        // stored cursor can never disagree. Written to a DISTINCT output key
+        // (`nextSkillCursor`) because `currentSkillId` arrives as a readonly INPUT
+        // here; the mount's outputMapper maps it onto the parent's mutable
+        // `currentSkillId` for the next iteration. Skill-graph agents only.
+        // ONE consultation of the graph per iteration: when the graph can explain
+        // itself (8.5.0) the cursor comes out of `.to`, so asking for the cause costs
+        // nothing extra and cannot answer a different destination than the routing did.
+        const move = explainNextSkill ? explainNextSkill(baseCtx) : undefined;
+        const routes = explainNextSkill !== undefined || nextSkill !== undefined;
+        const cursor = move ? move.to : nextSkill ? nextSkill(baseCtx) : undefined;
+        if (routes) {
+            scope.$setValue('nextSkillCursor', cursor);
+        }
+        // ── The step pointer's TENURE RE-KEY (9.18.0) ─────────────────────
+        // Same discipline as the cursor, one line down from it: `stepPointer`
+        // arrives as a readonly INPUT, so the fresh value goes out under a
+        // DISTINCT key (`nextStepPointer` — the currentSkillId/nextSkillCursor
+        // alias, NOT the turn-constant turnRoute pattern) and the mount mappers
+        // carry it back onto the parent. The tenant is the ADVANCED cursor on
+        // graph agents, else the tail of `activatedInjectionIds` (the shipped
+        // `activeSkillId` notion). Written on EVERY iteration the feature is on
+        // (the `if (routes)` precedent) so a downstream reader never sees a
+        // stale pointer; gated on `stepPlanFor` so agents without steps commit
+        // exactly the keys they always did.
+        //
+        // Computed BEFORE `evaluateInjections`, and the FRESH pointer goes into
+        // the ctx the triggers read — else `defineStepsHint`'s trigger would
+        // judge the stale pointer and the hint would miss the tenure's first
+        // iteration while the banner (tools slot, fresh value) was present.
+        let ctx = baseCtx;
+        if (stepPlanFor) {
+            const activated = args.activatedInjectionIds ?? [];
+            const tenant = routes ? cursor : activated[activated.length - 1];
+            const fresh = (0, skillSteps_js_1.rekeyStepPointer)({ prior: args.stepPointer, tenant, stepPlanFor });
+            scope.$setValue('nextStepPointer', fresh);
+            const freshPointer = (0, skillSteps_js_1.pointerOf)(fresh);
+            ctx = { ...baseCtx, ...(freshPointer !== undefined && { stepPointer: freshPointer }) };
+        }
+        // ── Instruction leases (9.19.0) — the `require-instruction` push ───
+        // Validity is COMPUTED per pass against the ADVANCED tenure (a lease
+        // dies the same pass its tenure ends): `'next-call'` serves exactly the
+        // pass after its grant; `'until-skill-exit'` serves while the granting
+        // tenant still holds. The served ids ride the ctx the evaluator reads,
+        // which admits them into the active set beside their own triggers.
+        // Zero-cost gate: no granted lease anywhere → not one line here runs.
+        if (args.instructionLeases !== undefined) {
+            const leaseTenant = (0, leases_js_1.tenantOf)(routes ? cursor : undefined, args.activatedInjectionIds);
+            if (args.instructionLeases.length > 0) {
+                const leaseIds = (0, leases_js_1.activeLeaseIds)(args.instructionLeases, ctx.iteration, leaseTenant);
+                if (leaseIds.length > 0) {
+                    ctx = { ...ctx, leaseActiveIds: leaseIds };
+                }
+            }
+            // The TENURE SWEEP — what makes lease death PERMANENT. `skillId ===
+            // tenant` alone cannot tell "held the tenure all along" from
+            // "re-entered the granting skill later" (a cyclic graph makes both
+            // real), so the pass that sees a tenure end removes its dead leases
+            // from the record — computed AFTER `activeLeaseIds` (this pass's
+            // serving is untouched; the swept array feeds only future passes).
+            // Same alias round trip as the cursor: `instructionLeases` is a
+            // readonly boundary INPUT here, so the survivors go out under
+            // `nextInstructionLeases` and the mount mappers carry them back onto
+            // the parent key. Written on EVERY pass the key exists — even as [] —
+            // so no boundary ever re-delivers a stale, pre-sweep array.
+            scope.$setValue('nextInstructionLeases', (0, leases_js_1.pruneLeases)(args.instructionLeases, ctx.iteration, leaseTenant));
+        }
+        // A parallel batch whose results matched edges to DIFFERENT targets
+        // (9.16.0). The resolver already decided the hop — first match in call
+        // order won — and reported the suppression on the move; here it goes on
+        // the record as its own typed event, stamped the iteration it happened.
+        // Silent-drop was the pre-9.16.0 behavior this replaces: earlier calls of
+        // a batch simply never routed. POJO copies, because event payloads must
+        // be detached plain data.
+        if (move?.conflict) {
+            (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.skill.route_conflict', {
+                iteration: ctx.iteration,
+                ...(ctx.currentSkillId !== undefined && { fromSkillId: ctx.currentSkillId }),
+                winner: { ...move.conflict.winner },
+                losers: move.conflict.losers.map((l) => ({ ...l })),
+            });
+        }
+        // ── Map engagement (9.58.0) — the mount kernel's one pass ──────────
+        // Advanced with the SAME facts the triggers gate on, BEFORE the
+        // evaluator runs, so a re-engagement earned this pass serves this pass
+        // and a park suppresses this pass — the record and the wire can never
+        // disagree. The state rides the boundary as a readonly INPUT
+        // (`mapEngagement`) and leaves under the DISTINCT key
+        // `nextMapEngagement` (the cursor/lease alias discipline). The cursor
+        // itself is untouched by every branch of this block: engagement is the
+        // kernel's axis, position is the map's.
+        let parkCardText;
+        if (engagementPlan !== undefined) {
+            const advance = (0, lease_js_1.advanceEngagement)(engagementPlan, args.mapEngagement, {
+                iteration: ctx.iteration,
+                ...(cursor !== undefined && { currentNode: cursor }),
+                ...(move?.by !== undefined && { moveBy: move.by }),
+                ...(move?.witness?.text !== undefined && { witness: move.witness.text }),
+                toolResults: (0, types_js_1.toolResultsOf)(ctx),
+                ...(ctx.pendingSkillPick !== undefined && { pendingSkillPick: ctx.pendingSkillPick }),
+                // PER-PASS picks (9.59.0), not the turn-cumulative activation list.
+                acceptedSkillPicks: args.acceptedSkillPicks ?? [],
+                // The idle test's SERVED clause (9.59.0) — what the engine actually
+                // put on the wire last pass, carried under the kernel's own key.
+                servedLastPass: args.servedInjectionIds ?? [],
+            });
+            // Written on EVERY pass the feature is on (the `if (routes)` precedent)
+            // so a boundary never re-delivers stale engagement state.
+            scope.$setValue('nextMapEngagement', advance.next);
+            for (const change of advance.changes) {
+                if (change.kind === 'engaged') {
+                    (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.map.engaged', {
+                        mapId: change.mapId,
+                        iteration: change.iteration,
+                        by: change.by,
+                        ...(change.witness !== undefined && { witness: change.witness }),
+                        ...(change.reengaged === true && { reengaged: true }),
+                        // A guess that real evidence confirmed, and the cause it was
+                        // FOUNDED on — so a reader of the record sees both halves of the
+                        // story instead of a `by` that silently rewrote itself (9.59.0).
+                        ...(change.upgraded === true && { upgraded: true }),
+                        // The cursor moved to a different member: eligibility was
+                        // re-derived from THIS member's evidence, not inherited.
+                        ...(change.tenantChanged === true && { tenantChanged: true }),
+                        ...(change.at !== undefined && { at: change.at }),
+                        ...(change.foundedBy !== undefined && { foundedBy: change.foundedBy }),
+                    });
+                }
+                else {
+                    (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.map.parked', {
+                        mapId: change.mapId,
+                        iteration: change.iteration,
+                        by: change.by,
+                        idleCalls: change.idleCalls,
+                        ...(change.witness !== undefined && { witness: change.witness }),
+                    });
+                }
+            }
+            // ── The MODEL-VISIBLE surface (9.59.0) ──────────────────────────
+            // Everything above lands on the RECORD, which the model never reads.
+            // The card is the one thing it does read: cursor and engagement shown
+            // as SEPARATE fields, the reason, and the way back named as a concrete
+            // call. Built from the state that was just advanced, so the card and
+            // the suppression are two views of one decision.
+            parkCardText = (0, parkCard_js_1.parkCard)(engagementPlan, advance.next);
+            // Tools come off the wire on the ENGAGEMENT axis, independently of
+            // `scopeTools` — see `EngagementAdvance.parkedToolNames`.
+            scope.$setValue('parkedToolNames', advance.parkedToolNames);
+            if (advance.parkedInjectionIds.length > 0) {
+                ctx = { ...ctx, parkedIds: advance.parkedInjectionIds };
+            }
+        }
+        const evaluation = (0, evaluator_js_1.evaluateInjections)(injections, ctx);
+        // The suppression the cursor law performs (8.15.0). Asked ONCE, on the same ctx
+        // the triggers gated on, so the reported suppression and the active set are two
+        // views of one evaluation and cannot disagree.
+        const supersededIds = supersededEntries ? [...supersededEntries(ctx)] : [];
+        // The told-the-truth check. `read_skill` answered "Skill 'X' activated for the
+        // next iteration" and the gate accepted the pick — so X must be in THIS pass's
+        // active set. It normally is (the pick moved the cursor). The one case where it
+        // isn't: a declared edge fired the same turn and won the cursor (`D1 > D2` —
+        // the model emitted a domain tool AND read_skill in one message, and the domain
+        // tool's result matched a route). Rather than let a promise quietly go unmet,
+        // say so on the record. Checked against the REAL active set, not against which
+        // clause won — the question is "did the promised skill load?", and only the
+        // active set answers it.
+        //
+        // 8.15.0 widened WHEN that answer is "no", without changing the question. A
+        // superseded pick onto a rules-form entry used to slip through: the pick lost the
+        // cursor, but the entry's own rule kept it active anyway, so the promise looked
+        // kept by accident. Conditional entries are cursor-gated now, so the same hop
+        // reports itself. `supersededIds` below is a DIFFERENT fact — a continuous
+        // suppression, nobody's broken promise — and deliberately does not come out here.
+        const pick = ctx.pendingSkillPick;
+        if (pick !== undefined && !evaluation.active.some((inj) => inj.id === pick)) {
+            (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.skill.reroute_superseded', {
+                volunteeredId: pick,
+                ...(cursor !== undefined && { wonId: cursor }),
+                ...(ctx.currentSkillId !== undefined && { fromSkillId: ctx.currentSkillId }),
+                iteration: ctx.iteration,
+            });
+        }
+        // The same told-the-truth check for an ACCEPTED transition proposal
+        // (9.19.0): the effect was accepted (`tools.effect { outcome:
+        // 'accepted' }` is on the record) but a declared edge fired on the same
+        // batch and won the cursor (D1 outranks the proposal exactly as it
+        // outranks a pick). Said out loud rather than left as a promise that
+        // quietly went unmet.
+        if (proposal !== undefined && cursor !== proposal.targetSkillId) {
+            (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.skill.reroute_superseded', {
+                volunteeredId: proposal.targetSkillId,
+                ...(cursor !== undefined && { wonId: cursor }),
+                ...(ctx.currentSkillId !== undefined && { fromSkillId: ctx.currentSkillId }),
+                iteration: ctx.iteration,
+                source: 'tool-proposal',
+            });
+        }
+        // activeInjections — the REAL output the slot subflows read. POJO
+        // projections (no trigger functions, no Tool execute functions) so they
+        // survive footprintjs's transactional scope buffer (which clones on
+        // write). Tool schemas are preserved + tagged by injectionId so the
+        // Agent's closure-held registry can look up the executable.
+        // The ctx goes in (9.57.0): this is the one moment the context and the
+        // content are both in scope, so a templated instruction is rendered here
+        // and every reader downstream sees the same plain text it always saw.
+        const activePOJOs = evaluation.active.map((inj) => (0, types_js_1.projectActiveInjection)(inj, ctx));
+        // The park card rides as its own row — a reserved id, so it is one
+        // identifiable line on the record (composition, budget, the context
+        // ledger) instead of an anonymous string glued onto somebody's fragment.
+        // Appended LAST: it is a framework aside about the map, and it should
+        // read after the content it is commenting on.
+        if (parkCardText !== undefined) {
+            activePOJOs.push({
+                id: parkCard_js_1.PARK_CARD_ID,
+                flavor: 'steering',
+                description: 'the mount kernel telling the model which maps are parked, and the way back',
+                inject: { systemPrompt: parkCardText },
+            });
+        }
+        scope.$setValue('activeInjections', activePOJOs);
+        // The kernel's SERVED carrier (9.59.0) — this pass's answer, read as the
+        // previous pass's on the next one. Written on EVERY pass the kernel is
+        // mounted (even as []), so a boundary never re-delivers a stale set.
+        if (engagementPlan !== undefined) {
+            scope.$setValue('nextServedInjectionIds', activePOJOs.map((i) => i.id));
+        }
+        const routing = routingEntriesOf(evaluation.active);
+        // Structural copy (the events layer stays decoupled from `CursorMove`), and a
+        // POJO so it survives the emit channel's clone.
+        //
+        // SG-C decoration: on the iteration a MODEL PICK resolves an outstanding
+        // turn-start menu, the move carries the menu it resolved (`offered`) — and
+        // `declinedOffer: true` when the accepted pick was reachable but NOT on it.
+        // Under 'assist' the model's divergence from the menu is DATA, not a
+        // refusal; without this stamp the record could not tell an on-menu pick
+        // from an off-menu one. `menuOutstanding` is the same one implementation
+        // the envelope and the 'guard' gate use, judged on the PRE-advance cursor
+        // (this very move is what closes the menu).
+        const resolvedMenu = move?.by === 'model-pick' &&
+            move.to !== undefined &&
+            (0, routingPolicy_js_1.menuOutstanding)(ctx.turnRoute, ctx.currentSkillId)
+            ? {
+                offered: [...ctx.turnRoute.offered],
+                ...(ctx.turnRoute.offered.includes(move.to) ? {} : { declinedOffer: true }),
+            }
+            : undefined;
+        // The gate's admissible set from the LANDED cursor (9.50.0) — asked once,
+        // beside the one resolver consultation, so the recorded set and this
+        // iteration's read_skill offer/refusals come from the same answer. A POJO
+        // copy (event payloads are detached plain data); `[]` is a fact (a dead
+        // end), absence means the graph could not say.
+        const reachable = move !== undefined && reachableSkills ? [...reachableSkills(cursor)] : undefined;
+        const cursorMove = move
+            ? {
+                ...(move.from !== undefined && { from: move.from }),
+                ...(move.to !== undefined && { to: move.to }),
+                by: move.by,
+                ...(reachable !== undefined && { reachable }),
+                // Tier-1 DATA-matcher evidence (9.28.0) — what the message said that
+                // routed this hop. Copied field-by-field: the event payload is a
+                // structural shape, never the engine's own object.
+                ...(move.witness !== undefined && {
+                    witness: {
+                        text: move.witness.text,
+                        ...(move.witness.keyword !== undefined && { keyword: move.witness.keyword }),
+                    },
+                }),
+                // Data-guard evidence (9.51.0) — the taken hop's evaluation and the
+                // refusals, copied field-by-field like the witness: the event
+                // payload is a structural shape, never the engine's own object.
+                ...(move.guard !== undefined && { guard: copyGuardEvaluation(move.guard) }),
+                ...(move.guardsClosed !== undefined &&
+                    move.guardsClosed.length > 0 && {
+                    guardsClosed: move.guardsClosed.map(copyGuardEvaluation),
+                }),
+                ...resolvedMenu,
+            }
+            : undefined;
+        // Aggregate evaluation metadata is pure OBSERVABILITY — no flow stage
+        // reads it — so it goes out the EMIT channel where a recorder/Lens can
+        // observe "what was considered, what won, what was skipped and why".
+        (0, typedEmit_js_1.typedEmit)(scope, 'agentfootprint.context.evaluated', {
+            iteration: ctx.iteration,
+            activeCount: evaluation.active.length,
+            skippedCount: evaluation.skipped.length,
+            evaluatedTotal: injections.length,
+            activeIds: evaluation.active.map((i) => i.id),
+            skippedDetails: evaluation.skipped,
+            triggerKindCounts: countTriggerKinds(evaluation.active),
+            // The Skill menu the LLM was offered (same text as the read_skill tool
+            // description) — pair "offered" with "chosen" (activatedInjectionIds) to
+            // debug a missed/wrong read_skill call.
+            skillCatalog: skillCatalogOf(injections),
+            // Routing PROVENANCE for active skill-graph injections — the decision path
+            // / edge that reached each. Undefined when none came from a skillGraph().
+            //
+            // NOTE the difference from `cursorMove` below, which is the whole reason the
+            // latter exists: `routing[]` is BUILD-TIME provenance ("how is this skill
+            // reachable at all"), stamped once by the compiler. It answers per SKILL, not
+            // per HOP. Reading it as the cause of this turn's move is what made a model
+            // pick get recorded under a declared edge's label.
+            ...(routing && { routing }),
+            // How the CURSOR actually moved this iteration, straight from the clause that
+            // won inside the resolver (8.5.0). Skill-graph agents only; absent for a graph
+            // built before `explainNextSkill` existed.
+            ...(cursorMove && { cursorMove }),
+            // Entries whose own `when` matched and which the cursor law kept OFF the wire
+            // (8.15.0). A conditional entry is active exactly while the cursor is on it,
+            // and a suppression the run cannot name is a silent drop. Omitted when nothing
+            // was suppressed, so the common iteration is byte-identical to 8.14.0.
+            ...(supersededIds.length > 0 && { supersededIds }),
+        });
+    };
+}
+/** One guard evaluation as a DETACHED POJO for the emit channel (9.51.0) —
+ *  field-by-field, conditions included: event payloads must be plain data,
+ *  and value arrays are re-sliced so no live reference rides the record. */
+function copyGuardEvaluation(g) {
+    return {
+        from: g.from,
+        to: g.to,
+        toolName: g.toolName,
+        ...(g.toolCallId !== undefined && { toolCallId: g.toolCallId }),
+        verdict: g.verdict,
+        conditions: g.conditions.map((c) => ({
+            key: c.key,
+            op: c.op,
+            value: Array.isArray(c.value) ? [...c.value] : c.value,
+            actualSummary: c.actualSummary,
+            passed: c.passed,
+        })),
+    };
+}
+/** Per active skill-graph injection: its routing provenance + unlocked tools.
+ *  Returns undefined when no active injection carries skill-graph metadata, so
+ *  the emit payload omits `routing` entirely for non-skill-graph runs. */
+function routingEntriesOf(active) {
+    const entries = active.flatMap((inj) => {
+        const routing = inj.metadata?.[skillGraph_js_1.SKILL_GRAPH_METADATA_KEY];
+        if (!routing)
+            return [];
+        return [
+            {
+                injectionId: inj.id,
+                flavor: inj.flavor,
+                via: routing.via,
+                ...(routing.path && {
+                    path: routing.path.map((s) => ({ label: s.label, branch: s.branch })),
+                }),
+                ...(routing.label && { label: routing.label }),
+                ...(routing.from && { from: routing.from }),
+                ...(routing.triggerKind && { triggerKind: routing.triggerKind }),
+                tools: (inj.inject.tools ?? []).map((t) => t.schema.name),
+            },
+        ];
+    });
+    return entries.length > 0 ? entries : undefined;
+}
+// ── Stage 3: Route ───────────────────────────────────────────────────────
+/** Partition active injections by the slot(s) each contributes to. Mirrors
+ *  the slot subflows' own filters so this view matches what they compose.
+ *  Pure — exported for unit tests + reuse (e.g. the lens). */
+function routeActiveInjections(active) {
+    const systemPrompt = [];
+    const messages = [];
+    const tools = [];
+    for (const inj of active) {
+        const entry = {
+            id: inj.id,
+            source: inj.flavor,
+            reason: inj.description ?? `${inj.flavor} '${inj.id}' active`,
+        };
+        // system-prompt: has prompt content AND not a tool-only Skill
+        // (mirrors buildSystemPromptSlot's Block C suppression).
+        if (inj.inject.systemPrompt &&
+            inj.inject.systemPrompt.length > 0 &&
+            !(inj.flavor === 'skill' && inj.surfaceMode === 'tool-only')) {
+            systemPrompt.push(entry);
+        }
+        if (inj.inject.messages && inj.inject.messages.length > 0)
+            messages.push(entry);
+        if (inj.inject.tools && inj.inject.tools.length > 0)
+            tools.push(entry);
+    }
+    return { systemPrompt, messages, tools };
+}
+exports.routeActiveInjections = routeActiveInjections;
+function routeStage(scope) {
+    const active = scope.$getValue('activeInjections') ?? [];
+    scope.$setValue('activeByslot', routeActiveInjections(active));
+}
+// ── Stage 4: Delta ───────────────────────────────────────────────────────
+/** Diff this turn's per-slot buckets against last turn's (carried via the
+ *  mount mappers as `priorActiveByslot`). Turn 1 / unwired → all "added". */
+function deltaStage(scope) {
+    const current = scope.$getValue('activeByslot') ?? exports.EMPTY_ACTIVE_BY_SLOT;
+    const prior = scope.$getArgs().priorActiveByslot ?? exports.EMPTY_ACTIVE_BY_SLOT;
+    scope.$setValue('slotDelta', diffActiveBySlot(prior, current));
+}
+/** Diff two per-slot snapshots into a per-slot delta. Pure — exported for
+ *  unit tests + reuse. */
+function diffActiveBySlot(prior, current) {
+    return {
+        systemPrompt: diffSlot(prior.systemPrompt, current.systemPrompt),
+        messages: diffSlot(prior.messages, current.messages),
+        tools: diffSlot(prior.tools, current.tools),
+    };
+}
+exports.diffActiveBySlot = diffActiveBySlot;
+/** added = now-not-before, removed = before-not-now, kept = both. */
+function diffSlot(prior, current) {
+    const priorIds = new Set(prior.map((e) => e.id));
+    const currentIds = new Set(current.map((e) => e.id));
+    return {
+        added: [...currentIds].filter((id) => !priorIds.has(id)),
+        removed: [...priorIds].filter((id) => !currentIds.has(id)),
+        kept: [...currentIds].filter((id) => priorIds.has(id)),
+    };
+}
+/** The Skill catalog the LLM was offered — id + description for every Skill
+ *  injection, mirroring buildReadSkillTool's `(no description)` fallback. */
+function skillCatalogOf(injections) {
+    return injections
+        .filter((i) => i.flavor === 'skill')
+        .map((i) => ({ id: i.id, description: i.description ?? '(no description)' }));
+}
+/** Count active injections by trigger kind (observability metric). */
+function countTriggerKinds(active) {
+    const counts = {};
+    for (const inj of active) {
+        counts[inj.trigger.kind] = (counts[inj.trigger.kind] ?? 0) + 1;
+    }
+    return counts;
+}
+//# sourceMappingURL=buildInjectionEngineSubflow.js.map