agentfootprint 1.23.0 → 2.1.0

package/dist/types/index.d.ts

@@ -1,38 +1,59 @@
 /**
- * agentfootprint — The explainable agent framework.
+ * agentfootprint — public barrel.
  *
- * Core: builders, tools, providers, messages, types.
- *
- * Focused capabilities (also importable from subpaths):
- *   agentfootprint/instructions  → Conditional context injection
- *   agentfootprint/observe       → Monitor execution (recorders)
- *   agentfootprint/resilience    → Retry, fallback, circuit breaker
- *   agentfootprint/security      → Tool gating, permissions
- *   agentfootprint/explain       → Narrative, grounding analysis
- *   agentfootprint/stream        → Real-time lifecycle events
+ * Pattern: Facade (GoF) over the typed sublayers.
+ * Role:    Single entry point consumers import from.
+ * Emits:   N/A.
  */
-export { Agent, AgentRunner, LLMCall, LLMCallRunner, RAG, RAGRunner, FlowChart, FlowChartRunner, Swarm, SwarmRunner, Parallel, ParallelRunner, Conditional, ConditionalRunner, } from './concepts';
-export type { CustomRouteBranch, CustomRouteConfig, ConditionalOptions, ConditionalPredicate, } from './concepts';
-export { exportTrace } from './exportTrace';
-export type { AgentfootprintTrace, ExportTraceOptions } from './exportTrace';
-export { defineTool, askHuman, ToolRegistry } from './tools';
-export { mock, MockAdapter, mockRetriever, MockRetriever, createProvider } from './adapters';
-export { anthropic, openai, ollama, bedrock } from './models';
-export { AnthropicAdapter, OpenAIAdapter, BedrockAdapter } from './adapters';
-export { BrowserAnthropicAdapter, BrowserOpenAIAdapter } from './adapters';
-export type { ModelConfig } from './models';
-export type { PromptProvider, PromptContext, ToolProvider, ToolContext, ToolExecutionResult, AgentRecorder, } from './core';
-export type { ResponseFormat, LLMStreamChunk } from './types';
-export { systemMessage, userMessage, assistantMessage, toolResultMessage, textBlock, imageBlock, base64Image, urlImage, } from './types';
-export { LLMError } from './types';
-export type { Message, ToolCall, LLMProvider, LLMResponse, LLMCallOptions, TokenUsage, LLMToolDescription, ToolDefinition, ToolDefinitionInput, ToolHandler, ToolResult, ZodSchemaLike, AgentResult, AgentRunOptions, RunnerLike, RetrieverProvider, RetrievalChunk, RAGResult, LLMErrorCode, } from './types';
-export type { AgentStreamEvent, AgentStreamEventHandler } from './streaming';
-export { agentLoop } from './executor';
-export type { AgentLoopConfig } from './core/config';
-export { defineInstruction, AgentPattern, quickBind } from './instructions.barrel';
-export type { AgentInstruction, InstructedToolDefinition } from './instructions.barrel';
-export { defineSkill, SkillRegistry } from './skills.barrel';
-export type { Skill, SurfaceMode, SkillRegistryOptions, AutoActivateOptions, SkillListEntry, } from './skills.barrel';
-export { TokenRecorder, ToolUsageRecorder, TurnRecorder, CostRecorder, contextEngineering, agentTimeline, AgentTimelineRecorder, } from './observe.barrel';
-export type { ContextEngineeringRecorder, ContextInjectionRecord, ContextLedger, AgentEvent, AgentTurn, AgentIteration, AgentToolInvocation, AgentToolCallStub, AgentMessage, AgentContextInjection, AgentContextLedger, AgentInfo, SubAgentTimeline, Activity, StatusLine, CommentaryLine, RunSummary, IterationRange, IterationRangeIndex, ContextBySource, ContextSlotSummary, ContextSourceSummary, Humanizer, } from './observe.barrel';
+export * from './events/types.js';
+export * from './events/payloads.js';
+export { EVENT_NAMES, ALL_EVENT_TYPES, type AgentfootprintEvent, type AgentfootprintEventMap, type AgentfootprintEventType, } from './events/registry.js';
+export { EventDispatcher, type EventListener, type WildcardListener, type ListenOptions, type Unsubscribe, type DomainWildcard, type AllWildcard, type WildcardSubscription, } from './events/dispatcher.js';
+export * from './adapters/types.js';
+export { INJECTION_KEYS, injectionKeyForSlot, isInjectionKey, type InjectionKey, } from './conventions.js';
+export { COMPOSITION_KEYS, type BudgetPressureRecord, type CompositionKey, type EvictionRecord, type InjectionRecord, type SlotComposition, } from './recorders/core/types.js';
+export { buildEventMeta, parseSubflowPath, type RunContext } from './bridge/eventMeta.js';
+export { ContextRecorder, type ContextRecorderOptions } from './recorders/core/ContextRecorder.js';
+export { EmitBridge, type EmitBridgeOptions } from './recorders/core/EmitBridge.js';
+export { streamRecorder, type StreamRecorderOptions } from './recorders/core/StreamRecorder.js';
+export { agentRecorder, type AgentRecorderOptions } from './recorders/core/AgentRecorder.js';
+export { compositionRecorder, type CompositionRecorderOptions, } from './recorders/core/CompositionRecorder.js';
+export { costRecorder, type CostRecorderOptions } from './recorders/core/CostRecorder.js';
+export { permissionRecorder, type PermissionRecorderOptions, } from './recorders/core/PermissionRecorder.js';
+export { evalRecorder, type EvalRecorderOptions } from './recorders/core/EvalRecorder.js';
+export { memoryRecorder, type MemoryRecorderOptions } from './recorders/core/MemoryRecorder.js';
+export { skillRecorder, type SkillRecorderOptions } from './recorders/core/SkillRecorder.js';
+export { typedEmit } from './recorders/core/typedEmit.js';
+export type { EmittedEvent, EnableNamespace, Runner } from './core/runner.js';
+export { RunnerBase, makeRunId } from './core/RunnerBase.js';
+export { pauseHere, askHuman, isPauseRequest, isPaused, type RunnerPauseOutcome, } from './core/pause.js';
+export { attachThinking, type ThinkingEvent, type ThinkingOptions, } from './recorders/observability/ThinkingRecorder.js';
+export { attachLogging, LoggingDomains, type LoggingDomain, type LoggingLogger, type LoggingOptions, } from './recorders/observability/LoggingRecorder.js';
+export { attachFlowchart, type ContextInjection, type FlowchartHandle, type FlowchartOptions, type StepEdge, type StepGraph, type StepNode, } from './recorders/observability/FlowchartRecorder.js';
+export { BoundaryRecorder, boundaryRecorder, type ActorArrow, type BoundaryRecorderOptions, type DomainContextInjectedEvent, type DomainDecisionBranchEvent, type DomainEvent, type DomainForkBranchEvent, type DomainLLMEndEvent, type DomainLLMStartEvent, type DomainLoopIterationEvent, type DomainRunEvent, type DomainSubflowEvent, type DomainToolEndEvent, type DomainToolStartEvent, } from './recorders/observability/BoundaryRecorder.js';
+export { defaultCommentaryTemplates, selectCommentaryKey, extractCommentaryVars, renderCommentary, type CommentaryContext, type CommentaryTemplates, } from './recorders/observability/commentary/commentaryTemplates.js';
+export { defaultThinkingTemplates, selectThinkingState, renderThinkingLine, type ThinkingContext, type ThinkingState, type ThinkingStateKind, type ThinkingTemplates, } from './recorders/observability/thinking/thinkingTemplates.js';
+export { LLMCall, LLMCallBuilder, type LLMCallInput, type LLMCallOptions, type LLMCallOutput, } from './core/LLMCall.js';
+export { Agent, AgentBuilder, type AgentInput, type AgentOptions, type AgentOutput, } from './core/Agent.js';
+export type { Tool, ToolExecutionContext, ToolRegistryEntry, DefineToolOptions, } from './core/tools.js';
+export { defineTool } from './core/tools.js';
+export { Sequence, SequenceBuilder, type SequenceInput, type SequenceOptions, type SequenceOutput, } from './core-flow/Sequence.js';
+export { Parallel, ParallelBuilder, type BranchOutcome, type MergeFn, type MergeOutcomesFn, type MergeWithLLMOptions, type ParallelInput, type ParallelOptions, type ParallelOutput, } from './core-flow/Parallel.js';
+export { Conditional, ConditionalBuilder, type ConditionalInput, type ConditionalOptions, type ConditionalOutput, type Predicate, } from './core-flow/Conditional.js';
+export { Loop, LoopBuilder, type LoopInput, type LoopOptions, type LoopOutput, type UntilGuard, } from './core-flow/Loop.js';
+export { MockProvider, mock, type MockProviderOptions } from './adapters/llm/MockProvider.js';
+export { anthropic, AnthropicProvider, type AnthropicProviderOptions, } from './adapters/llm/AnthropicProvider.js';
+export { openai, OpenAIProvider, ollama, type OpenAIProviderOptions, } from './adapters/llm/OpenAIProvider.js';
+export { bedrock, BedrockProvider, type BedrockProviderOptions, } from './adapters/llm/BedrockProvider.js';
+export { browserAnthropic, BrowserAnthropicProvider, type BrowserAnthropicProviderOptions, } from './adapters/llm/BrowserAnthropicProvider.js';
+export { browserOpenai, BrowserOpenAIProvider, type BrowserOpenAIProviderOptions, } from './adapters/llm/BrowserOpenAIProvider.js';
+export { createProvider, type ProviderKind, type CreateProviderOptions, } from './adapters/llm/createProvider.js';
+export { toSSE, SSEFormatter, encodeSSE, type ToSSEOptions } from './stream.js';
+export { type Injection, type InjectionTrigger, type InjectionContent, type InjectionContext, type InjectionEvaluation, evaluateInjections, buildInjectionEngineSubflow, type InjectionEngineConfig, defineInstruction, type DefineInstructionOptions, defineSkill, type DefineSkillOptions, defineSteering, type DefineSteeringOptions, defineFact, type DefineFactOptions, } from './lib/injection-engine/index.js';
+export * from './patterns/index.js';
+export { defaultPipeline, ephemeralPipeline, factPipeline, narrativePipeline, semanticPipeline, autoPipeline, } from './memory/pipeline/index.js';
+export { heuristicExtractor, llmExtractor, } from './memory/beats/index.js';
+export { patternFactExtractor, llmFactExtractor, } from './memory/facts/index.js';
+export { defineMemory, MEMORY_TYPES, MEMORY_STRATEGIES, MEMORY_TIMING, SNAPSHOT_PROJECTIONS, type MemoryType, type MemoryStrategyKind, type MemoryTiming, type SnapshotProjection, type Strategy, type MemoryDefinition, type DefineMemoryOptions, InMemoryStore, mockEmbedder, identityNamespace, type MemoryIdentity, type Embedder, } from './memory/index.js';
+export { defineRAG, type DefineRAGOptions, indexDocuments, type IndexDocumentsOptions, type RagDocument, } from './lib/rag/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACL,KAAK,EACL,WAAW,EACX,OAAO,EACP,aAAa,EACb,GAAG,EACH,SAAS,EACT,SAAS,EACT,eAAe,EACf,KAAK,EACL,WAAW,EACX,QAAQ,EACR,cAAc,EACd,WAAW,EACX,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAG7E,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG7D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C,YAAY,EACV,cAAc,EACd,aAAa,EACb,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,aAAa,GACd,MAAM,QAAQ,CAAC;AAChB,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EACL,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,WAAW,EACX,QAAQ,GACT,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,YAAY,EACV,OAAO,EACP,QAAQ,EACR,WAAW,EACX,WAAW,EACX,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,UAAU,EACV,aAAa,EACb,WAAW,EACX,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,YAAY,GACb,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAG7E,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACnF,YAAY,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGxF,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC7D,YAAY,EACV,KAAK,EACL,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,GACf,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,0BAA0B,EAC1B,sBAAsB,EACtB,aAAa,EACb,UAAU,EACV,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,EAClB,SAAS,EACT,gBAAgB,EAChB,QAAQ,EACR,UAAU,EACV,cAAc,EACd,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,GACV,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+/**
+ * agentfootprint/injection-engine — public re-export for the InjectionEngine subsystem.
+ */
+export * from './lib/injection-engine/index.js';
+//# sourceMappingURL=injection-engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injection-engine.d.ts","sourceRoot":"","sources":["../../src/injection-engine.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iCAAiC,CAAC"}

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

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ * Emits:   `agentfootprint.context.evaluated` at exit, with
+ *          aggregate metadata. The slot subflows that follow emit
+ *          `agentfootprint.context.injected` per InjectionRecord placed.
+ *
+ * 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,
+ *         activatedInjectionIds: parent.activatedInjectionIds ?? [],
+ *       }),
+ *       outputMapper: (sf) => ({ activeInjections: sf.activeInjections }),
+ *     },
+ *   )
+ */
+import type { FlowChart } from 'footprintjs';
+import { type Injection } from './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[];
+}
+/**
+ * Build the Injection Engine subflow. One stage: `evaluate`.
+ * Pure function over the injection list + the iteration context.
+ */
+export declare function buildInjectionEngineSubflow(config: InjectionEngineConfig): FlowChart;
+//# sourceMappingURL=buildInjectionEngineSubflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildInjectionEngineSubflow.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/buildInjectionEngineSubflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,aAAa,CAAC;AAEzD,OAAO,EAA0B,KAAK,SAAS,EAAyB,MAAM,YAAY,CAAC;AAE3F,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3C;AAMD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CA8CpF"}

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

@@ -0,0 +1,25 @@
+/**
+ * Injection Engine — evaluator.
+ *
+ * Pattern: Pure function. Stateless.
+ * Role:    Internal helper. Called once per iteration by the
+ *          InjectionEngine subflow's compose stage. Slot subflows
+ *          read the `active` array and filter by their slot target.
+ * Emits:   N/A. Caller (the subflow) emits
+ *          `agentfootprint.context.evaluated`.
+ *
+ * Behavior per trigger kind:
+ *   • `always`             → always active.
+ *   • `rule`               → predicate runs against `ctx`. Errors are
+ *                            caught + reported in `skipped`; never
+ *                            propagate. Run never crashes.
+ *   • `on-tool-return`     → active when `ctx.lastToolResult.toolName`
+ *                            matches `trigger.toolName` (string equal
+ *                            or regex test).
+ *   • `llm-activated`      → active when the Injection's `id` is in
+ *                            `ctx.activatedInjectionIds` (the LLM
+ *                            previously called `viaToolName(<id>)`).
+ */
+import type { Injection, InjectionContext, InjectionEvaluation } from './types.js';
+export declare function evaluateInjections(injections: readonly Injection[], ctx: InjectionContext): InjectionEvaluation;
+//# sourceMappingURL=evaluator.d.ts.map

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

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

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

@@ -0,0 +1,52 @@
+/**
+ * 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: targets `systemPrompt` OR `messages` (consumer chooses)
+ *
+ * @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()}`,
+ *     slot: 'messages',
+ *     role: 'system',
+ *   });
+ */
+import type { ContextRole } from '../../../events/types.js';
+import type { Injection, InjectionContext } from '../types.js';
+export interface DefineFactOptions {
+    readonly id: string;
+    readonly description?: string;
+    /** The fact (data string) to inject. */
+    readonly data: string;
+    /**
+     * Which slot to land in. Default `'system-prompt'` (most common —
+     * facts the model should always have in mind).
+     * `'messages'` for facts that should appear inline with the
+     * conversation history (use sparingly — increases token cost).
+     */
+    readonly slot?: 'system-prompt' | 'messages';
+    /** When `slot: 'messages'`, the role to use. Default `'system'`. */
+    readonly role?: ContextRole;
+    /**
+     * 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;
+}
+export declare function defineFact(opts: DefineFactOptions): Injection;
+//# sourceMappingURL=defineFact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineFact.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineFact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAoB,MAAM,aAAa,CAAC;AAEjF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,UAAU,CAAC;IAC7C,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;CAC1D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,CA2B7D"}

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

@@ -0,0 +1,68 @@
+/**
+ * defineInstruction — sugar for rule-based system-prompt Injections.
+ *
+ * The most flexible Instruction-style flavor: a predicate decides
+ * activation each iteration. Use for "if condition X is true, give
+ * the LLM this guidance". Compared to:
+ *   - Steering (always-on, no predicate)
+ *   - Skill (LLM-activated via `read_skill`)
+ *   - on-tool-return (specific tool just ran — Dynamic ReAct)
+ *
+ * Produces an `Injection` with:
+ *   - flavor: `'instructions'`
+ *   - trigger: `{ kind: 'rule', activeWhen }` (or `'always'` if omitted)
+ *   - inject: `{ systemPrompt: prompt }`
+ *
+ * @example
+ *   const calmTone = defineInstruction({
+ *     id: 'calm-tone',
+ *     description: 'Use a calm, empathetic tone with frustrated users.',
+ *     activeWhen: (ctx) => /upset|angry|frustrated/.test(ctx.userMessage),
+ *     prompt: 'Acknowledge feelings before facts. Avoid corporate jargon.',
+ *   });
+ *
+ *   const piiAfterRedact = defineInstruction({
+ *     id: 'pii-after-redact',
+ *     activeWhen: (ctx) => ctx.lastToolResult?.toolName === 'redact_pii',
+ *     prompt: 'PII has been redacted. Do not include emails or phone numbers.',
+ *   });
+ */
+import type { ContextRole } from '../../../events/types.js';
+import type { Injection, InjectionContext } from '../types.js';
+export interface DefineInstructionOptions {
+    readonly id: string;
+    readonly description?: string;
+    /**
+     * Predicate to decide activation. Synchronous; side-effect free.
+     * If omitted, the instruction is always active (effectively a
+     * Steering doc, but tagged with `'instructions'` flavor for
+     * narrative semantics — use `defineSteering` for clearer intent).
+     * Predicates that throw are skipped (fail-open) and reported via
+     * `agentfootprint.context.evaluated`.
+     */
+    readonly activeWhen?: (ctx: InjectionContext) => boolean;
+    /** Instruction text. Lands in the slot specified by `slot` (default system-prompt). */
+    readonly prompt: string;
+    /**
+     * Where the instruction lands.
+     *
+     * - `'system-prompt'` (default) — appended to the system prompt.
+     *   Lower attention than recent messages but always available.
+     * - `'messages'` — appended as a recent message. **Higher attention
+     *   weight** — the LLM reads recent messages more carefully than
+     *   system-prompt text. Use this for guidance that MUST be salient
+     *   on this turn (post-tool-result reminders, urgent corrections).
+     *
+     * Same instruction object can target both slots in different agents
+     * — the trigger semantics don't change.
+     */
+    readonly slot?: 'system-prompt' | 'messages';
+    /**
+     * When `slot: 'messages'`, the role to use. Default `'system'`.
+     * `'user'` is also valid; `'assistant'` and `'tool'` work in
+     * principle but rarely make pedagogical sense.
+     */
+    readonly role?: ContextRole;
+}
+export declare function defineInstruction(opts: DefineInstructionOptions): Injection;
+//# sourceMappingURL=defineInstruction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineInstruction.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineInstruction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAoB,MAAM,aAAa,CAAC;AAEjF,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IACzD,uFAAuF;IACvF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,UAAU,CAAC;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,GAAG,SAAS,CAsB3E"}

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

@@ -0,0 +1,47 @@
+/**
+ * defineSkill — sugar for LLM-activated Injections that target both
+ * system-prompt + tools.
+ *
+ * A Skill is a bundle of (1) a body of guidance and (2) optionally
+ * unlocked tools. The LLM decides when a Skill is needed by calling
+ * a designated activation tool — by default `read_skill(<id>)`.
+ *
+ * Produces an `Injection` with:
+ *   - flavor: `'skill'`
+ *   - trigger: `{ kind: 'llm-activated', viaToolName: 'read_skill' }`
+ *   - inject: `{ systemPrompt: body, tools }`
+ *
+ * The Agent integration auto-attaches the `read_skill` tool when one
+ * or more Skills are present. When the LLM calls
+ * `read_skill('billing')`, the engine adds `'billing'` to
+ * `ctx.activatedInjectionIds`; the next iteration's evaluator
+ * matches this Skill's `id`, activates it, and the body + tools land
+ * in the slot subflows.
+ *
+ * @example
+ *   const billingSkill = defineSkill({
+ *     id: 'billing',
+ *     description: 'Use for refunds, charges, billing questions.',
+ *     body: 'When handling billing: confirm identity first, then…',
+ *     tools: [refundTool, chargeHistoryTool],
+ *   });
+ */
+import type { Injection } from '../types.js';
+import type { Tool } from '../../../core/tools.js';
+export interface DefineSkillOptions {
+    readonly id: string;
+    /** Visible to the LLM via the activation tool's description. */
+    readonly description: string;
+    /** Body appended to the system-prompt slot once activated. */
+    readonly body: string;
+    /** Optional unlocked tools, added to the tools slot once activated. */
+    readonly tools?: readonly Tool[];
+    /**
+     * Override the activation tool name. Defaults to `'read_skill'`.
+     * Multiple Skills sharing one activation tool is the common pattern;
+     * the LLM picks WHICH skill via the tool's argument.
+     */
+    readonly viaToolName?: string;
+}
+export declare function defineSkill(opts: DefineSkillOptions): Injection;
+//# sourceMappingURL=defineSkill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineSkill.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineSkill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAyB/D"}

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

@@ -0,0 +1,28 @@
+/**
+ * defineSteering — sugar for always-on system-prompt Injections.
+ *
+ * Steering docs are the simplest form of context engineering: a fixed
+ * piece of guidance the LLM should follow on every iteration. Style
+ * guides, output format rules, persona statements, safety policies.
+ *
+ * Produces an `Injection` with:
+ *   - flavor: `'steering'`
+ *   - trigger: `{ kind: 'always' }`
+ *   - inject: `{ systemPrompt: prompt }`
+ *
+ * @example
+ *   const jsonOnly = defineSteering({
+ *     id: 'json-only',
+ *     description: 'Always respond with valid JSON.',
+ *     prompt: 'Respond with JSON only. No prose. No markdown.',
+ *   });
+ */
+import type { Injection } from '../types.js';
+export interface DefineSteeringOptions {
+    readonly id: string;
+    readonly description?: string;
+    /** Always-on text appended to the system-prompt slot. */
+    readonly prompt: string;
+}
+export declare function defineSteering(opts: DefineSteeringOptions): Injection;
+//# sourceMappingURL=defineSteering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defineSteering.d.ts","sourceRoot":"","sources":["../../../../../src/lib/injection-engine/factories/defineSteering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,qBAAqB,GAAG,SAAS,CAcrE"}

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

@@ -0,0 +1,69 @@
+/**
+ * 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.
+ *
+ * ─── 7-panel design review (2026-04-28) ─────────────────────────────
+ *
+ *   LLM-AI system design   ✓ ONE primitive replaces N feature-specific
+ *                            subsystems. Skill, Steering, Instruction,
+ *                            Context (and RAG, Memory, Guardrail)
+ *                            are typed sugar producing the same shape.
+ *                            Engine is shared; observability is shared;
+ *                            Lens chips are shared.
+ *
+ *   Performance            ✓ Trigger evaluation O(N) per iteration.
+ *                            Subflow ceremony ~50µs per iteration.
+ *                            Negligible. Active set materialized once,
+ *                            consumed by 3 slot subflows.
+ *
+ *   Scalability            ✓ Adding a flavor = adding a sugar factory
+ *                            file. Zero engine change. Library scales
+ *                            to 50+ flavors without bloating the
+ *                            engine. The "narrow waist" pattern.
+ *
+ *   Research alignment     ✓ Maps to "Augmented LM" framing
+ *                            (Mialon et al. 2023): every external
+ *                            input is an augmentation; agentfootprint
+ *                            calls them Injections. Factory names
+ *                            preserve research vocabulary (Skill, RAG,
+ *                            Memory, Steering) at the API surface.
+ *
+ *   Flexibility            ✓ Discriminated `trigger` union handles
+ *                            always / rule / on-tool-return /
+ *                            llm-activated. New trigger kinds extend
+ *                            cleanly. Multi-slot per Injection covers
+ *                            Skills (system-prompt + tools).
+ *
+ *   Abstraction-modular    ✓ Engine = subflow (drill-able). Factories
+ *                            = small files (one per flavor). Slot
+ *                            subflows are unchanged consumers.
+ *                            Textbook narrow-waist architecture.
+ *
+ *   Software engineering   ✓ Predicate exceptions caught + reported
+ *                            via `skipped[]`, never propagate. Frozen
+ *                            Injections. Validation in factories.
+ *                            7-pattern test coverage. Subpath export
+ *                            for tree-shake.
+ *
+ * Plus footprintjs integration check ✓ — uses existing slot subflow
+ * convention (writes activeInjections to scope; slots filter by
+ * targeted slot) + ContextRecorder picks up source field zero-change.
+ *
+ * Plus TypeScript engineer check ✓ — discriminated union, no `any`,
+ * frozen returns, exhaustiveness check on trigger kind.
+ *
+ * ─── 7-pattern test coverage ────────────────────────────────────────
+ *
+ *   See `test/lib/injection-engine/*.test.ts`.
+ */
+export type { Injection, InjectionTrigger, InjectionContent, InjectionContext, InjectionEvaluation, } from './types.js';
+export { evaluateInjections } from './evaluator.js';
+export { buildInjectionEngineSubflow, type InjectionEngineConfig, } from './buildInjectionEngineSubflow.js';
+export { defineInstruction, type DefineInstructionOptions } from './factories/defineInstruction.js';
+export { defineSkill, type DefineSkillOptions } from './factories/defineSkill.js';
+export { defineSteering, type DefineSteeringOptions } from './factories/defineSteering.js';
+export { defineFact, type DefineFactOptions } from './factories/defineFact.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/injection-engine/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAGH,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,2BAA2B,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEpG,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAElF,OAAO,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3F,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC"}