agentfootprint 13.0.0 → 14.0.0

package/dist/esm/core/agent/stages/toolCalls/routing/readSkillRoute.js

@@ -0,0 +1,234 @@
+import { spoken } from '../../../../../lib/spokenIds.js';
+import { classifySkillTarget } from '../../../../../injection-engine/skillGraph.js';
+import { dedupeIds } from '../helpers/dedupeIds.js';
+import { selfCallNotice, selfSkillTools } from '../../../selfCallNotice.js';
+import { skillActivationConfirmation } from '../../../../../injection-engine/skillToolDescriptors.js';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+import { composeReadSkillRefusal } from '../helpers/readSkillRefusal.js';
+import { menuOutstanding } from '../../../../../injection-engine/routingPolicy.js';
+/** Apply the existing post-execution read_skill route, in the original order. */
+export function applyReadSkillRoute(scope, deps, bindings) {
+    if (deps.allowedSkillIds &&
+        bindings.tc.name === 'read_skill' &&
+        !bindings.outcome.error &&
+        !bindings.execution.denied) {
+        const reqId = bindings.callArguments.callArgs.id;
+        if (typeof reqId === 'string' && reqId.length > 0) {
+            const currentSkillId = scope.currentSkillId;
+            // ── ADMISSION reads the graph; every SENTENCE reads the filter ──
+            // Two sets, deliberately (9.86.0). `admissible` is the routing law:
+            // what the graph and the mount actually grant, unfiltered, because a
+            // narrowing may take a schema off the wire but never a name out of
+            // the dispatch map — role visibility governs what the model is TOLD,
+            // not what the gate admits. `hopsNamed` / `openNamed` are what any
+            // sentence, and the `skill.rejected` payload, may NAME: the same
+            // hidden set the description filtered itself with, resolved once by
+            // the tools slot and carried here on scope. Without it the refusals
+            // read the raw sets and could name a skill this role may never see —
+            // the leak the description closed, one stage downstream. (A hidden
+            // skill cannot reach this gate anyway: the `skill_read` permission
+            // gate above denies it first, on the same checker. The filter is
+            // what keeps that true by construction rather than by coincidence.)
+            const hiddenIds = new Set(scope.hiddenSkillIds ?? []);
+            const mayName = (id) => !hiddenIds.has(id);
+            const hops = deps.allowedSkillIds(currentSkillId);
+            const openAll = deps.openSkillIds ?? [];
+            // `spoken` keeps BOTH halves — what may be named, and whether the
+            // graph held anything before the filter ran. A composer handed only
+            // the filtered array cannot tell "nothing was reachable" from
+            // "nothing reachable may be named", and it used to assert the first.
+            const hopsSpoken = spoken(hops, mayName);
+            const openSpoken = spoken(openAll, mayName);
+            // The cursor through the SAME filter (9.86.1). The description
+            // withholds a hidden cursor's name and every refusal below printed
+            // it raw in two clauses; `cursorWithheld` keeps the sentence's
+            // anchor honest ("the skill the cursor stood in") without the id.
+            const cursorSpoken = currentSkillId === undefined
+                ? {}
+                : mayName(currentSkillId)
+                    ? { cursorId: currentSkillId }
+                    : { cursorWithheld: true };
+            const hopsNamed = hopsSpoken.named;
+            const openNamed = openSpoken.named;
+            // The ONE owner of "is this target the cursor?" — the same function
+            // the description, the tool-effects judge and the permission gate
+            // switch on, so a stay means the same thing in all four.
+            const targetClass = classifySkillTarget({
+                ...(currentSkillId !== undefined && { cursor: currentSkillId }),
+                target: reqId,
+                hops,
+                open: openAll,
+            });
+            bindings.skillRoute.skillHop = targetClass === 'hop';
+            const admissible = dedupeIds([...hops, ...openAll]);
+            const allowed = dedupeIds([...hopsNamed, ...openNamed]);
+            // ── The RE-ENGAGEMENT arm (9.59.0) — a third admission class ──
+            // A pick must be routed by INTENT. The reachable set deliberately
+            // excludes the node the cursor already occupies (`makeReachableSkills`
+            // filters it out), which is right for a MOVE and wrong for an
+            // ENGAGEMENT: parking never moves the cursor, so a parked map is
+            // parked exactly WHERE the model wants to return, and the refusal
+            // then told the model to "answer with the current skill" — whose
+            // prompt and tools had just been suppressed. For a single-member
+            // map that made parking permanent for the rest of the turn, under
+            // documentation calling this pick the recovery door.
+            //
+            // So: a pick of a PARKED map's member is admitted, activates, and
+            // does NOT touch the cursor — the same shape as an OPEN skill
+            // ("they ACTIVATE and never move the cursor"). `skillHop` stays
+            // false, `pendingSkillPick` stays unwritten, and the pick lands on
+            // `acceptedSkillPicks`, which the kernel's renewal feed reads as
+            // explicit evidence and re-engages on the very next pass.
+            const parked = bindings.parkedNow(scope);
+            const reengaging = parked?.has(reqId) === true;
+            if (reengaging) {
+                // Admitted. Nothing to refuse and no posture to apply: this is
+                // not a hop, and a posture governs routing, not engagement.
+            }
+            else if (targetClass === 'self') {
+                // ── The SELF-CALL arm (9.84.0) — BEFORE reachability ─────────
+                // The cursor is in neither half of `allowed`, by construction:
+                // `makeReachableSkills` filters it out of its own successor set
+                // and `openSkillIds()` excludes every graph-wired skill. So a
+                // pick of the skill the model is ALREADY IN fell through to the
+                // reachability arm and came back "not reachable from here" —
+                // about the one skill whose body was in the prompt and whose
+                // tools were in that same call's tool list. Models read that as
+                // "unavailable" and stop, which is exactly what happened in the
+                // field, three times in one day.
+                //
+                // It stays a REJECTION mechanically — no activation to append
+                // (the cursor already activates it), no hop (`skillHop` is false
+                // for the cursor anyway), and the refusal cap still counts it,
+                // because a self-call LOOP is precisely the stuck model that
+                // budget exists to escalate. What changes is the sentence: an
+                // acknowledgement of where the model stands, and — named from
+                // this call's own wire list, never from the declaration — what
+                // it can call right now. `reason` on the event is what lets a
+                // consumer tell the two apart without comparing ids.
+                //
+                // Ordered after re-engagement on purpose: a parked map member
+                // picked at its own cursor is a genuine re-engagement request,
+                // and re-engaging it beats telling the model about tools that
+                // the park has just taken off the wire.
+                bindings.skillRoute.skillRejected = true;
+                // The wire the model was ACTUALLY handed on THIS call — the one
+                // the notice speaks about and the only one it may speak about.
+                // Read unconditionally: a `scope.wrapUpAsked` guard here could
+                // never fire. This stage runs only on the Route decider's
+                // `'tool-calls'` branch, which it takes only while
+                // `iteration < maxIterations`; `wrapUpStage` raises the latch one
+                // iteration PAST that, so every self-call is composed with the
+                // latch still down.
+                const wire = scope.dynamicToolSchemas;
+                // No routing map is passed, and that is the fix rather than an
+                // omission. A tool result is re-read on every later call of the
+                // turn, so any id named here as somewhere `read_skill` could go
+                // is a PREDICTION — and three separate mechanisms falsify it
+                // after this line has run: the budget (a hop is a tool call, and
+                // the wrap-up dispatches none), the POSTURE arm forty lines below
+                // (`rails` refuses every model hop; `guard` refuses every hop off
+                // an outstanding menu, which is the default state of a decisively
+                // routed turn), and the cursor itself (a sibling tool in this
+                // very batch can fire a step edge). Passing `hops` through the
+                // hidden-id filter fixed only the third-party leak and left all
+                // three staleness paths open; the notice contradicting the
+                // posture arm's own refusal — and costing a refusal from the
+                // escalation budget to find out — was the live bug. The routing
+                // map belongs to the `read_skill` DESCRIPTION, which is
+                // recomposed on every call and is therefore never stale.
+                bindings.outcome.result = selfCallNotice({
+                    skillId: reqId,
+                    tools: selfSkillTools(reqId, scope.activeInjections, wire),
+                    // A body only exists under `surfaceMode: 'both'` (`'tool-only'`
+                    // is refused at build for anything a graph routes, and only a
+                    // graph-wired skill can be the cursor); every other mode
+                    // returns the activation confirmation, which would promise an
+                    // activation that is not pending. `ceilingRefused` is the third
+                    // shape `result` can hold — a `resultCeiling`/`resultColumns`
+                    // refusal composed above — and it is nobody's instructions.
+                    ...(typeof bindings.outcome.result === 'string' &&
+                        !bindings.execution.ceilingRefused &&
+                        bindings.outcome.result !== skillActivationConfirmation(reqId) && {
+                        body: bindings.outcome.result,
+                    }),
+                });
+                typedEmit(scope, 'agentfootprint.skill.rejected', {
+                    requestedId: reqId,
+                    currentSkillId,
+                    allowed,
+                    iteration: bindings.iteration,
+                    reason: 'self-call',
+                });
+                bindings.noteSkillRefusal(scope, bindings.iteration);
+            }
+            else if (!admissible.includes(reqId)) {
+                bindings.skillRoute.skillRejected = true;
+                bindings.outcome.result = composeReadSkillRefusal({
+                    requestedId: reqId,
+                    targetClass,
+                    ...cursorSpoken,
+                    hops: hopsSpoken,
+                    openIds: openSpoken,
+                    ...(deps.skillGraphIsTree === true && { isTree: true }),
+                });
+                typedEmit(scope, 'agentfootprint.skill.rejected', {
+                    requestedId: reqId,
+                    ...(currentSkillId !== undefined && { currentSkillId }),
+                    allowed,
+                    iteration: bindings.iteration,
+                    reason: 'unreachable',
+                });
+                bindings.noteSkillRefusal(scope, bindings.iteration);
+            }
+            else if (deps.skillStrictness !== undefined && bindings.skillRoute.skillHop) {
+                // ── The POSTURE arm (SG-C) — after reachability, hops only. ──
+                // OPEN skills never reach here (skillHop is false for them), so
+                // `.selfExplain()` and friends stay admitted under every posture.
+                const turnRoute = scope.turnRoute;
+                const onOutstandingMenu = menuOutstanding(turnRoute, currentSkillId) &&
+                    turnRoute?.offered?.includes(reqId) === true;
+                const refusedByPosture = deps.skillStrictness === 'rails' ||
+                    (deps.skillStrictness === 'guard' && !onOutstandingMenu);
+                if (refusedByPosture) {
+                    bindings.skillRoute.skillRejected = true;
+                    bindings.skillRoute.skillHop = false; // a refused pick must not move the cursor below
+                    // The posture arm names NO hop — under 'rails' the model does
+                    // not route, and under 'guard' it routes only from a menu — so
+                    // the composer is handed the menu when there IS one and an
+                    // empty hop list either way. Open skills are still named:
+                    // they never reach this arm, so nothing here can decline them.
+                    const menuNamed = turnRoute?.offered !== undefined && menuOutstanding(turnRoute, currentSkillId)
+                        ? spoken(turnRoute.offered, mayName)
+                        : undefined;
+                    bindings.outcome.result = composeReadSkillRefusal({
+                        requestedId: reqId,
+                        targetClass,
+                        ...cursorSpoken,
+                        // No hop is named under a posture, and the graph's hop set
+                        // is not this arm's subject — `held: false` is the honest
+                        // shape, not a claim that nothing was reachable (this arm
+                        // never composes the reachability clause at all).
+                        hops: { named: [], held: false },
+                        openIds: openSpoken,
+                        posture: deps.skillStrictness,
+                        ...(menuNamed !== undefined && { menuOffered: menuNamed }),
+                        // The whole verdict, not a boolean derived from two of its
+                        // six values: the composer says one past fact per value.
+                        ...(turnRoute !== undefined && { turnStartedBy: turnRoute.by }),
+                    });
+                    typedEmit(scope, 'agentfootprint.skill.rejected', {
+                        requestedId: reqId,
+                        ...(currentSkillId !== undefined && { currentSkillId }),
+                        allowed,
+                        iteration: bindings.iteration,
+                        posture: deps.skillStrictness,
+                        reason: 'posture',
+                    });
+                    bindings.noteSkillRefusal(scope, bindings.iteration);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=readSkillRoute.js.map

package/dist/esm/core/agent/stages/toolCalls/routing/readSkillRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readSkillRoute.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/routing/readSkillRoute.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/stages/toolCalls/routing/skillActivation.d.ts

@@ -0,0 +1,15 @@
+import type { CallResultCell, CallExecution, CallSkillRoute, CallArguments } from '../contracts/callCells.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+interface ActivateLandedSkillFrame {
+    readonly tc: DispatchCall;
+    readonly outcome: CallResultCell;
+    readonly execution: CallExecution;
+    readonly skillRoute: CallSkillRoute;
+    readonly callArguments: CallArguments;
+}
+/** The existing synchronous skillActivation phase; no new await or checkpoint carrier. */
+export declare function activateLandedSkill(scope: TypedScope<AgentState>, deps: Pick<ToolCallsHandlerDeps, 'allowedSkillIds' | 'engagementPlan'>, frame: ActivateLandedSkillFrame): void;
+export {};

package/dist/esm/core/agent/stages/toolCalls/routing/skillActivation.js

@@ -0,0 +1,48 @@
+/** The existing synchronous skillActivation phase; no new await or checkpoint carrier. */
+export function activateLandedSkill(scope, deps, frame) {
+    // (2) `read_skill` is the auto-attached activation tool.
+    //     When the LLM calls it with a valid Skill id, append
+    //     to `activatedInjectionIds` so the InjectionEngine's
+    //     NEXT pass activates that Skill (lifetime: turn — stays
+    //     active until the turn ends).
+    if (frame.tc.name === 'read_skill' &&
+        !frame.outcome.error &&
+        !frame.execution.denied &&
+        !frame.skillRoute.skillRejected) {
+        const requestedId = frame.callArguments.callArgs.id;
+        if (typeof requestedId === 'string' && requestedId.length > 0) {
+            const current = scope.activatedInjectionIds;
+            if (!current.includes(requestedId)) {
+                scope.activatedInjectionIds = [...current, requestedId];
+            }
+            // (3) The same call is also a MOVE through the graph. `read_skill`
+            //     answers "activated for the next iteration", and for a skill
+            //     whose activation is cursor-gated (a route target, an exclusive
+            //     entry) or rule-gated (an intent entry whose rule didn't match)
+            //     appending the id alone never made that true — the sentence was
+            //     a promise the engine didn't keep. Record the pick the gate just
+            //     accepted; the Injection Engine hands it to `graph.nextSkill`,
+            //     which moves the cursor unless a declared edge fired first.
+            //     Last accepted pick of a parallel batch wins the cursor; all of
+            //     them still land in `activatedInjectionIds`.
+            //
+            //     Only a HOP moves the cursor. An OPEN skill (one the graph never
+            //     wires) is not a node, so parking the cursor on it would strand
+            //     the graph: every route trigger reads `nextSkill(ctx) === id`, and
+            //     from a non-node nothing can fire. It activates through its own
+            //     `llm-activated` trigger and the graph stays exactly where it was.
+            if (deps.allowedSkillIds && frame.skillRoute.skillHop)
+                scope.pendingSkillPick = requestedId;
+            // The kernel's per-pass feed: every pick the gate accepted, hop
+            // or not. A re-engagement is here and NOT in `pendingSkillPick`,
+            // which is the whole point — it changes engagement, not position.
+            if (deps.engagementPlan) {
+                const picks = scope.acceptedSkillPicks ?? [];
+                if (!picks.includes(requestedId)) {
+                    scope.acceptedSkillPicks = [...picks, requestedId];
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=skillActivation.js.map

package/dist/esm/core/agent/stages/toolCalls/routing/skillActivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillActivation.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/routing/skillActivation.ts"],"names":[],"mappings":"AAmBA,0FAA0F;AAC1F,MAAM,UAAU,mBAAmB,CACjC,KAA6B,EAC7B,IAAsE,EACtE,KAA+B;IAE/B,yDAAyD;IACzD,0DAA0D;IAC1D,0DAA0D;IAC1D,6DAA6D;IAC7D,mCAAmC;IACnC,IACE,KAAK,CAAC,EAAE,CAAC,IAAI,KAAK,YAAY;QAC9B,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK;QACpB,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM;QACvB,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,EAC/B,CAAC;QACD,MAAM,WAAW,GAAI,KAAK,CAAC,aAAa,CAAC,QAA6B,CAAC,EAAE,CAAC;QAC1E,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9D,MAAM,OAAO,GAAG,KAAK,CAAC,qBAA0C,CAAC;YACjE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnC,KAAK,CAAC,qBAAqB,GAAG,CAAC,GAAG,OAAO,EAAE,WAAW,CAAC,CAAC;YAC1D,CAAC;YACD,mEAAmE;YACnE,kEAAkE;YAClE,qEAAqE;YACrE,qEAAqE;YACrE,qEAAqE;YACrE,sEAAsE;YACtE,oEAAoE;YACpE,iEAAiE;YACjE,qEAAqE;YACrE,kDAAkD;YAClD,EAAE;YACF,sEAAsE;YACtE,qEAAqE;YACrE,wEAAwE;YACxE,qEAAqE;YACrE,wEAAwE;YACxE,IAAI,IAAI,CAAC,eAAe,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ;gBAAE,KAAK,CAAC,gBAAgB,GAAG,WAAW,CAAC;YAC5F,gEAAgE;YAChE,iEAAiE;YACjE,kEAAkE;YAClE,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,GAAI,KAAK,CAAC,kBAAoD,IAAI,EAAE,CAAC;gBAChF,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;oBACjC,KAAK,CAAC,kBAAkB,GAAG,CAAC,GAAG,KAAK,EAAE,WAAW,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/esm/core/agent/stages/toolCalls/routing/stepsOperations.d.ts

@@ -0,0 +1,4 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolStepsOperations } from '../contracts/operations/steps.js';
+/** Compose the existing steps callbacks once for this handler. */
+export declare function buildToolStepsOperations(deps: Pick<ToolCallsHandlerDeps, 'stepPlanFor' | 'escalation'>): ToolStepsOperations;

package/dist/esm/core/agent/stages/toolCalls/routing/stepsOperations.js

@@ -0,0 +1,145 @@
+import { pointerOf, stepInProgress, currentStepOf, skipNothingActiveSentence, skipNeedsReasonSentence, skipHoldSentence, skipAdvanceSentence, stepAdvanceSuffix, readSkillStepIntro, } from '../../../../../injection-engine/skillSteps.js';
+import { typedEmit } from '../../../../../recorders/core/typedEmit.js';
+/** Compose the existing steps callbacks once for this handler. */
+export function buildToolStepsOperations(deps) {
+    // ── Step-procedure boundary (9.18.0) — ONE implementation, five sites ──
+    // The batch loop and the four resume paths all finalize results; each
+    // calls these where its result becomes final, so a pointer can never miss
+    // a move because of which door the result came through (the resume-path
+    // law: the checkpoint carries the pointer for free in sharedState, and
+    // the answered call advances it HERE on resume).
+    /** The in-progress procedure, when there is one: pointer + plan + the
+     *  current step. Undefined on every agent without steps, between tenures,
+     *  and once a procedure completed. */
+    const stepStateOf = (scope) => {
+        if (!deps.stepPlanFor)
+            return undefined;
+        // A VALUE, not a handle: `scope.stepPointer[0]` is a proxy that reads
+        // live by path (footprintjs 9.22.0), so after `scope.stepPointer = [next]`
+        // below it would already answer with `next` — and the event that names
+        // the step just completed would name the one after it. `$getValue`
+        // hands back the committed/staged object itself, which never changes
+        // once the pointer is replaced (committed state is immutable-after-swap).
+        const ptr = pointerOf(scope.$getValue('stepPointer'));
+        if (!stepInProgress(ptr))
+            return undefined;
+        const plan = deps.stepPlanFor(ptr.skillId);
+        if (!plan)
+            return undefined;
+        const step = currentStepOf(ptr, plan);
+        return step ? { ptr, plan, step } : undefined;
+    };
+    // LENS · tool-result · persistent-history
+    // reads: the advanced pointer ← pointerOf(scope.stepPointer), under `toolCalls/routing/stepsOperations.ts` · "── Step-procedure boundary (9.18.0)"; the sentence ← ../../injection-engine/skillSteps.ts
+    // note: it overwrites the placeholder BEFORE the after-tool moment, so the record carries the authoritative words.
+    // law: may omit, never deny; every clause anchored to the call it was composed on.
+    /**
+     * `skip_step` bookkeeping — returns the AUTHORITATIVE result that
+     * replaces the tool's placeholder (both channels, the read_skill-refusal
+     * precedent). Emits `step_skipped` and moves/holds the pointer per the
+     * declared policy; a teaching answer (no active procedure / empty
+     * reason) emits nothing.
+     */
+    const applySkipStep = (scope, call) => {
+        const state = stepStateOf(scope);
+        if (!state)
+            return skipNothingActiveSentence();
+        const raw = call.args.reason;
+        const reason = typeof raw === 'string' ? raw.trim() : '';
+        if (reason.length === 0)
+            return skipNeedsReasonSentence();
+        const { ptr, plan, step } = state;
+        typedEmit(scope, 'agentfootprint.skill.step_skipped', {
+            skillId: ptr.skillId,
+            step: { index: ptr.step, total: ptr.total, tool: step.tool, note: step.note },
+            reason,
+            policy: plan.onSkip,
+            iteration: call.iteration,
+            toolCallId: call.toolCallId,
+        });
+        // 'hold': recorded and held — the step stays the offer; repeated skips
+        // of a held step are each recorded, because each is a fact.
+        if (plan.onSkip === 'hold')
+            return skipHoldSentence(ptr, reason, plan);
+        const next = {
+            skillId: ptr.skillId,
+            step: ptr.step + 1,
+            total: ptr.total,
+            skipped: [...ptr.skipped, ptr.step],
+        };
+        scope.stepPointer = [next];
+        return skipAdvanceSentence(ptr.step, reason, next, plan);
+    };
+    /**
+     * Advance-on-return — the caller has just finalized a NON-error,
+     * NON-denied, NON-refused result for `toolName`. When that call is the
+     * current step's tool: pointer + 1, `step_advanced` (with `completed` on
+     * the last), and the returned suffix joins the model-visible result
+     * BEFORE the history push. Empty string otherwise. Eligibility (ran,
+     * not denied/rejected/errored) is judged by the CALLING site, because
+     * each dispatch path knows its own truth about that.
+     */
+    const applyStepReturn = (scope, call) => {
+        const state = stepStateOf(scope);
+        if (!state || state.step.tool !== call.toolName)
+            return '';
+        const { ptr, plan, step } = state;
+        const next = {
+            skillId: ptr.skillId,
+            step: ptr.step + 1,
+            total: ptr.total,
+            skipped: [...ptr.skipped],
+        };
+        scope.stepPointer = [next];
+        const completed = next.step > next.total;
+        typedEmit(scope, 'agentfootprint.skill.step_advanced', {
+            skillId: ptr.skillId,
+            step: { index: ptr.step, total: ptr.total, tool: step.tool, note: step.note },
+            iteration: call.iteration,
+            toolCallId: call.toolCallId,
+            ...(completed && { completed: true }),
+        });
+        return stepAdvanceSuffix(next, plan);
+    };
+    /** The `read_skill` activation intro for a STEPPED skill — where its
+     *  procedure starts. Rides the same "activated for the next iteration"
+     *  promise the read_skill result already makes (a same-batch declared
+     *  edge that outruns the pick reports itself via `reroute_superseded`,
+     *  exactly as it does for the activation sentence). */
+    const readSkillStepIntroFor = (pickedId) => {
+        const plan = deps.stepPlanFor?.(pickedId);
+        return plan ? readSkillStepIntro(plan) : '';
+    };
+    // ── Escalate-on-evidence (9.19.0) — the refusal budget ─────────────────
+    // Called beside ALL THREE `skill.rejected` emit sites — self-call,
+    // reachability and posture: real recorded refusals are the only evidence that
+    // counts. The self-call site is deliberate and worth stating, because the
+    // sentence it composes is NOT a refusal to the model (see `selfCallNotice`):
+    // what the budget measures is not how a message reads, it is a model that
+    // keeps asking the graph where it is instead of working — the stuck run this
+    // budget exists to escalate. Both facts hold at once, and neither comment
+    // gets to imply the other away. At the
+    // declared threshold the flip is committed (`skillEscalated` — the fact
+    // callLLM's brainFor reads) and `skill.escalated` fires ONCE; the counter
+    // keeps counting so the record shows the whole loop. Gated on the policy
+    // being declared — otherwise not one key is read or written.
+    const noteSkillRefusal = (scope, iteration) => {
+        const escalation = deps.escalation;
+        if (!escalation)
+            return;
+        const refusals = (scope.skillRefusalsThisTurn ?? 0) + 1;
+        scope.skillRefusalsThisTurn = refusals;
+        if (refusals >= escalation.afterRefusals && scope.skillEscalated !== true) {
+            scope.skillEscalated = true;
+            typedEmit(scope, 'agentfootprint.skill.escalated', {
+                iteration,
+                afterRefusals: escalation.afterRefusals,
+                refusals,
+                from: escalation.describeFrom(scope.currentSkillId, scope.resolvedModel),
+                to: escalation.to,
+            });
+        }
+    };
+    return { stepStateOf, applySkipStep, applyStepReturn, readSkillStepIntroFor, noteSkillRefusal };
+}
+//# sourceMappingURL=stepsOperations.js.map

package/dist/esm/core/agent/stages/toolCalls/routing/stepsOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepsOperations.js","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/routing/stepsOperations.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/agent/stages/toolResolver.d.ts

@@ -7,7 +7,7 @@
  *          reference holders it is handed — the tools slot's per-epoch records
  *          (`servedTools`, `providerToolCache`) are shared by REFERENCE, so a
  *          resolver built once answers for the current epoch whenever it runs.
- * Role:    core/agent. Two readers: `stages/toolCalls.ts` (dispatch, and the
+ * Role:    core/agent. Two readers: `stages/toolCalls/execution/catalogOperations.ts` (dispatch, and the
  *          four resume doors) and the inputs layer (`honesty/mounts.ts`), which
  *          reads a call's argument rules off the implementation that WILL run
  *          — never off a re-derivation that could name a different party.
@@ -26,7 +26,8 @@
  *      was never shown under that name.
  */
 import type { ToolProvider } from '../../../tools/toolProvider.js';
-import type { ProviderToolCache, ServedToolParties, ToolParty } from '../../slots/buildToolsSlot.js';
+import type { ProviderToolCache, ServedToolParties } from '../../slots/buildToolsSlot.js';
+import { type ToolParty } from '../../../tools/toolParty.js';
 import type { Tool } from '../../../tools/tools.js';
 import type { ToolClaim } from '../buildToolRegistry.js';
 /** One name, resolved. */