agentfootprint 10.3.0 → 10.4.0

package/dist/types/lib/injection-engine/buildInjectionEngineSubflow.d.ts

@@ -1,167 +0,0 @@
-/**
- * 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
- *       }),
- *     },
- *   )
- */
-import type { FlowChart } from 'footprintjs';
-import { type ActiveInjection, type Injection, type InjectionContext } from './types.js';
-import { type CursorMove } from './skillGraph.js';
-import { type StepPlanFor } from './skillSteps.js';
-import type { EngagementPlan } from '../../maps/engagement/types.js';
-export interface InjectionEngineConfig {
-    /**
-     * The Injection list. Frozen at build time. To change at runtime,
-     * rebuild the agent / chart — the primitive is intentionally
-     * declarative.
-     */
-    readonly injections: readonly Injection[];
-    /**
-     * The skill-graph CURSOR resolver (`graph.nextSkill`), present only when the
-     * agent was built with `.skillGraph()`. The Evaluate stage advances the cursor
-     * with the SAME `ctx` the triggers gate on, so trigger ↔ cursor never diverge
-     * (the keystone). Absent → `currentSkillId` is never written (no graph routing).
-     */
-    readonly nextSkill?: (ctx: InjectionContext) => string | undefined;
-    /**
-     * The same resolver, reporting the clause that WON (`graph.explainNextSkill`,
-     * 8.5.0). Preferred over `nextSkill` when present — the stage takes the cursor
-     * from `.to`, so the graph is still consulted exactly once per iteration, and
-     * stamps the cause on `context.evaluated` as `cursorMove`.
-     *
-     * Optional for forward-compat with graphs built before it existed; without it
-     * the stage falls back to `nextSkill` and emits no `cursorMove` (an observer
-     * then sees exactly what it saw in 8.4.0).
-     */
-    readonly explainNextSkill?: (ctx: InjectionContext) => CursorMove;
-    /**
-     * The graph's suppression reporter (`graph.supersededEntries`, 8.15.0) — the
-     * conditional entries whose own `when` matched this iteration while the cursor was
-     * elsewhere, so the cursor law kept them off the wire. Stamped on
-     * `context.evaluated` as `supersededIds`.
-     *
-     * Optional for forward-compat with graphs built before it existed; absent → the
-     * field is omitted and an observer sees exactly what it saw in 8.14.0.
-     */
-    readonly supersededEntries?: (ctx: InjectionContext) => readonly string[];
-    /**
-     * The gate's admissible set, for the record (9.50.0) — given the cursor a
-     * move landed on, the skill ids the `read_skill` gate will admit this
-     * iteration (declared hops out of that cursor plus the open skills). The
-     * Agent composes it from the SAME two resolvers the `read_skill` offer and
-     * the refusal messages use, so the recorded set can never drift from the
-     * verdicts. Stamped on `context.evaluated.cursorMove` as `reachable`.
-     *
-     * Optional for forward-compat with graphs built before `reachableSkills`
-     * existed; absent → the field is omitted and an observer sees exactly what
-     * it saw in 9.49.0.
-     */
-    readonly reachableSkills?: (currentSkillId?: string) => readonly string[];
-    /**
-     * The frozen step plans, keyed by skill id (9.18.0) — present only when
-     * ≥1 registered skill declares `steps`. The Evaluate stage owns the
-     * pointer's TENURE RE-KEY with it, at the same stage the cursor truth
-     * lives: tenant changed → fresh pointer (or cleared, when the new tenant
-     * has no steps); unchanged → pass-through. Absent → no pointer key is
-     * ever written (zero-cost-when-unused).
-     */
-    readonly stepPlanFor?: StepPlanFor;
-    /**
-     * The mount kernel's plan (9.58.0) — present only when the agent was built
-     * with `.maps()`. The Evaluate stage advances every mounted map's
-     * engagement with the SAME ctx the triggers gate on, and hands the parked
-     * maps' member ids to the evaluator as the one framework-tier suppression
-     * (`ctx.parkedIds`, the `leaseActiveIds` admission's mirror). Absent →
-     * nothing here runs and the evaluation is byte-identical.
-     */
-    readonly engagement?: EngagementPlan;
-}
-/** One routed entry per (active injection × slot it contributes to). */
-export interface RoutedInjection {
-    readonly id: string;
-    readonly source: ActiveInjection['flavor'];
-    readonly reason: string;
-}
-/** Active injections partitioned by the slot they contribute to. */
-export interface ActiveBySlot {
-    readonly systemPrompt: readonly RoutedInjection[];
-    readonly messages: readonly RoutedInjection[];
-    readonly tools: readonly RoutedInjection[];
-}
-/** Per-slot change since last turn. */
-export interface SlotDeltaEntry {
-    readonly added: readonly string[];
-    readonly removed: readonly string[];
-    readonly kept: readonly string[];
-}
-/** Per-slot delta across the whole context. */
-export interface SlotDelta {
-    readonly systemPrompt: SlotDeltaEntry;
-    readonly messages: SlotDeltaEntry;
-    readonly tools: SlotDeltaEntry;
-}
-/** Empty buckets — turn-1 prior, and the safe default for the mappers. */
-export declare const EMPTY_ACTIVE_BY_SLOT: ActiveBySlot;
-/**
- * Build the Injection Engine subflow — Gather → Evaluate → Route → Delta.
- */
-export declare function buildInjectionEngineSubflow(config: InjectionEngineConfig): FlowChart;
-/** 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). */
-export declare function routeActiveInjections(active: readonly ActiveInjection[]): ActiveBySlot;
-/** Diff two per-slot snapshots into a per-slot delta. Pure — exported for
- *  unit tests + reuse. */
-export declare function diffActiveBySlot(prior: ActiveBySlot, current: ActiveBySlot): SlotDelta;
-//# sourceMappingURL=buildInjectionEngineSubflow.d.ts.map

package/dist/types/lib/injection-engine/buildInjectionEngineSubflow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildInjectionEngineSubflow.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/buildInjectionEngineSubflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAIzD,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAGL,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,gCAAgC,CAAC;AAEpF,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,MAAM,GAAG,SAAS,CAAC;IACnE;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,UAAU,CAAC;IAClE;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1E;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1E;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;CACtC;AAID,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,YAAY,EAAE,SAAS,eAAe,EAAE,CAAC;IAClD,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;CAC5C;AAED,uCAAuC;AACvC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,+CAA+C;AAC/C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC;AAED,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,EAAE,YAIlC,CAAC;AAiGF;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAkCpF;AA+bD;;8DAE8D;AAC9D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,YAAY,CAyBtF;AAmBD;0BAC0B;AAC1B,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,GAAG,SAAS,CAMtF"}

package/dist/types/lib/injection-engine/classifierScorer.d.ts

@@ -1,45 +0,0 @@
-/**
- * classifierScorer — an {@link EntryScorer} whose ranking IS a calibrated
- * classifier's distribution (9.104.0; docs/design/2026-09-scored-choice.md
- * step 2, opened when a provider that scores came in reach).
- *
- * `keywordScorer` and `embeddingScorer` compute a raw score per candidate
- * and let `rankEntries` soften it into a `relevance` share. This scorer has
- * no raw score to soften: the classifier is asked ONE `choice` question
- * over the candidates — criteria `{ id: description }`, declared before the
- * call, the same law as declared tags and routes — and answers with a
- * probability per candidate and a pick. Both are the provider's data and
- * both land on `EntryScoring` unchanged: `ranked[].score` and
- * `ranked[].relevance` are the SAME number (the probability as sent, never
- * renormalised), and `chosen` is the provider's `choice`, not an argmax the
- * library took — a provider whose pick differs from its own argmax is
- * recorded as it answered, which is a fact about the provider.
- *
- * A provider failure is NOT a guess: the scorer returns
- * `scorer: 'classifier:unavailable'`, an EMPTY ranking and no `chosen`.
- * `stages/pickEntry.ts` leaves the cursor unset on an undefined `chosen`
- * and the Injection Engine's cold-start entry pick takes over — the
- * fallback that already exists for a throwing embedder, reached here
- * through the honest empty result rather than a throw.
- *
- * Pure core of the skill-graph fence: the only import outside the folder
- * is the `Classifier` port type (`src/classify/types.ts`, a zero-import leaf).
- */
-import type { Classifier } from '../../classify/types.js';
-import type { EntryScorer } from './entryScorer.js';
-export interface ClassifierScorerOptions {
-    /** The instruction on the choice question. Default: pick the skill the message is for. */
-    readonly instructions?: string;
-}
-/** The question id every scoring asks under — fixed, so a record reader can find it. */
-export declare const CLASSIFIER_SCORER_QUESTION: "entry";
-/** The `scorer` name on an unavailable result. */
-export declare const CLASSIFIER_SCORER_UNAVAILABLE: "classifier:unavailable";
-/**
- * `classifierScorer(classifier)` — plug into `skillGraph().entryBy(...)`.
- * `scorer` on a scoring is `'classifier:' + the provider's model string`
- * (`'classifier:jev-1.13.0'`), so the "Why this skill?" panel names the
- * exact model that ranked.
- */
-export declare function classifierScorer(classifier: Classifier, options?: ClassifierScorerOptions): EntryScorer;
-//# sourceMappingURL=classifierScorer.d.ts.map

package/dist/types/lib/injection-engine/classifierScorer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"classifierScorer.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/classifierScorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAc,WAAW,EAAkC,MAAM,kBAAkB,CAAC;AAEhG,MAAM,WAAW,uBAAuB;IACtC,0FAA0F;IAC1F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,SAAmB,CAAC;AAC3D,kDAAkD;AAClD,eAAO,MAAM,6BAA6B,0BAAoC,CAAC;AAM/E;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,uBAA4B,GACpC,WAAW,CAsCb"}

package/dist/types/lib/injection-engine/constrainedEnumPick.d.ts

@@ -1,60 +0,0 @@
-/**
- * constrainedEnumPick — ONE model call that can only answer from a fixed
- * list (9.19.0). The machinery extracted from `llmClassifier` so the tier-3
- * decider (RouteTurn's out-of-band menu resolver) and the classifier share
- * one enum discipline instead of two drifting copies:
- *
- *   • When `forcedToolChoiceFor(provider, model)` permits it, the pick rides
- *     a forced synthetic tool whose single argument is `enum: allowed` —
- *     the same mechanism the `'tool-forced'` output strategy uses. The
- *     provider constrains generation; an answer outside the enum cannot be
- *     emitted at all.
- *   • On any other provider it is a strict single-line parse validated
- *     against the enum, ONE structured re-ask, then the caller's fallback.
- *
- * An off-enum answer is a PARSE FAILURE, never a pick — this function can
- * never return an id it was not given (the `allowed` list plus `fallback`).
- * Callers put their own "none" sentinel INTO `allowed` (and as `fallback`)
- * so the model can decline explicitly; the sentinel is a first-class enum
- * member on the wire, exactly as `llmClassifier` has always sent it.
- */
-import type { LLMProvider } from '../../adapters/types.js';
-/** The synthetic pick tool, named by the caller (the wire shows this name). */
-export interface EnumPickTool {
-    readonly name: string;
-    readonly description: string;
-    /** The single argument's name (`'intent'` for the classifier, `'skill'`
-     *  for the decider) — a reader of the raw request sees the domain word. */
-    readonly argName: string;
-    readonly argDescription: string;
-}
-export interface ConstrainedEnumPickRequest {
-    readonly provider: LLMProvider;
-    /** Model id for the call. Left unset, the request carries an empty model
-     *  id, which only the mock tolerates — name it for any real provider. */
-    readonly model?: string;
-    /** The catalog/context prompt — WITHOUT the parse instruction; the parse
-     *  path appends its own, so both paths read one catalog. */
-    readonly systemPrompt: string;
-    readonly messages: ReadonlyArray<{
-        readonly role: 'user' | 'assistant';
-        readonly content: string;
-    }>;
-    /** The complete enum, the caller's decline-sentinel included. */
-    readonly allowed: readonly string[];
-    /** Returned on parse failure / off-enum after the one re-ask (callers pass
-     *  their decline-sentinel, conventionally `'none'`). */
-    readonly fallback: string;
-    readonly pickTool: EnumPickTool;
-    readonly signal?: AbortSignal;
-}
-/** Run the pick. Resolves to a member of `allowed`, else `fallback`. */
-export declare function constrainedEnumPick(req: ConstrainedEnumPickRequest): Promise<string>;
-/**
- * A trimmed single-token answer that IS one of the allowed ids, else undefined.
- * The decoration is walked off each end, not matched with `/[…]+$/`: the
- * reply is model output, and that regex retries from every position of a long
- * run of quotes (`lib/linearText.ts` · "Why these exist").
- */
-export declare function parseEnumLine(content: string, allowed: readonly string[]): string | undefined;
-//# sourceMappingURL=constrainedEnumPick.d.ts.map

package/dist/types/lib/injection-engine/constrainedEnumPick.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constrainedEnumPick.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/constrainedEnumPick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAA0C,MAAM,yBAAyB,CAAC;AAInG,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;+EAC2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B;6EACyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;gEAC4D;IAC5D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,CAAC,CAAC;IACH,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;4DACwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,wEAAwE;AACxE,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,0BAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAI1F;AAsED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAG7F"}

package/dist/types/lib/injection-engine/devWarn.d.ts

@@ -1,48 +0,0 @@
-/**
- * devWarn — the dev-warning SEAM for the pure skill-graph core (9.34.0).
- *
- * THE PROBLEM IT SOLVES. `skillGraph.ts` and `skillIntent.ts` print dev-mode
- * warnings (a throwing matcher, a check-up with problems, a leaf set that did
- * not fire exactly once). Those warnings were gated on `isDevMode()` imported
- * from `footprintjs` — a real dependency on the flowchart engine, inside the
- * two files whose whole point is that they do not depend on one. footprintjs's
- * dev flag is a module-private boolean toggled by `enableDevMode()`, so the
- * pure core cannot read it without importing the engine.
- *
- * THE SEAM. The pure core asks a READER it was handed. The default reader
- * says "not dev mode", so a pure-core-only host is silent until it opts in.
- * agentfootprint's own host binds the reader to footprintjs's `isDevMode`
- * (see `devWarnHost.ts`, side-effect-imported by the injection-engine
- * barrel), so every warning in this package behaves exactly as it did — same
- * text, same gate, same `enableDevMode()` switch.
- *
- * (Precedent: footprintjs's own `capture/envelope.ts` dev-warn seam — the
- * pure module stays pure, the tier that owns the flag binds the warner.)
- *
- * Zone: PURE CORE. Pinned by
- * `test/lib/injection-engine/skill-graph-fence.test.ts`.
- */
-/** Answers "should dev-time warnings print?". */
-export type DevModeReader = () => boolean;
-/**
- * Bind the dev-mode reader the pure core consults.
- *
- * agentfootprint calls this for you — importing anything from
- * `agentfootprint/context` (or the main entry) binds it to footprintjs's
- * `isDevMode`, so `enableDevMode()` keeps switching skill-graph warnings on
- * exactly as before.
- *
- * A host running the graph through `agentfootprint/skill-graph` alone gets
- * NO warnings until it calls this — that door deliberately loads no engine,
- * and a warning gate is not worth an import of one.
- *
- * @example turn skill-graph dev warnings on in a foreign host
- *   import { useSkillGraphDevMode } from 'agentfootprint/skill-graph';
- *   useSkillGraphDevMode(() => process.env.NODE_ENV !== 'production');
- */
-export declare function useSkillGraphDevMode(read: DevModeReader | undefined): void;
-/** Is dev mode on, per the bound reader? The gate the hot paths check. */
-export declare function devMode(): boolean;
-/** Print `message` to the console when dev mode is on. Never throws. */
-export declare function devWarn(message: string): void;
-//# sourceMappingURL=devWarn.d.ts.map

package/dist/types/lib/injection-engine/devWarn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"devWarn.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/devWarn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC;AAM1C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI,CAE1E;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,IAAI,OAAO,CAEjC;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI7C"}

package/dist/types/lib/injection-engine/devWarnHost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"devWarnHost.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/devWarnHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/types/lib/injection-engine/entryScorer.d.ts

@@ -1,112 +0,0 @@
-/**
- * EntryScorer — the pluggable STRATEGY for ranking a skill graph's entry
- * candidates by relevance to the user's message.
- *
- * `skillGraph().entryBy(scorer)` selects a strategy; the agent's PickEntry stage
- * runs it ONCE per turn (off the hot loop) and starts the cursor at the winner.
- * Two built-ins ship:
- *   • `keywordScorer()`      — no dependency, no model call: word overlap between
- *     the message and each skill's `description`. The zero-config way to route.
- *   • `embeddingScorer(e)`   — semantic: cosine similarity of embeddings (needs an
- *     Embedder). `.entryByRelevance(embedder)` is sugar for this.
- * Bring your own by implementing `EntryScorer`.
- *
- * The scorer OWNS both the surfaced `relevance` % AND the `chosen` winner, so the
- * explanation and the decision can never disagree (softmax is order-preserving, so
- * argmax-score == argmax-relevance).
- */
-import type { Embedder } from '../../memory/embedding/types.js';
-import type { IntentScorer } from './intentScorer.js';
-/** One entry candidate's relevance to the user's message. */
-export interface EntryScore {
-    /** The entry skill id. */
-    readonly id: string;
-    /** Raw, strategy-specific score — cosine for `embedding`, word-overlap for
-     *  `keyword`. Higher = more relevant. Not normalized across strategies. */
-    readonly score: number;
-    /** Softmax share across candidates, 0..1 — the surfaced "Why this skill?" %. */
-    readonly relevance: number;
-}
-/** Result of scoring the entries — the picked entry, the full ranking, and which
- *  scorer produced it. */
-export interface EntryScoring {
-    /** The scorer's `name` (e.g. `'keyword'`, `'embedding'`) — surfaced so a lens /
-     *  the "Why this skill?" panel can say HOW the entry was chosen. */
-    readonly scorer: string;
-    /** Winning entry id (highest `score`), or undefined if no candidate. */
-    readonly chosen: string | undefined;
-    /** Every scored candidate, in declaration order. */
-    readonly ranked: readonly EntryScore[];
-}
-/** A candidate the scorer ranks — its id + the text it's matched on (the skill's
- *  `description`). */
-export interface EntryCandidate {
-    readonly id: string;
-    readonly description: string;
-}
-/** What a scorer receives: the user's message + the candidates to rank. */
-export interface EntryScorerInput {
-    readonly userMessage: string;
-    readonly candidates: readonly EntryCandidate[];
-}
-/**
- * A strategy for ranking entry candidates. Pure given its inputs; may be async (an
- * embedder makes network calls). Runs ONCE per turn off the hot loop, so cost here
- * never touches the ReAct inner loop.
- */
-export interface EntryScorer {
-    /** Short, stable name — shown in the lens / "Why this skill?" panel + any
-     *  strategy picker. */
-    readonly name: string;
-    score(input: EntryScorerInput, signal?: AbortSignal): Promise<EntryScoring> | EntryScoring;
-}
-/**
- * Shared finisher: raw scores → `EntryScoring`. Softmax turns the (sanitized) raw
- * scores into a `relevance` share (sums to 1); the winner is the argmax with
- * declaration order breaking ties. Because softmax is order-preserving over the
- * sanitized scores, the WINNER is always the argmax `relevance` — the surfaced %
- * and the pick can never disagree.
- *
- * `EntryScorer` is a public, consumer-implementable interface, so a third-party
- * scorer might return `NaN` / `±Infinity`. We sanitize those to `-Infinity` for BOTH
- * the softmax input AND the winner pick, so a non-finite score can never silently win
- * (`NaN > x` is always false — a leading `NaN` would otherwise seed-and-keep a naive
- * reduce) and the softmax stays well-defined. The raw (possibly non-finite) score is
- * still surfaced on `EntryScore.score` for honest debugging.
- */
-export declare function rankEntries(scorerName: string, candidates: readonly EntryCandidate[], rawScores: readonly number[]): EntryScoring;
-/**
- * keywordScorer — rank by word overlap between the message and each description.
- * No embedder, no model call, deterministic. Scores the set-cosine of lowercased
- * word tokens (length-normalized so a long description can't win on sheer size),
- * minus a small stop-word list. The zero-config router: good enough when skill
- * descriptions use the words a user would.
- *
- * ALSO an {@link IntentScorer} (SG-C): handed a candidates array as the second
- * argument it scores the message's set-cosine against each intent's sentence +
- * examples, and declares `floor: 0` — zero token overlap IS honestly "did not
- * match at all", so this scorer can say *unmatched*. One factory, one name,
- * two arities; existing `EntryScorer` callers are byte-unaffected.
- */
-export declare function keywordScorer(options?: {
-    readonly stopWords?: readonly string[];
-}): EntryScorer & IntentScorer;
-/**
- * embeddingScorer — rank by SEMANTIC similarity. Embeds the message + each
- * description and cosine-scores them. Needs an `Embedder` (a model call per text);
- * runs once per turn off the hot loop. `.entryByRelevance(embedder)` is sugar for
- * `.entryBy(embeddingScorer(embedder))`.
- *
- * ALSO an {@link IntentScorer} (SG-C): handed a candidates array it embeds the
- * message + one text per candidate (the intent sentence with its examples) and
- * cosine-scores them. **No floor unless you declare one** (`{ floor }`): an
- * absolute embedding threshold is a lie by default — measured in the field,
- * real intent clusters separate by single-digit percentages of cosine, so a
- * built-in cutoff would flip between "unmatched" and "decisive" on noise.
- * Without a floor this scorer can say *stay*, *move* or *near-tie*, never
- * *unmatched* — the verdict table documents that honestly.
- */
-export declare function embeddingScorer(embedder: Embedder, options?: {
-    readonly floor?: number;
-}): EntryScorer & IntentScorer;
-//# sourceMappingURL=entryScorer.d.ts.map

package/dist/types/lib/injection-engine/entryScorer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entryScorer.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/entryScorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAGhE,OAAO,KAAK,EAGV,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAE3B,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;+EAC2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;0BAC0B;AAC1B,MAAM,WAAW,YAAY;IAC3B;wEACoE;IACpE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;CACxC;AAED;sBACsB;AACtB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;CAChD;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;2BACuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;CAC5F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,SAAS,cAAc,EAAE,EACrC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,YAAY,CAcd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,OAAO,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACvD,WAAW,GAAG,YAAY,CA0B5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,WAAW,GAAG,YAAY,CAyC5B"}

package/dist/types/lib/injection-engine/evaluator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAMnF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,GAAG,EAAE,gBAAgB,GACpB,mBAAmB,CA+GrB"}

package/dist/types/lib/injection-engine/factories/defineFact.d.ts

@@ -1,85 +0,0 @@
-/**
- * defineFact — sugar for context-style Injections (data, not behavior).
- *
- * Use for developer-supplied facts the LLM should see in addition to
- * user messages and tool results. Examples: user profile, env info,
- * computed conversation summary, cached config, current time. Distinct
- * from Skills (LLM-activated guidance) and Steering (always-on rules)
- * in INTENT — they share the engine.
- *
- * Produces an `Injection` with:
- *   - flavor: `'fact'`
- *   - trigger: configurable (default `'always'`)
- *   - inject: `systemPrompt` (default), or `messages` with a declared role
- *
- * @example
- *   const userProfile = defineFact({
- *     id: 'user-profile',
- *     data: `Name: ${user.name}, Plan: ${user.plan}, Joined: ${user.joinedAt}`,
- *   });
- *
- *   const turnTime = defineFact({
- *     id: 'turn-time',
- *     data: `Current time: ${new Date().toISOString()}`,
- *   });
- */
-import type { WireRole } from '../../../adapters/types.js';
-import type { Injection, InjectionContext } from '../types.js';
-import type { CachePolicy } from '../../../cache/types.js';
-interface DefineFactBase {
-    readonly id: string;
-    readonly description?: string;
-    /** The fact (data string) to inject. */
-    readonly data: string;
-    /**
-     * Trigger control. Defaults to always-on. For conditional facts
-     * (e.g., "only show user profile after iteration 3"), pass a
-     * predicate via `activeWhen`.
-     */
-    readonly activeWhen?: (ctx: InjectionContext) => boolean;
-    /**
-     * Cache policy for this fact injection. Defaults to `'always'` —
-     * facts are typically static data the LLM should always have in mind.
-     * Override with `'never'` for facts containing volatile content
-     * (e.g., a `Current time:` fact); use `{ until }` for time-bounded
-     * facts.
-     */
-    readonly cache?: CachePolicy;
-}
-/**
- * `slot` and `role` are ONE decision, so the type makes them one choice.
- *
- * `slot: 'messages'` requires a `role` and there is deliberately no default:
- * who appears to speak is a meaning the app owns. (Before 7.19.1 the option
- * existed with `role` defaulting to `'system'` — a default that reached the
- * model on OpenAI-family providers and vanished on Anthropic-family ones.
- * Now the role is stated, and a provider that cannot carry it refuses at run
- * start by name.) `slot: 'system-prompt'` forbids `role`, because there is no
- * role in a system prompt to choose.
- */
-export type DefineFactOptions = DefineFactBase & ({
-    /** The default. The one placement every provider delivers. */
-    readonly slot?: 'system-prompt';
-    readonly role?: never;
-} | {
-    /**
-     * Deliver the fact into the conversation itself — it enters
-     * `scope.history` at the injection-engine boundary, so the window
-     * strategies, the slots and the wire all see the same past.
-     * Placed at the END of the window; if its role would collide with
-     * the turn already there, delivery defers to the next boundary and
-     * says so on `messagesDelivery.deferred`.
-     */
-    readonly slot: 'messages';
-    /**
-     * Who appears to say it. Required — no default. Refused at run start
-     * when the attached provider does not carry it inside `messages`
-     * (the Anthropic family drops `'system'` there; the OpenAI family
-     * carries it). `'tool'` is refused outright: a tool message answers a
-     * specific call, and an injection has no call to answer.
-     */
-    readonly role: WireRole;
-});
-export declare function defineFact(opts: DefineFactOptions): Injection;
-export {};
-//# sourceMappingURL=defineFact.d.ts.map

package/dist/types/lib/injection-engine/factories/defineFact.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineFact.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineFact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAoB,MAAM,aAAa,CAAC;AAGjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,UAAU,cAAc;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACzD;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC9B;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAC5C,CACI;IACE,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;CACvB,GACD;IACE;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACzB,CACJ,CAAC;AAEJ,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,CA6C7D"}

package/dist/types/lib/injection-engine/factories/defineInjection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineInjection.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineInjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAqB,KAAK,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,EAAwB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACjF,OAAO,EAAkB,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEjF,yFAAyF;AACzF,MAAM,MAAM,sBAAsB,GAC9B,CAAC;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GAAG,wBAAwB,CAAC,GACpD,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,kBAAkB,CAAC,GACxC,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,qBAAqB,CAAC,GAC9C,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,iBAAiB,CAAC,CAAC;AAE3C,0DAA0D;AAC1D,MAAM,MAAM,eAAe,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;AAE7D,wBAAgB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,SAAS,CAsBvE"}