agentfootprint 10.3.0 → 10.3.1

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

@@ -0,0 +1,211 @@
+/**
+ * hostContract — THE BOUNDARY between the skill-graph runtime and whatever
+ * runs it (9.34.0).
+ *
+ * The skill graph is a pure decision layer: given an `InjectionContext` it
+ * says which skill the cursor is in, which skills are reachable from there,
+ * and which injections are active. It does not call a model, does not own a
+ * loop, and does not know what a `Tool` is in any particular framework. This
+ * module is the small set of shapes that statement needs to be TRUE:
+ *
+ *   • {@link SkillToolSchema} / {@link SkillTool} — the narrow shape a skill's
+ *     tools must have for the graph to reason about them (a name, a
+ *     description, an input schema, something to run). agentfootprint's own
+ *     `Tool` structurally satisfies it; so would any other framework's.
+ *   • {@link SkillToolDescriptor} — a PLAIN description of a tool the graph
+ *     needs to exist (`read_skill` above all, which is how the model moves
+ *     the cursor). The graph describes it; the host constructs it in its own
+ *     tool type.
+ *   • {@link SkillCachePolicy} — the cache directive that rides the
+ *     `ActiveInjection` projection across the host boundary.
+ *   • {@link SkillGraphHost} — the obligations a host must meet for the graph
+ *     to route correctly. Documentation as a type.
+ *
+ * WHY STRUCTURAL COPIES. `SkillToolSchema` and `SkillCachePolicy` are
+ * field-for-field mirrors of `provider-contract/types.ts#LLMToolSchema` and
+ * `cache/types.ts#CachePolicy`. Mirroring them is what lets a foreign host
+ * satisfy the boundary without importing an adapter layer it does not use;
+ * TypeScript's structural typing then makes the two spellings mutually
+ * assignable, so nothing inside agentfootprint changed shape. The mirrors are
+ * PINNED against their originals by
+ * `test/injection-engine/skill-graph-fence.test.ts`, which fails on drift
+ * in either direction.
+ *
+ * Zone: PURE CORE. Zero imports, by construction.
+ */
+/**
+ * A tool's LLM-facing declaration — name, description, input schema.
+ *
+ * Structural mirror of `LLMToolSchema` (`src/provider-contract/types.ts`). Anything
+ * that satisfies one satisfies the other.
+ */
+export interface SkillToolSchema {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+/**
+ * The NARROW tool shape a skill carries in `InjectionContent.tools`.
+ *
+ * Two required members — a schema and something to run — because those are
+ * the only two the graph, the contract checker and the vocabulary checker
+ * ever read. agentfootprint's `Tool` adds credentials, artifact wants,
+ * check-in demands, capabilities and result ceilings on top; every one of
+ * them is optional, so a `Tool` IS a `SkillTool` and a `SkillTool` is
+ * accepted everywhere a `Tool` is. That is the point: a host on another
+ * framework hands its own tool objects straight in.
+ *
+ * `execute`'s context is deliberately `unknown` here — it is the HOST's
+ * execution context, and the graph never calls the tool.
+ */
+export interface SkillTool<TArgs = Record<string, unknown>, TResult = unknown> {
+    readonly schema: SkillToolSchema;
+    execute(args: TArgs, ctx: unknown): Promise<TResult> | TResult;
+}
+/**
+ * A tool the graph DESCRIBES but does not construct.
+ *
+ * `read_skill` is the load-bearing one: it is how the model asks to move the
+ * cursor, so the graph has to be able to say what that tool looks like —
+ * which ids are on the enum, which are reachable from here, what the menu
+ * offers this turn, what the result says. What it must NOT do is build the
+ * host's tool object, because that would drag a framework's tool factory
+ * (and everything that factory pulls in) into a pure decision layer.
+ *
+ * So the graph emits this POJO and the host adapts it:
+ *
+ * @example agentfootprint's own adapter (`skillTools.ts`)
+ *   const d = readSkillDescriptor(skills, offer);
+ *   return d && defineTool({ name: d.name, description: d.description,
+ *                            inputSchema: d.inputSchema, execute: d.execute });
+ *
+ * @example another framework
+ *   const d = readSkillDescriptor(skills);
+ *   myFramework.tool(d.name, d.description, d.inputSchema, d.execute);
+ */
+export interface SkillToolDescriptor<TArgs = Record<string, unknown>, TResult = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    /** Pure: same args in, same string out. No host context is passed. */
+    execute(args: TArgs): TResult;
+}
+/**
+ * Read-only snapshot a {@link SkillCachePolicy} predicate inspects.
+ * Structural mirror of `CachePolicyContext` (`src/cache/types.ts`).
+ */
+export interface SkillCachePolicyContext {
+    readonly iteration: number;
+    readonly iterationsRemaining: number;
+    readonly userMessage: string;
+    readonly lastToolName?: string;
+    readonly cumulativeInputTokens: number;
+}
+/**
+ * Whether an injection's content may be marked as a cacheable prefix.
+ * Structural mirror of `CachePolicy` (`src/cache/types.ts`) — carried
+ * across the boundary by `ActiveInjection.cache`, where a host that has no
+ * prefix cache at all can simply ignore it.
+ */
+export type SkillCachePolicy = 'always' | 'never' | 'while-active' | {
+    readonly until: (ctx: SkillCachePolicyContext) => boolean;
+};
+/**
+ * The obligations a host must meet to run a skill graph CORRECTLY.
+ *
+ * This is documentation as a type, not a runtime abstraction. Nothing in
+ * agentfootprint constructs one, nothing consumes one, and implementing it
+ * does not start a run — the package has exactly one run door and this is
+ * not a second one. It exists so the contract that was previously spread
+ * across four call sites in three files can be READ in one place, and so a
+ * host on another framework can typecheck its own wiring against it.
+ *
+ * `buildInjectionEngineSubflow.ts` + `core/agent/stages/toolCalls.ts` are the
+ * reference implementation of every clause below.
+ *
+ * @example checking a foreign host against the contract
+ *   const host: SkillGraphHost = {
+ *     advanceCursor: (ctx) => graph.explainNextSkill(ctx).to,
+ *     acceptSkillPick: (id, cursor) => graph.reachableSkills(cursor).includes(id),
+ *     …
+ *   };
+ */
+export interface SkillGraphHost {
+    /**
+     * **Obligation 1 — one cursor advance per iteration, off the SAME ctx.**
+     *
+     * Build the iteration's `InjectionContext` ONCE, ask the graph where the
+     * cursor goes with that exact object, and evaluate every trigger with that
+     * exact object. Route triggers are compiled as `nextSkill(ctx) === id`, so
+     * an active set derived from a different ctx than the stored cursor can
+     * disagree with it — the skill the loop thinks it is in and the body it
+     * actually injects come apart. This is the keystone; everything else here
+     * is bookkeeping around it.
+     *
+     * Reference: `buildInjectionEngineSubflow.ts` — `baseCtx` is built, handed
+     * to `explainNextSkill`, then handed to `evaluateInjections`.
+     */
+    advanceCursor(ctx: SkillGraphIterationContext): string | undefined;
+    /**
+     * **Obligation 2 — enforce reachability at PICK time.**
+     *
+     * When the model calls `read_skill(id)`, the host must check `id` against
+     * `graph.reachableSkills(cursor)` BEFORE treating the pick as real, and
+     * refuse teachingly when it is not reachable. The graph cannot enforce
+     * this itself: it never sees the tool call. A host that skips the gate
+     * turns every declared edge into a suggestion.
+     *
+     * Reference: `toolCalls.ts` — `deps.allowedSkillIds(currentSkillId)`.
+     */
+    acceptSkillPick(skillId: string, currentSkillId: string | undefined): boolean;
+    /**
+     * **Obligation 3 — publish an ACCEPTED pick, and only an accepted one.**
+     *
+     * `InjectionContext.pendingSkillPick` is the model's validated volunteer
+     * hop. Set it only after obligation 2 has said yes (a refused pick must
+     * never move the cursor), and clear it at the top of every iteration so it
+     * names a pick made just now rather than a stale one.
+     *
+     * Reference: `toolCalls.ts` — cleared once per iteration, then set only on
+     * the accepted-hop path.
+     */
+    publishAcceptedPick(skillId: string | undefined): void;
+    /**
+     * **Obligation 4 — carry the cursor across iterations.**
+     *
+     * The value obligation 1 produced becomes the NEXT iteration's
+     * `currentSkillId`. One run's worth: a skill graph declares how one turn
+     * is routed, so a fresh run starts at the entry, not where the last one
+     * stopped. A host that wants continuity persists the id itself and starts
+     * the next turn's graph from it.
+     *
+     * Reference: `buildInjectionEngineSubflow.ts` writes the advanced cursor
+     * to a distinct output key; the mount mappers map it onto the parent's
+     * `currentSkillId` for the next iteration.
+     */
+    carryCursor(nextSkillId: string | undefined): void;
+    /**
+     * **Obligation 5 — say what happened, out loud.**
+     *
+     * Every routing decision the graph makes is evidence, and evidence that is
+     * not emitted did not happen as far as any observer is concerned. A host
+     * should surface at minimum: a skill becoming active or inactive, a pick
+     * REFUSED by the gate, and a batch whose edges disagreed. agentfootprint
+     * spells these `agentfootprint.skill.activated` / `.deactivated` /
+     * `.rejected` / `.escalated` / `.route_conflict` / `.reroute_superseded` /
+     * `.turn_routed`; a foreign host may name them whatever it likes, but a
+     * refusal the operator cannot see is the one this contract cares about.
+     */
+    emitSkillEvent(name: string, payload: Readonly<Record<string, unknown>>): void;
+}
+/**
+ * The per-iteration context obligation 1 reads. Kept structural (rather than
+ * naming `InjectionContext`) so this module stays a zero-import leaf; the
+ * real `InjectionContext` satisfies it.
+ */
+export interface SkillGraphIterationContext {
+    readonly iteration: number;
+    readonly userMessage: string;
+    readonly currentSkillId?: string;
+    readonly pendingSkillPick?: string;
+}

package/dist/esm/injection-engine/hostContract.js

@@ -0,0 +1,37 @@
+/**
+ * hostContract — THE BOUNDARY between the skill-graph runtime and whatever
+ * runs it (9.34.0).
+ *
+ * The skill graph is a pure decision layer: given an `InjectionContext` it
+ * says which skill the cursor is in, which skills are reachable from there,
+ * and which injections are active. It does not call a model, does not own a
+ * loop, and does not know what a `Tool` is in any particular framework. This
+ * module is the small set of shapes that statement needs to be TRUE:
+ *
+ *   • {@link SkillToolSchema} / {@link SkillTool} — the narrow shape a skill's
+ *     tools must have for the graph to reason about them (a name, a
+ *     description, an input schema, something to run). agentfootprint's own
+ *     `Tool` structurally satisfies it; so would any other framework's.
+ *   • {@link SkillToolDescriptor} — a PLAIN description of a tool the graph
+ *     needs to exist (`read_skill` above all, which is how the model moves
+ *     the cursor). The graph describes it; the host constructs it in its own
+ *     tool type.
+ *   • {@link SkillCachePolicy} — the cache directive that rides the
+ *     `ActiveInjection` projection across the host boundary.
+ *   • {@link SkillGraphHost} — the obligations a host must meet for the graph
+ *     to route correctly. Documentation as a type.
+ *
+ * WHY STRUCTURAL COPIES. `SkillToolSchema` and `SkillCachePolicy` are
+ * field-for-field mirrors of `provider-contract/types.ts#LLMToolSchema` and
+ * `cache/types.ts#CachePolicy`. Mirroring them is what lets a foreign host
+ * satisfy the boundary without importing an adapter layer it does not use;
+ * TypeScript's structural typing then makes the two spellings mutually
+ * assignable, so nothing inside agentfootprint changed shape. The mirrors are
+ * PINNED against their originals by
+ * `test/injection-engine/skill-graph-fence.test.ts`, which fails on drift
+ * in either direction.
+ *
+ * Zone: PURE CORE. Zero imports, by construction.
+ */
+export {};
+//# sourceMappingURL=hostContract.js.map

package/dist/esm/injection-engine/hostContract.js.map

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

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

@@ -0,0 +1,40 @@
+/**
+ * agentfootprint Injection Engine — public barrel.
+ *
+ * The unifying primitive of agentfootprint context engineering.
+ * One `Injection` type. One `InjectionEngine` subflow. N typed sugar
+ * factories. See `README.md` in this folder for the full concept.
+ */
+import './devWarnHost.js';
+export type { Injection, InjectionTrigger, InjectionContent, InjectionContext, InjectionEvaluation, ActiveInjection, } from './types.js';
+export { projectActiveInjection } from './types.js';
+export { toolResultsOf } from './types.js';
+export { saidByPerson } from './types.js';
+export { evaluateInjections } from './evaluator.js';
+export { buildInjectionEngineSubflow, type InjectionEngineConfig, } from './buildInjectionEngineSubflow.js';
+export { defineInstruction, type DefineInstructionOptions } from './factories/defineInstruction.js';
+export { defineRelevanceHint, READS_ENTRY_SCORES_METADATA_KEY, type RelevanceHintOptions, } from './factories/defineRelevanceHint.js';
+export { defineMenuHint, MENU_HINT_METADATA_KEY, type MenuHintOptions, } from './factories/defineMenuHint.js';
+export { defineSkill, resolveSurfaceMode, type DefineSkillOptions, type SurfaceMode, type AutoActivateMode, } from './factories/defineSkill.js';
+export { pointerOf, SKIP_STEP_TOOL_NAME, skipStepDescriptor, type OnSkipPolicy, type SkillStep, type StepPlan, type StepPointer, type StepPointerCarrier, } from './skillSteps.js';
+export { defineStepsHint, STEPS_HINT_METADATA_KEY, type StepsHintOptions, } from './factories/defineStepsHint.js';
+export { checkArtifactVocabularies, vocabularyOf, type ArtifactVocabulary, } from './skillVocabulary.js';
+export { SkillRegistry, type SkillRegistryOptions } from './SkillRegistry.js';
+export { skillsFromDir, runbookFromDir, type SkillsFromDirOptions, type DirRunbook, } from './skillsFromDir.js';
+export { buildListSkillsTool, buildReadSkillTool, buildSkipStepTool, type ReadSkillOffer, type SkillToolPair, } from './skillTools.js';
+export { listSkillsDescriptor, readSkillDescriptor } from './skillToolDescriptors.js';
+export type { SkillCachePolicy, SkillCachePolicyContext, SkillGraphHost, SkillGraphIterationContext, SkillTool, SkillToolDescriptor, SkillToolSchema, } from './hostContract.js';
+export { TOOL_RESULT_STATUSES, type ToolResultStatus } from '../semantics/toolOutcome.js';
+export { useSkillGraphDevMode, type DevModeReader } from './devWarn.js';
+export { defineSteering, type DefineSteeringOptions } from './factories/defineSteering.js';
+export { defineFact, type DefineFactOptions } from './factories/defineFact.js';
+export { defineInjection, type DefineInjectionOptions, type InjectionFlavor, } from './factories/defineInjection.js';
+export { skillGraph, defineSkillMap, type SkillMap, decideSkill, formatCheckup, SKILL_GRAPH_METADATA_KEY, type SkillGraph, type SkillGraphBuilder, type SkillRouteOptions, type SkillEntryOptions, type TreeOptions, type SkillEdge, type SkillEdgeKind, type SkillNode, type DecisionNode, type SkillRouting, type SkillRoutingStep, type CursorMove, type CursorMoveCause, type RouteBatchConflict, type RouteBatchOutcome, type EntryScore, type EntryScoring, type SkillGraphConfig, type SkillGraphFlatConfig, type SkillGraphTreeConfig, type SkillGraphStart, type SkillGraphStep, type SkillMatch, type SkillMatchData, type SkillStartRule, GUARD_HOP_KEYS, plainGuardCaption, type GuardConditionData, type GuardConditionEvidence, type GuardEvaluation, type GuardOperator, type GuardValue, type SkillGuard, type SkillGuardData, type SkillGuardOps, SKILL_GRAPH_DEFERRED_CONTRACT_KEY, type DeferredBodyContract, type BuildOptions, type CheckupOptions, type GraphCheckMode, type GraphCheckup, type GraphProblem, type GraphProblemCode, classifySkillTarget, type SkillTargetClass, } from './skillGraph.js';
+export { keywordScorer, embeddingScorer, rankEntries, type EntryScorer, type EntryScorerInput, type EntryCandidate, } from './entryScorer.js';
+export { classifierScorer, CLASSIFIER_SCORER_QUESTION, CLASSIFIER_SCORER_UNAVAILABLE, type ClassifierScorerOptions, } from './classifierScorer.js';
+export { validateIntentScores, type IntentScorer, type IntentCandidate, type IntentScore, type IntentScorerInput, } from './intentScorer.js';
+export { llmClassifier, type LlmClassifierOptions } from './llmClassifier.js';
+export { constrainedEnumPick, type ConstrainedEnumPickRequest, type EnumPickTool, } from './constrainedEnumPick.js';
+export { NEAR_TIE_MARGIN, MENU_SIZE, DEFAULT_ROUTING_POLICY, decideTier2, menuOutstanding, type RoutingPolicy, type Tier2Verdict, type RankedIntentScore, type TurnRoute, } from './routingPolicy.js';
+export type { TurnRoutingPlan } from './skillIntent.js';
+export { checkSkillContract, checkSkillContracts, skillToolNames, type SkillContractOptions, } from './skillContract.js';

package/dist/esm/injection-engine/index.js

@@ -0,0 +1,116 @@
+/**
+ * agentfootprint Injection Engine — public barrel.
+ *
+ * The unifying primitive of agentfootprint context engineering.
+ * One `Injection` type. One `InjectionEngine` subflow. N typed sugar
+ * factories. See `README.md` in this folder for the full concept.
+ */
+// Bind the pure core's dev-warn seam to footprintjs's `isDevMode` (9.34.0).
+// Side-effect import, on purpose: the skill-graph core no longer imports the
+// engine, so SOMEONE has to hand it the dev flag, and this barrel is on every
+// path inside this package that can reach `skillGraph()`. Without it,
+// `enableDevMode()` would stop switching skill-graph warnings on — the one
+// behavior the fence refactor must not change. `agentfootprint/skill-graph`
+// deliberately skips it; see `devWarn.ts`.
+import './devWarnHost.js';
+// POJO projection — used by slot subflows + advanced consumers
+export { projectActiveInjection } from './types.js';
+// The iteration's tool-result batch with the singular fallback applied
+// (9.16.0) — the one reader `rule` predicates should use to see every call of
+// a parallel batch, not only the last (`ctx.toolResults ?? [ctx.lastToolResult]`).
+export { toolResultsOf } from './types.js';
+// The messages a PERSON wrote (9.84.0) — the one reader for a predicate that
+// judges what was said. `ctx.history` also holds the five user-role messages
+// this library writes itself (compaction frame, drop notice, schema-check
+// correction, evidence-check correction, delivered message), and a rule
+// scanning it raw matches our own bookkeeping.
+export { saidByPerson } from './types.js';
+// Engine
+export { evaluateInjections } from './evaluator.js';
+export { buildInjectionEngineSubflow, } from './buildInjectionEngineSubflow.js';
+// Sugar factories — Ships four; more flavors planned (RAG / Memory / Guardrail)
+export { defineInstruction } from './factories/defineInstruction.js';
+export { defineRelevanceHint, READS_ENTRY_SCORES_METADATA_KEY, } from './factories/defineRelevanceHint.js';
+export { defineMenuHint, MENU_HINT_METADATA_KEY, } from './factories/defineMenuHint.js';
+export { defineSkill, resolveSurfaceMode, } from './factories/defineSkill.js';
+// Steps-as-data (9.18.0) — the procedure grammar. `skillSteps.ts` is the ONE
+// owner of the types, the pointer's shape and every sentence the model reads;
+// the public slice here is what a consumer needs to DECLARE steps, READ the
+// pointer off a snapshot (`pointerOf(sharedState.stepPointer)`), and compose
+// the integrity tool into custom wiring (the buildReadSkillTool precedent).
+export { pointerOf, SKIP_STEP_TOOL_NAME, skipStepDescriptor, } from './skillSteps.js';
+export { defineStepsHint, STEPS_HINT_METADATA_KEY, } from './factories/defineStepsHint.js';
+// Artifact vocabularies (9.25.0) — `produces`/`consumes` on a skill or a step.
+// The public slice is what a consumer needs to READ a skill's declared data
+// legs off its metadata (`vocabularyOf`, for a lens or an inventory) and to run
+// the satisfiability check itself over a list of skills the library did not
+// assemble. `assertArtifactVocabulary` stays private: it is the authoring-time
+// refusal `defineSkill` already applies.
+export { checkArtifactVocabularies, vocabularyOf, } from './skillVocabulary.js';
+export { SkillRegistry } from './SkillRegistry.js';
+// File-authored skills — a loader over `defineSkill`, not a second mechanism.
+// Node-only (reads the filesystem); node:fs is imported lazily inside the call
+// so this barrel stays safe to import from a browser bundle.
+// `runbookFromDir` is the same loader read as a whole runbook — skills PLUS the
+// edges each file's `routes:` declares, ready for `skillGraph({ ...runbook })`.
+export { skillsFromDir, runbookFromDir, } from './skillsFromDir.js';
+// Skill-tool builders — used by SkillRegistry.toTools() and the Agent's
+// auto-attach path. Exported so consumers building custom tool wiring
+// (e.g., gatedTools chains) can compose the same `list_skills` /
+// `read_skill` tools directly.
+export { buildListSkillsTool, buildReadSkillTool, buildSkipStepTool, } from './skillTools.js';
+// The graph's own DESCRIPTIONS of the tools it needs (9.34.0) — the POJOs the
+// builders above wrap. Exported because a host composing its own tool objects
+// (another framework, a custom ToolProvider) should read `read_skill`'s enum,
+// reachability offer and result sentences from the library rather than
+// re-writing them. Also the whole surface of `agentfootprint/skill-graph`.
+export { listSkillsDescriptor, readSkillDescriptor } from './skillToolDescriptors.js';
+export { TOOL_RESULT_STATUSES } from '../semantics/toolOutcome.js';
+export { useSkillGraphDevMode } from './devWarn.js';
+export { defineSteering } from './factories/defineSteering.js';
+export { defineFact } from './factories/defineFact.js';
+// Unified factory — a `type` discriminant routes to the four named factories
+// above. Use when the flavor is chosen programmatically; prefer the named
+// factories when you know the flavor at author time.
+export { defineInjection, } from './factories/defineInjection.js';
+// Declarative skill graph (proposal 002) — declare skills + routing edges →
+// graph-derived triggers + a drawable topology. Sugar over the trigger model.
+export { skillGraph, 
+// The official vocabulary (9.51.0): you declare the SkillMap; the agent is
+// the SkillWalker; the recording carries both. `defineSkillMap` is a
+// permanent reference-equal alias of `skillGraph`, `SkillMap` of
+// `SkillGraph` — both names ship forever, neither is a rename.
+defineSkillMap, decideSkill, 
+// 8.7.0 — render a `graph.checkup()` for a log line or a CI failure. The formatter
+// the library itself uses; without it every consumer wrote their own. `checkupGraph`
+// stays private: its input is the graph's internal wiring shape, and `graph.checkup()`
+// is already the door to it.
+formatCheckup, SKILL_GRAPH_METADATA_KEY, 
+// Guards-as-data on route edges (9.51.0) — the SkillWalker's guard mover as
+// data: `guard:` beside the code `when`, compiled once into the predicate,
+// the serializable `SkillGuardData` (edges/provenance/`skill.graph_declared`)
+// and the per-condition evidence (`cursorMove.guard`/`guardsClosed`).
+GUARD_HOP_KEYS, plainGuardCaption, 
+// The graph's note that its body-contract checks wait for Agent build (present
+// only when built without `knownTools`) — see SkillGraph.deferredBodyContract.
+// The note rides the graph AND each compiled skill's metadata (under
+// SKILL_GRAPH_DEFERRED_CONTRACT_KEY), so Agent build honors it whichever way
+// the skills arrive — `.skillGraph(graph)` or `.skills({ list: () => graph.skills })`.
+SKILL_GRAPH_DEFERRED_CONTRACT_KEY, 
+// The ONE owner of "is this target the cursor?" (9.86.0) — every gate,
+// description and refusal switches on it instead of re-deriving it.
+classifySkillTarget, } from './skillGraph.js';
+export { keywordScorer, embeddingScorer, rankEntries, } from './entryScorer.js';
+export { classifierScorer, CLASSIFIER_SCORER_QUESTION, CLASSIFIER_SCORER_UNAVAILABLE, } from './classifierScorer.js';
+// The turn-start routing cascade (SG-C, 9.17.0) — the intent-scorer port +
+// the built-in LLM classifier, the tie policy that judges tier 2, and the
+// graph surfaces the agent consumes. keywordScorer/embeddingScorer above ARE
+// IntentScorers too (same factories, a second arity).
+export { validateIntentScores, } from './intentScorer.js';
+export { llmClassifier } from './llmClassifier.js';
+// The constrained-enum machinery behind the classifier AND the tier-3
+// decider (9.19.0) — one model call that can only answer from a fixed list.
+export { constrainedEnumPick, } from './constrainedEnumPick.js';
+export { NEAR_TIE_MARGIN, MENU_SIZE, DEFAULT_ROUTING_POLICY, decideTier2, menuOutstanding, } from './routingPolicy.js';
+export { checkSkillContract, checkSkillContracts, skillToolNames, } from './skillContract.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/injection-engine/index.js.map

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

package/dist/esm/injection-engine/intentScorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intentScorer.js","sourceRoot":"","sources":["../../../src/injection-engine/intentScorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAwDH;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAClC,UAAkB,EAClB,UAAsC,EACtC,MAA8B;IAE9B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC5C,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,2EAA2E;IAC3E,uEAAuE;IACvE,mEAAmE;IACnE,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aAC1D,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;gBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACpD,CAAC;;YAAM,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC3B,CAAC;IACD,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3E,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpE,MAAM,OAAO,GAAG;YACd,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrF,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;gBACpB,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC;gBAC7E,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;gBACrB,CAAC,CAAC,CAAC,UAAU,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC;gBACvE,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;QACF,MAAM,IAAI,KAAK,CACb,iBAAiB,UAAU,qCAAqC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI;YACvF,kFAAkF;YAClF,gFAAgF;YAChF,2DAA2D,CAC9D,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAE,CAAC,CAAC;AAChD,CAAC"}

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

@@ -0,0 +1,87 @@
+/**
+ * leases — the accepted transition proposal and the instruction leases a
+ * tool's `require-instruction` effect grants, as scope state, and the three
+ * pure functions over them (`tenantOf`, `activeLeaseIds`, `pruneLeases`).
+ *
+ * The effect GRAMMAR — the envelope, its two effect kinds, the delivery-lease
+ * words — is `semantics/toolEffects.ts`. What a granted lease MEANS across
+ * iterations is an injection concept: the injection engine's Evaluate stage
+ * serves and sweeps them, and the tool-calls stage appends new grants, so the
+ * carriers live here, beside their one reader.
+ */
+import type { InstructionDeliveryLease } from '../semantics/toolEffects.js';
+/**
+ * The transition proposal the tool-calls stage ACCEPTED this iteration —
+ * validated (graph mounted, target reachable), first-accepted-wins across
+ * the batch. One-shot BY DATA, not by clearing writes: it is stamped with
+ * the iteration that granted it, and the Evaluate stage honors it exactly
+ * once — on the following iteration — so nothing ever has to write the key
+ * back to undefined (zero-cost stays zero for agents that never see one).
+ */
+export interface PendingToolTransition {
+    readonly targetSkillId: string;
+    /** The proposing tool — provenance for the record. */
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    /** The effect's own declared reason. */
+    readonly reason: string;
+    /** The ReAct iteration whose batch granted it (valid for iteration + 1). */
+    readonly iteration: number;
+}
+/**
+ * One granted `require-instruction` lease. Validity is COMPUTED, never
+ * mutated: `'next-call'` serves exactly the Evaluate pass of
+ * `iteration + 1`; `'until-skill-exit'` serves every pass while the tenant
+ * that granted it (`skillId`) still holds the tenure.
+ *
+ * Death is PERMANENT, and the Evaluate tenure sweep is what makes it so:
+ * `skillId === tenant` alone cannot tell "still holding the tenure" from
+ * "re-entered the skill later" (a cyclic graph makes both real), so the
+ * Evaluate stage prunes dead leases on EVERY pass — the same pass a tenure
+ * ends, the leases it granted leave the record, and a cursor that comes back
+ * finds nothing to resurrect. The tool-calls stage also prunes when it
+ * appends a new grant (keeps mid-batch arrays tight), but the sweep is the
+ * law's owner: it runs whether or not anything new was granted.
+ */
+export interface InstructionLease {
+    readonly instructionId: string;
+    readonly deliveryLease: InstructionDeliveryLease;
+    /** The tenure that granted it (advanced cursor, else the activation tail);
+     *  absent when no tenant existed at grant. `'until-skill-exit'` compares
+     *  the CURRENT tenant against this — both-undefined still matches. */
+    readonly skillId?: string;
+    /** The granting tool — provenance for the record. */
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    /** The ReAct iteration whose batch granted it. */
+    readonly iteration: number;
+}
+/** Who holds the tenure — the advanced cursor on graph agents, else the tail
+ *  of `activatedInjectionIds` (the shipped `activeSkillId` notion the step
+ *  pointer's re-key already uses). */
+export declare function tenantOf(cursor: string | undefined, activatedInjectionIds: readonly string[] | undefined): string | undefined;
+/**
+ * The lease-served injection ids for ONE Evaluate pass — pure. `iteration`
+ * is the pass being composed; `tenant` is who holds the tenure on it (the
+ * ADVANCED cursor — a lease dies the same pass its tenure ends).
+ *
+ * `skillId === tenant` is a sound "tenure still holds" test ONLY because the
+ * Evaluate tenure sweep (`pruneLeases`, every pass) removes a dead lease the
+ * pass its tenure ends — so a cursor that re-enters the granting skill later
+ * finds nothing to match, instead of resurrecting an ended grant.
+ */
+export declare function activeLeaseIds(leases: readonly InstructionLease[] | undefined, iteration: number, tenant: string | undefined): readonly string[];
+/**
+ * Drop leases that can never serve again. `iteration` is the CURRENT pass;
+ * a `'next-call'` lease older than the previous iteration is spent, and an
+ * `'until-skill-exit'` lease whose tenant is no longer current is dead.
+ *
+ * TWO call sites, one law. The Evaluate stage sweeps on EVERY pass (writing
+ * the survivors under `nextInstructionLeases`, the cursor's alias round
+ * trip) — that sweep is what makes death permanent: it records the death the
+ * same pass the tenure ends, before any later pass could see the cursor
+ * re-enter the granting skill and mistake re-entry for an unbroken tenure.
+ * The tool-calls stage also prunes when it appends a new grant, so a
+ * mid-batch array never carries spent leases into the commit.
+ */
+export declare function pruneLeases(leases: readonly InstructionLease[] | undefined, iteration: number, currentTenant: string | undefined): readonly InstructionLease[];

package/dist/esm/injection-engine/leases.js

@@ -0,0 +1,64 @@
+/**
+ * leases — the accepted transition proposal and the instruction leases a
+ * tool's `require-instruction` effect grants, as scope state, and the three
+ * pure functions over them (`tenantOf`, `activeLeaseIds`, `pruneLeases`).
+ *
+ * The effect GRAMMAR — the envelope, its two effect kinds, the delivery-lease
+ * words — is `semantics/toolEffects.ts`. What a granted lease MEANS across
+ * iterations is an injection concept: the injection engine's Evaluate stage
+ * serves and sweeps them, and the tool-calls stage appends new grants, so the
+ * carriers live here, beside their one reader.
+ */
+/** Who holds the tenure — the advanced cursor on graph agents, else the tail
+ *  of `activatedInjectionIds` (the shipped `activeSkillId` notion the step
+ *  pointer's re-key already uses). */
+export function tenantOf(cursor, activatedInjectionIds) {
+    if (cursor !== undefined)
+        return cursor;
+    const activated = activatedInjectionIds ?? [];
+    return activated[activated.length - 1];
+}
+/**
+ * The lease-served injection ids for ONE Evaluate pass — pure. `iteration`
+ * is the pass being composed; `tenant` is who holds the tenure on it (the
+ * ADVANCED cursor — a lease dies the same pass its tenure ends).
+ *
+ * `skillId === tenant` is a sound "tenure still holds" test ONLY because the
+ * Evaluate tenure sweep (`pruneLeases`, every pass) removes a dead lease the
+ * pass its tenure ends — so a cursor that re-enters the granting skill later
+ * finds nothing to match, instead of resurrecting an ended grant.
+ */
+export function activeLeaseIds(leases, iteration, tenant) {
+    if (leases === undefined || leases.length === 0)
+        return [];
+    const ids = [];
+    for (const lease of leases) {
+        const live = lease.deliveryLease === 'next-call'
+            ? lease.iteration + 1 === iteration
+            : lease.skillId === tenant;
+        if (live && !ids.includes(lease.instructionId))
+            ids.push(lease.instructionId);
+    }
+    return ids;
+}
+/**
+ * Drop leases that can never serve again. `iteration` is the CURRENT pass;
+ * a `'next-call'` lease older than the previous iteration is spent, and an
+ * `'until-skill-exit'` lease whose tenant is no longer current is dead.
+ *
+ * TWO call sites, one law. The Evaluate stage sweeps on EVERY pass (writing
+ * the survivors under `nextInstructionLeases`, the cursor's alias round
+ * trip) — that sweep is what makes death permanent: it records the death the
+ * same pass the tenure ends, before any later pass could see the cursor
+ * re-enter the granting skill and mistake re-entry for an unbroken tenure.
+ * The tool-calls stage also prunes when it appends a new grant, so a
+ * mid-batch array never carries spent leases into the commit.
+ */
+export function pruneLeases(leases, iteration, currentTenant) {
+    if (leases === undefined || leases.length === 0)
+        return [];
+    return leases.filter((lease) => lease.deliveryLease === 'next-call'
+        ? lease.iteration + 1 > iteration
+        : lease.skillId === currentTenant);
+}
+//# sourceMappingURL=leases.js.map

package/dist/esm/injection-engine/leases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leases.js","sourceRoot":"","sources":["../../../src/injection-engine/leases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAsDH;;sCAEsC;AACtC,MAAM,UAAU,QAAQ,CACtB,MAA0B,EAC1B,qBAAoD;IAEpD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,SAAS,GAAG,qBAAqB,IAAI,EAAE,CAAC;IAC9C,OAAO,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,MAA+C,EAC/C,SAAiB,EACjB,MAA0B;IAE1B,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3D,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GACR,KAAK,CAAC,aAAa,KAAK,WAAW;YACjC,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,KAAK,SAAS;YACnC,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,CAAC;QAC/B,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,WAAW,CACzB,MAA+C,EAC/C,SAAiB,EACjB,aAAiC;IAEjC,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3D,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7B,KAAK,CAAC,aAAa,KAAK,WAAW;QACjC,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,GAAG,SAAS;QACjC,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,aAAa,CACpC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,39 @@
+/**
+ * llmClassifier — an {@link IntentScorer} that asks a model which declared
+ * intent the new message is (SG-C tier 2). ONE call per turn, off the hot
+ * loop, in the RouteTurn stage — never inside the ReAct iterations.
+ *
+ * **Constrained enum, never free text.** The pick runs through
+ * {@link constrainedEnumPick} (extracted from this module in 9.19.0 so the
+ * tier-3 decider shares the same discipline): when the provider declares
+ * forced-tool support for that model it rides a forced synthetic tool whose single
+ * argument is `enum: [...candidateIds, 'none']` (the same machinery the
+ * `'tool-forced'` output strategy uses); on any other provider it is a
+ * strict single-line parse validated against the enum, ONE structured
+ * re-ask, then `'none'`. An off-enum answer is a parse failure, not a route
+ * — this scorer can never emit an id it wasn't given.
+ *
+ * Output maps to scores the framework can judge: picked id → 1, others → 0;
+ * `'none'` → all 0. `floor: 0` (so `'none'` is honestly "unmatched") and
+ * `categorical: true` (one id or none — a pick is decisive by construction,
+ * never diluted by the near-tie margin; see `routingPolicy.ts`).
+ *
+ * One of the two injection-engine scorer modules that import
+ * `provider-contract/types` (the other is `constrainedEnumPick`, its machinery) —
+ * kept out of `entryScorer.ts` so the keyword/embedding paths stay
+ * adapter-free.
+ */
+import type { LLMProvider } from '../provider-contract/types.js';
+import type { IntentScorer } from './intentScorer.js';
+export interface LlmClassifierOptions {
+    /** Model to classify with. Name it for any real provider — left unset, the
+     *  request carries an empty model id, which only the mock tolerates. */
+    readonly model?: string;
+    /** Recent-turns window (count of prior conversational turns shown to the
+     *  classifier). Absent = current message only. */
+    readonly window?: number;
+    /** Prompt budget: examples listed per intent. Default 5. */
+    readonly maxExamplesPerIntent?: number;
+}
+/** Build the classifier. See the module header for the enum discipline. */
+export declare function llmClassifier(provider: LLMProvider, options?: LlmClassifierOptions): IntentScorer;