agentfootprint 13.0.0 → 14.0.0

package/dist/esm/injection-engine/skillExamples.d.ts

@@ -122,7 +122,7 @@ export declare const EXAMPLES_ORDER_NOT_CHECKED: string;
 /**
  * The slice of an entry declaration this module reads — the shared claim shape
  * ({@link StartRuleDecl}, which owns "who claims a phrase") plus the one field
- * only this check reads. Structural, so `skillGraph.ts`'s module-private
+ * only this check reads. Structural, so `skillGraph/graphRoutes.ts`'s internal
  * `EntryDecl` satisfies it unchanged (the same trick `skillIntent.ts` uses).
  */
 export interface ExampleRuleDecl extends StartRuleDecl {

package/dist/esm/injection-engine/skillGraph/cursorEvidence.d.ts

@@ -0,0 +1,48 @@
+import type { EntryDecl } from './graphRoutes.js';
+import type { InjectionContext } from '../types.js';
+import type { RouteWitness } from '../skillMatch.js';
+/**
+ * The cursor resolver (the keystone). Pure + deterministic. Given the iteration
+ * context, returns the skill the graph should be *in* after this iteration AND the
+ * clause that decided it (`CursorMove`; `nextSkill` is the `.to` projection):
+ *   • cold start (`currentSkillId` unset) → first `entry` whose `when` passes
+ *     (an `always`-entry — no `when` — matches unconditionally), else the entry
+ *     the MODEL picked with `read_skill` (see "the model's pick" below);
+ *   • a `from`-gated route (`fromId === currentSkillId`) whose predicate matches
+ *     a result of the iteration's tool batch — results in call order, edges per
+ *     result in declaration order; the first result with a match wins, later
+ *     results matching OTHER targets are reported as `conflict` (9.16.0) →
+ *     its target (the transition);
+ *   • else the model's pick, when the read_skill gate accepted one this turn;
+ *   • otherwise the current cursor unchanged (sticky stay).
+ *
+ * **The model's pick (`ctx.pendingSkillPick`) — the D2 "validated volunteer".**
+ * `read_skill(id)` is already GATED to `reachableSkills(cursor)` (the model may
+ * only name a skill the graph declares as reachable from where it stands), and
+ * the tool answers "Skill 'id' activated for the next iteration." Until 8.3.0 the
+ * cursor ignored that answer for every form except `.entryByRead()`'s cold start,
+ * so the sentence was false wherever the skill's activation was cursor-gated or
+ * rule-gated. It is honoured here, at ONE place, with the precedence the design
+ * pinned (docs/design/skill-graph.md §4A.1): a declared edge that fired this hop
+ * WINS over a same-turn pick (`D1 > D2`) — the author's determinism is never
+ * overridden by a model guess. The pick is one-shot (the tool-calls stage rewrites
+ * it every iteration), so a pick can never drag the cursor backwards after a later
+ * edge has moved it.
+ *
+ * Each candidate predicate runs in its OWN try/catch so one throwing edge can't
+ * block its siblings or crash the loop — a throw is treated as "no match" and,
+ * in dev mode, warned. This is the design's `routeForResult` pin-table target.
+ *
+ * The `by` on each return is decided at the same statement as the destination
+ * (8.5.0). That matters most in the case an outside observer cannot reconstruct:
+ * a declared edge and a same-turn model pick naming the SAME target. `D1 > D2`
+ * makes it a `'route'`, and only this function knows.
+ */
+/** The winning entry's recorded evidence, as a spreadable fragment: `{ witness }`
+ *  when the rule was DATA and it yielded quotable text, `{}` otherwise (a `when`
+ *  predicate, an unconditional entry, a match with nothing quotable). A throwing
+ *  extractor is treated exactly as no evidence — a record is never worth a crash,
+ *  and the hop itself already happened. */
+export declare function witnessOf(entry: EntryDecl, ctx: InjectionContext): {
+    witness?: RouteWitness;
+};

package/dist/esm/injection-engine/skillGraph/cursorEvidence.js

@@ -0,0 +1,54 @@
+/**
+ * The cursor resolver (the keystone). Pure + deterministic. Given the iteration
+ * context, returns the skill the graph should be *in* after this iteration AND the
+ * clause that decided it (`CursorMove`; `nextSkill` is the `.to` projection):
+ *   • cold start (`currentSkillId` unset) → first `entry` whose `when` passes
+ *     (an `always`-entry — no `when` — matches unconditionally), else the entry
+ *     the MODEL picked with `read_skill` (see "the model's pick" below);
+ *   • a `from`-gated route (`fromId === currentSkillId`) whose predicate matches
+ *     a result of the iteration's tool batch — results in call order, edges per
+ *     result in declaration order; the first result with a match wins, later
+ *     results matching OTHER targets are reported as `conflict` (9.16.0) →
+ *     its target (the transition);
+ *   • else the model's pick, when the read_skill gate accepted one this turn;
+ *   • otherwise the current cursor unchanged (sticky stay).
+ *
+ * **The model's pick (`ctx.pendingSkillPick`) — the D2 "validated volunteer".**
+ * `read_skill(id)` is already GATED to `reachableSkills(cursor)` (the model may
+ * only name a skill the graph declares as reachable from where it stands), and
+ * the tool answers "Skill 'id' activated for the next iteration." Until 8.3.0 the
+ * cursor ignored that answer for every form except `.entryByRead()`'s cold start,
+ * so the sentence was false wherever the skill's activation was cursor-gated or
+ * rule-gated. It is honoured here, at ONE place, with the precedence the design
+ * pinned (docs/design/skill-graph.md §4A.1): a declared edge that fired this hop
+ * WINS over a same-turn pick (`D1 > D2`) — the author's determinism is never
+ * overridden by a model guess. The pick is one-shot (the tool-calls stage rewrites
+ * it every iteration), so a pick can never drag the cursor backwards after a later
+ * edge has moved it.
+ *
+ * Each candidate predicate runs in its OWN try/catch so one throwing edge can't
+ * block its siblings or crash the loop — a throw is treated as "no match" and,
+ * in dev mode, warned. This is the design's `routeForResult` pin-table target.
+ *
+ * The `by` on each return is decided at the same statement as the destination
+ * (8.5.0). That matters most in the case an outside observer cannot reconstruct:
+ * a declared edge and a same-turn model pick naming the SAME target. `D1 > D2`
+ * makes it a `'route'`, and only this function knows.
+ */
+/** The winning entry's recorded evidence, as a spreadable fragment: `{ witness }`
+ *  when the rule was DATA and it yielded quotable text, `{}` otherwise (a `when`
+ *  predicate, an unconditional entry, a match with nothing quotable). A throwing
+ *  extractor is treated exactly as no evidence — a record is never worth a crash,
+ *  and the hop itself already happened. */
+export function witnessOf(entry, ctx) {
+    if (!entry.witness)
+        return {};
+    try {
+        const found = entry.witness(ctx);
+        return found === undefined ? {} : { witness: found };
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=cursorEvidence.js.map

package/dist/esm/injection-engine/skillGraph/cursorEvidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursorEvidence.js","sourceRoot":"","sources":["../../../../src/injection-engine/skillGraph/cursorEvidence.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;;;;2CAI2C;AAC3C,MAAM,UAAU,SAAS,CAAC,KAAgB,EAAE,GAAqB;IAC/D,IAAI,CAAC,KAAK,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IAC9B,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACjC,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/esm/injection-engine/skillGraph/cursorResolution.d.ts

@@ -0,0 +1,4 @@
+import type { EntryDecl, RouteDecl } from './graphRoutes.js';
+import type { InjectionContext } from '../types.js';
+import type { CursorMove } from './graphCursor.js';
+export declare function makeResolveCursor(entries: readonly EntryDecl[], routes: readonly RouteDecl[], llmReadEntry?: boolean): (ctx: InjectionContext) => CursorMove;

package/dist/esm/injection-engine/skillGraph/cursorResolution.js

@@ -0,0 +1,241 @@
+import { isHiddenSkill, toolResultsOf } from '../types.js';
+import { witnessOf } from './cursorEvidence.js';
+import { warnMatcherThrew } from './passMemo.js';
+import { isDeterministicRoute, edgePreconditionsPass, routeMatches } from './routePredicates.js';
+// FOLD · the one owner of where the cursor goes next, and which clause decided it (CursorMove)
+// consumers read this and never re-derive it: the `nextSkill` and `explainNextSkill` hooks the Evaluate stage asks;
+// the memoized `nextSkillForTriggers` that `deriveTrigger` reads; and `makeSupersededEntries`.
+// NOT skillToolDescriptors: the read_skill description reads the ALREADY-RESOLVED cursor off the offer (offer.cursorId).
+// detached: yes — a POJO plus a string id, memoized per pass so two readers get one decided value.
+export function makeResolveCursor(entries, routes, llmReadEntry = false) {
+    const isEntry = (id) => entries.some((e) => e.id === id);
+    return (ctx) => {
+        // ROLE VISIBILITY. The cursor never moves onto a skill this caller's role
+        // may not read (`isHiddenSkill`, the same rule the evaluator refuses
+        // activation by), so the stored cursor and the active set cannot
+        // disagree. Every clause below asks `may` before it names a destination:
+        // a keyword in the message, a declared edge, a tool proposal and a pick
+        // are all untrusted routes to the same place. A cursor already standing
+        // on a hidden skill (a restored conversation, a grant revoked mid-run) is
+        // treated as no cursor, so the turn re-enters through the visible entries.
+        const may = (id) => !isHiddenSkill(ctx, id);
+        const cur = ctx.currentSkillId !== undefined && may(ctx.currentSkillId) ? ctx.currentSkillId : undefined;
+        const from = cur !== undefined ? { from: cur } : {};
+        // The turn-start cascade's verdict (SG-C) — a PRECOMPUTED input consumed
+        // exactly as `pendingSkillPick` is, on iteration 1 only (the RouteTurn
+        // stage decided it off the hot loop; `userMessage` is fixed for the run,
+        // so iterations 2..N keep today's law byte-for-byte). Present only on
+        // cascade graphs (`classify` / `continuity: 'conversation'`); absent, not
+        // one line here behaves differently. A `menu`/`none` verdict carries no
+        // `to` and falls through — the model resolves the menu via the ordinary
+        // gated pick (D2), which is what keeps the offer and the verdict one
+        // machinery; the cold-start walk below is suppressed by the verdict's
+        // PRESENCE, so falling through can never enter an entry the record does
+        // not claim.
+        if (ctx.iteration === 1 && ctx.turnRoute?.to !== undefined && may(ctx.turnRoute.to)) {
+            const by = ctx.turnRoute.by === 'intent'
+                ? 'intent'
+                : ctx.turnRoute.by === 'continuity'
+                    ? 'continuity'
+                    : ctx.turnRoute.by === 'decider'
+                        ? 'decider'
+                        : 'entry';
+            return {
+                ...(ctx.turnRoute.from !== undefined && { from: ctx.turnRoute.from }),
+                to: ctx.turnRoute.to,
+                by,
+                // The cascade already extracted the tier-1 evidence (`turn_routed`
+                // carries it); the hop repeats it rather than re-deriving it, so the
+                // two records can never quote different text.
+                ...(ctx.turnRoute.witness !== undefined && { witness: ctx.turnRoute.witness }),
+            };
+        }
+        if (cur === undefined) {
+            // Cold start: declaration-order first entry whose intent predicate passes.
+            // `.entryByRead()` skips this — there the library deliberately does NOT
+            // auto-pick; the model reads the menu and picks (below), so no entry body
+            // loads until it does. A turn whose cascade left a VERDICT on scope
+            // (`ctx.turnRoute`, SG-C) skips it the same way: suppression follows the
+            // verdict, not only the compile-time flag, because an entry-scorer graph
+            // opts into the cascade at MOUNT time (`continuity: 'conversation'`) —
+            // it compiles with `llmReadEntry` false, yet its cold `menu`/`none`
+            // verdict (a near-tie, or the scorer-throw fallback) must reach the
+            // model, never be overridden by the declaration-order walk while the
+            // record claims a menu is outstanding. RouteTurn writes the POJO only
+            // when the cascade DECIDED something, so a graph whose cold start still
+            // belongs to this walk (no rules, no tier 2 — e.g. after a dropped
+            // resume) keeps it.
+            if (!llmReadEntry && ctx.turnRoute === undefined) {
+                for (const e of entries) {
+                    if (!may(e.id))
+                        continue;
+                    if (!e.when)
+                        return { to: e.id, by: 'entry' };
+                    try {
+                        // The witness is extracted HERE, on the winner only — the losing
+                        // rules never pay for evidence, and an unconditional/`when` entry
+                        // has none to give (`witnessOf` answers undefined).
+                        if (e.when(ctx))
+                            return { to: e.id, by: 'entry', ...witnessOf(e, ctx) };
+                    }
+                    catch (err) {
+                        warnMatcherThrew(`entry "${e.id}"`, err);
+                    }
+                }
+            }
+            // A cold ACCEPTED tool proposal enters exactly where a cold model pick
+            // may (an entry — the reachable-from-cold set), and OUTRANKS the pick:
+            // deterministic tool evidence over a model guess, the same order the
+            // mid-run walk applies below (9.19.0).
+            const coldProposal = ctx.pendingToolTransition?.targetSkillId;
+            if (coldProposal !== undefined && isEntry(coldProposal) && may(coldProposal)) {
+                return { to: coldProposal, by: 'tool-proposal' };
+            }
+            // The model's pick becomes the starting cursor. This is what `.entryByRead()`
+            // has always done; 8.3.0 makes it true for EVERY start form, which is what
+            // makes the rules form's documented fallback ("no rule matched → the model
+            // picks from the read_skill menu") actually work. An entry's `when` is the
+            // AUTOMATIC pick's condition, not a lock on the manual one: the model asked
+            // for this skill by name and the gate allowed it.
+            if (ctx.pendingSkillPick !== undefined &&
+                isEntry(ctx.pendingSkillPick) &&
+                may(ctx.pendingSkillPick)) {
+                return { to: ctx.pendingSkillPick, by: 'model-pick' };
+            }
+            for (const e of entries) {
+                if (may(e.id) && ctx.activatedInjectionIds.includes(e.id)) {
+                    return { to: e.id, by: 'model-pick' };
+                }
+            }
+            return { by: 'none' };
+        }
+        // D1 — transition: the whole tool batch, in CALL order (9.16.0). Per
+        // result, the first from-gated deterministic edge in DECLARATION order
+        // that fires names that result's target; the first RESULT with a target
+        // wins the cursor. Two orders, two jobs: declaration order is the
+        // author's tiebreak when one result could match several edges (the D1
+        // law, unchanged), call order is the run's tiebreak across results —
+        // the tool that returned first routed first. Before 9.16.0 only the
+        // LAST call of a batch was consulted, so identical batches routed
+        // differently depending on call order (the 9.15.0 L1 probe). A later
+        // result matching a DIFFERENT target is suppressed AND reported on the
+        // move (`conflict`), never silently dropped; a batch of one is
+        // byte-identical to the old singular walk. D1 still wins over a
+        // same-turn model pick — INCLUDING when both name the same target,
+        // which is why the cause is decided here and not inferred downstream
+        // from the destination.
+        let winner;
+        let losers;
+        // Guard evidence (9.51.0), collected at the very statements that decide:
+        // the winning edge's evaluation (verdict true) and — per guarded edge —
+        // the FIRST refusal whose preconditions a result met (verdict false).
+        // A guarded edge whose tool/status preconditions never matched leaves no
+        // record: its guard never decided anything.
+        let winnerGuard;
+        let guardsClosed;
+        let closedEdges;
+        for (const res of toolResultsOf(ctx)) {
+            let target;
+            let targetGuard;
+            for (const r of routes) {
+                if (r.fromId !== cur)
+                    continue;
+                if (!isDeterministicRoute(r))
+                    continue; // model edges don't auto-fire
+                if (!may(r.toId))
+                    continue; // an edge into a hidden skill never fires
+                try {
+                    if (r.guard !== undefined) {
+                        // The guard is judged AFTER the edge's own tool/status
+                        // preconditions, over the hop view (the six hop keys + the
+                        // result's JSON fields — see skillGuard.ts). `evaluate` and the
+                        // routing predicate are one compilation, so the recorded
+                        // conditions ARE the ones that routed.
+                        if (!edgePreconditionsPass(r, res))
+                            continue;
+                        const evaluation = r.guard.evaluate({
+                            toolName: res.toolName,
+                            result: res.result,
+                            ...(res.status !== undefined && { status: res.status }),
+                            iteration: ctx.iteration,
+                            userMessage: ctx.userMessage,
+                            currentSkillId: cur,
+                        });
+                        const record = {
+                            from: r.fromId,
+                            to: r.toId,
+                            toolName: res.toolName,
+                            ...(res.toolCallId !== undefined && { toolCallId: res.toolCallId }),
+                            verdict: evaluation.verdict,
+                            conditions: evaluation.conditions,
+                        };
+                        if (evaluation.verdict) {
+                            target = r.toId;
+                            targetGuard = record;
+                            break;
+                        }
+                        if (!(closedEdges ??= new Set()).has(r)) {
+                            closedEdges.add(r);
+                            (guardsClosed ??= []).push(record);
+                        }
+                        continue;
+                    }
+                    if (routeMatches(r, res)) {
+                        target = r.toId;
+                        break;
+                    }
+                }
+                catch (err) {
+                    warnMatcherThrew(`route ${r.fromId}→${r.toId}`, err);
+                }
+            }
+            if (target === undefined)
+                continue;
+            const outcome = {
+                ...(res.toolCallId !== undefined && { toolCallId: res.toolCallId }),
+                toolName: res.toolName,
+                target,
+            };
+            if (winner === undefined) {
+                winner = outcome;
+                winnerGuard = targetGuard;
+            }
+            else if (target !== winner.target)
+                (losers ??= []).push(outcome);
+        }
+        // The refusals ride WHATEVER move resulted — a closed guard explains a
+        // stay (or the hop that won instead) the same way `supersededEntries`
+        // explains a suppressed entry.
+        const closed = guardsClosed !== undefined ? { guardsClosed } : {};
+        if (winner !== undefined) {
+            return {
+                ...from,
+                to: winner.target,
+                by: 'route',
+                ...(winnerGuard !== undefined && { guard: winnerGuard }),
+                ...closed,
+                ...(losers !== undefined && { conflict: { winner, losers } }),
+            };
+        }
+        // D1.5 — the ACCEPTED tool proposal (9.19.0): no declared edge fired, so
+        // a `propose-transition` effect the gate validated moves the cursor. It
+        // sits BETWEEN the edges and the pick on purpose: a declared edge is the
+        // author's determinism (never overridden), a proposal is the tool
+        // author's determinism (code that shipped), a pick is the model's guess.
+        // A proposal of the CURRENT skill is a no-op stay, not a hop.
+        const proposal = ctx.pendingToolTransition?.targetSkillId;
+        if (proposal !== undefined && proposal !== cur && may(proposal)) {
+            return { ...from, to: proposal, by: 'tool-proposal', ...closed };
+        }
+        // D2 — the validated volunteer: no declared edge fired, so the model's own
+        // (already gated) pick moves the cursor. A pick of the CURRENT skill is a
+        // no-op stay, not a hop.
+        if (ctx.pendingSkillPick !== undefined &&
+            ctx.pendingSkillPick !== cur &&
+            may(ctx.pendingSkillPick)) {
+            return { ...from, to: ctx.pendingSkillPick, by: 'model-pick', ...closed };
+        }
+        return { ...from, to: cur, by: 'stay', ...closed }; // sticky stay — no edge out of cur fired
+    };
+}
+//# sourceMappingURL=cursorResolution.js.map

package/dist/esm/injection-engine/skillGraph/cursorResolution.js.map

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

package/dist/esm/injection-engine/skillGraph/decision.d.ts

@@ -0,0 +1,21 @@
+import type { InjectionContext, Injection } from '../types.js';
+/**
+ * A decision-tree node (v3): a predicate that branches to a subtree (or a skill
+ * LEAF) on each side. The tree compiles to per-skill triggers — each leaf's
+ * trigger is the conjunction of the predicates on its root→leaf path (with
+ * earlier-sibling negation for if/else exclusivity), evaluated per iteration. So
+ * "predicate nodes that route" needs NO engine change — same evaluator.
+ */
+export interface DecisionNode {
+    readonly kind: 'decision';
+    readonly predicate: (ctx: InjectionContext) => boolean;
+    readonly whenTrue: DecisionNode | Injection;
+    readonly whenFalse: DecisionNode | Injection;
+    /** Caption for the predicate node when drawn (e.g. "io intent?"). */
+    readonly label?: string;
+}
+/** Build a decision node. Leaves are skills (an `Injection`); internal nodes are
+ *  other `decideSkill(...)` results. (Renamed from `decide` in v7 to avoid
+ *  colliding with footprintjs's `decide()`.) */
+export declare function decideSkill(predicate: (ctx: InjectionContext) => boolean, whenTrue: DecisionNode | Injection, whenFalse: DecisionNode | Injection, label?: string): DecisionNode;
+export declare function isDecisionNode(n: DecisionNode | Injection): n is DecisionNode;

package/dist/esm/injection-engine/skillGraph/decision.js

@@ -0,0 +1,10 @@
+/** Build a decision node. Leaves are skills (an `Injection`); internal nodes are
+ *  other `decideSkill(...)` results. (Renamed from `decide` in v7 to avoid
+ *  colliding with footprintjs's `decide()`.) */
+export function decideSkill(predicate, whenTrue, whenFalse, label) {
+    return { kind: 'decision', predicate, whenTrue, whenFalse, label };
+}
+export function isDecisionNode(n) {
+    return n.kind === 'decision';
+}
+//# sourceMappingURL=decision.js.map

package/dist/esm/injection-engine/skillGraph/decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.js","sourceRoot":"","sources":["../../../../src/injection-engine/skillGraph/decision.ts"],"names":[],"mappings":"AAkBA;;gDAEgD;AAChD,MAAM,UAAU,WAAW,CACzB,SAA6C,EAC7C,QAAkC,EAClC,SAAmC,EACnC,KAAc;IAEd,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,CAA2B;IACxD,OAAQ,CAAkB,CAAC,IAAI,KAAK,UAAU,CAAC;AACjD,CAAC"}

package/dist/esm/injection-engine/skillGraph/entryScores.d.ts

@@ -0,0 +1,14 @@
+import type { EntryDecl } from './graphRoutes.js';
+import type { Injection, InjectionContext } from '../types.js';
+import type { EntryScorer, EntryScoring } from '../entryScorer.js';
+/**
+ * Bind the chosen `EntryScorer` strategy into `graph.scoreEntries`. The engine owns
+ * the `when`-filtering (it needs `ctx` + the entry predicates); the scorer owns the
+ * ranking. Filters the entries to the `when`-passing candidates, hands the scorer
+ * `{ userMessage, candidates: { id, description } }`, and returns its `EntryScoring`.
+ * Async wrapper so a sync scorer (`keywordScorer`) and an async one (`embeddingScorer`)
+ * present identically; runs once per turn in the OFF-LOOP PickEntry stage, never in
+ * the sync route triggers, so `nextSkill` stays synchronous. An empty candidate set
+ * (or a throwing scorer, caught by PickEntry) falls back to the normal cold-start entry.
+ */
+export declare function makeScoreEntries(entries: readonly EntryDecl[], skillsById: ReadonlyMap<string, Injection>, scorer: EntryScorer): (ctx: InjectionContext, signal?: AbortSignal) => Promise<EntryScoring>;

package/dist/esm/injection-engine/skillGraph/entryScores.js

@@ -0,0 +1,30 @@
+import { warnMatcherThrew } from './passMemo.js';
+/**
+ * Bind the chosen `EntryScorer` strategy into `graph.scoreEntries`. The engine owns
+ * the `when`-filtering (it needs `ctx` + the entry predicates); the scorer owns the
+ * ranking. Filters the entries to the `when`-passing candidates, hands the scorer
+ * `{ userMessage, candidates: { id, description } }`, and returns its `EntryScoring`.
+ * Async wrapper so a sync scorer (`keywordScorer`) and an async one (`embeddingScorer`)
+ * present identically; runs once per turn in the OFF-LOOP PickEntry stage, never in
+ * the sync route triggers, so `nextSkill` stays synchronous. An empty candidate set
+ * (or a throwing scorer, caught by PickEntry) falls back to the normal cold-start entry.
+ */
+export function makeScoreEntries(entries, skillsById, scorer) {
+    return async (ctx, signal) => {
+        const candidates = entries
+            .filter((e) => {
+            if (!e.when)
+                return true;
+            try {
+                return e.when(ctx);
+            }
+            catch (err) {
+                warnMatcherThrew(`entry "${e.id}"`, err);
+                return false;
+            }
+        })
+            .map((e) => ({ id: e.id, description: skillsById.get(e.id)?.description ?? e.id }));
+        return scorer.score({ userMessage: ctx.userMessage, candidates }, signal);
+    };
+}
+//# sourceMappingURL=entryScores.js.map

package/dist/esm/injection-engine/skillGraph/entryScores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entryScores.js","sourceRoot":"","sources":["../../../../src/injection-engine/skillGraph/entryScores.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAA6B,EAC7B,UAA0C,EAC1C,MAAmB;IAEnB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;QAC3B,MAAM,UAAU,GAAG,OAAO;aACvB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;YACZ,IAAI,CAAC,CAAC,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YACzB,IAAI,CAAC;gBACH,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,gBAAgB,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;gBACzC,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACtF,OAAO,MAAM,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,CAAC;IAC5E,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/injection-engine/skillGraph/entrySuppression.d.ts

@@ -0,0 +1,23 @@
+import type { EntryDecl } from './graphRoutes.js';
+import type { InjectionContext } from '../types.js';
+import type { CursorMove } from './graphCursor.js';
+/**
+ * The suppression reporter (8.15.0) — the honesty half of the one law.
+ *
+ * A conditional entry is active exactly while the cursor is on it, so an entry whose
+ * own `when` matched while the graph is somewhere else is SUPPRESSED. Before 8.15.0
+ * it would have loaded beside the cursor's skill, which is precisely the double
+ * activation the law removes — so the run has to be able to SAY it happened, or an
+ * author debugging "why isn't my entry loading?" has nothing to read.
+ *
+ * Pure: one resolver pass plus, at most, one predicate call per OTHER conditional
+ * entry — O(E), inside the ceiling `memoizePerPass` sets for the whole evaluation.
+ * The RAW resolver (not the memoized projection) is used deliberately, matching the
+ * freshness policy of the other public resolvers: called once per iteration, always
+ * recomputed.
+ *
+ * A throwing predicate is swallowed HERE and reported by the evaluator instead
+ * (`skipped: 'predicate-threw'`) — one throw must not be told as two different
+ * stories on the same event.
+ */
+export declare function makeSupersededEntries(entries: readonly EntryDecl[], resolveCursor: (ctx: InjectionContext) => CursorMove): (ctx: InjectionContext) => readonly string[];

package/dist/esm/injection-engine/skillGraph/entrySuppression.js

@@ -0,0 +1,46 @@
+/**
+ * The suppression reporter (8.15.0) — the honesty half of the one law.
+ *
+ * A conditional entry is active exactly while the cursor is on it, so an entry whose
+ * own `when` matched while the graph is somewhere else is SUPPRESSED. Before 8.15.0
+ * it would have loaded beside the cursor's skill, which is precisely the double
+ * activation the law removes — so the run has to be able to SAY it happened, or an
+ * author debugging "why isn't my entry loading?" has nothing to read.
+ *
+ * Pure: one resolver pass plus, at most, one predicate call per OTHER conditional
+ * entry — O(E), inside the ceiling `memoizePerPass` sets for the whole evaluation.
+ * The RAW resolver (not the memoized projection) is used deliberately, matching the
+ * freshness policy of the other public resolvers: called once per iteration, always
+ * recomputed.
+ *
+ * A throwing predicate is swallowed HERE and reported by the evaluator instead
+ * (`skipped: 'predicate-threw'`) — one throw must not be told as two different
+ * stories on the same event.
+ */
+export function makeSupersededEntries(entries, resolveCursor) {
+    const conditional = entries.filter((e) => e.when !== undefined);
+    if (conditional.length === 0)
+        return () => [];
+    return (ctx) => {
+        const to = resolveCursor(ctx).to;
+        // No cursor at all → the trigger falls back to the rule alone, so nothing is
+        // being superseded.
+        if (to === undefined)
+            return [];
+        const out = [];
+        for (const e of conditional) {
+            if (e.id === to)
+                continue; // this is the one that won
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (e.when(ctx))
+                    out.push(e.id);
+            }
+            catch {
+                // Reported by the evaluator as `predicate-threw`, not as a suppression.
+            }
+        }
+        return out;
+    };
+}
+//# sourceMappingURL=entrySuppression.js.map

package/dist/esm/injection-engine/skillGraph/entrySuppression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrySuppression.js","sourceRoot":"","sources":["../../../../src/injection-engine/skillGraph/entrySuppression.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAA6B,EAC7B,aAAoD;IAEpD,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAChE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,EAAE,CAAC,EAAE,CAAC;IAC9C,OAAO,CAAC,GAAG,EAAE,EAAE;QACb,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QACjC,6EAA6E;QAC7E,oBAAoB;QACpB,IAAI,EAAE,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QAChC,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;YAC5B,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE;gBAAE,SAAS,CAAC,2BAA2B;YACtD,IAAI,CAAC;gBACH,oEAAoE;gBACpE,IAAI,CAAC,CAAC,IAAK,CAAC,GAAG,CAAC;oBAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACnC,CAAC;YAAC,MAAM,CAAC;gBACP,wEAAwE;YAC1E,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;AACJ,CAAC"}

package/dist/esm/injection-engine/skillGraph/graphConfig.d.ts

@@ -0,0 +1,39 @@
+import type { SkillStartRule, SkillRouteOptions } from './graphRoutes.js';
+import type { IntentScorer } from '../intentScorer.js';
+import type { RoutingPolicy } from '../routingPolicy.js';
+import type { EntryScorer } from '../entryScorer.js';
+import type { Embedder } from '../../memory/embedding/types.js';
+/** Where a turn starts, in the object-literal (flat) form. */
+export type SkillGraphStart = string | {
+    readonly use: string;
+} | {
+    readonly rules: ReadonlyArray<SkillStartRule>;
+    /** The intent classifier (SG-C) — REQUIRED iff any rule declares
+     *  `match: { intent }`. Same machine as `.classify(scorer)`. */
+    readonly classify?: IntentScorer;
+    /** Tie-policy override — the ONE override home, beside the scorer it
+     *  governs. Same machine as `.classify(scorer, policy)`. */
+    readonly routing?: Partial<RoutingPolicy>;
+} | {
+    readonly entries: readonly string[];
+    /** Rank the entries with a scorer strategy (`keywordScorer()`,
+     *  `embeddingScorer(e)`, or your own). Takes precedence over `byRelevance`. */
+    readonly scoredBy?: EntryScorer;
+    /** Sugar: rank the entries with an embedder (cosine/softmax). Omit both → the
+     *  LLM reads the menu and picks (`.entryByRead()`) — no model call. */
+    readonly byRelevance?: Embedder;
+};
+/** One tool-result transition in the object-literal (flat) form. */
+export interface SkillGraphStep {
+    readonly from: string;
+    readonly to: string;
+    readonly when?: SkillRouteOptions['when'];
+    readonly onToolReturn?: string | RegExp;
+    /** Route on the result's declared outcome status (9.19.0) — see
+     *  {@link SkillRouteOptions.onToolStatus}. */
+    readonly onToolStatus?: SkillRouteOptions['onToolStatus'];
+    /** The edge's condition as DATA (9.51.0) — see
+     *  {@link SkillRouteOptions.guard}. */
+    readonly guard?: SkillRouteOptions['guard'];
+    readonly label?: string;
+}

package/dist/esm/injection-engine/skillGraph/graphConfig.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graphConfig.js.map

package/dist/esm/injection-engine/skillGraph/graphConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphConfig.js","sourceRoot":"","sources":["../../../../src/injection-engine/skillGraph/graphConfig.ts"],"names":[],"mappings":""}