agentfootprint 2.1.0 → 2.3.0

package/dist/types/lib/instructions/evaluator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Instruction evaluator — runs the `activeWhen` predicates and
+ * returns the active set + any skipped predicates.
+ *
+ * Pattern: Pure function. Stateless.
+ * Role:    Internal helper used by Agent during pre-LLM stage.
+ * Emits:   N/A — caller handles emit + observability.
+ */
+import type { Instruction, InstructionContext, InstructionEvaluation } from './types.js';
+export declare function evaluateInstructions(instructions: readonly Instruction[], ctx: InstructionContext): InstructionEvaluation;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/types/lib/instructions/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../src/lib/instructions/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,SAAS,WAAW,EAAE,EACpC,GAAG,EAAE,kBAAkB,GACtB,qBAAqB,CAwBvB"}

package/dist/types/lib/instructions/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Instructions — declarative rule-based system-prompt injection.
+ *
+ * Public API for the v2 Instructions subsystem. See `types.ts` for the
+ * full interface + the unified context-engineering model placement.
+ *
+ * ─── 7-panel design review (2026-04-28) ─────────────────────────────
+ *
+ *   LLM-AI system design   ✓ Maps cleanly to the unified context-
+ *                            engineering model: slot=system-prompt
+ *                            (+optional tools), role=system, timing=
+ *                            per-iteration, decision=rule.
+ *   Performance            ✓ Predicates run once per iteration (not
+ *                            per token / per event). O(N) in number
+ *                            of instructions; typical N ≤ 20.
+ *   Scalability            ✓ Stateless evaluator; many concurrent
+ *                            agents share the same instruction list
+ *                            via Object.freeze.
+ *   Research alignment     ✓ Mirrors v1 AgentInstruction's `activeWhen`
+ *                            shape (origin/main `c6e11d0`) but drops
+ *                            `onToolResult`, `safety`, decision-scope
+ *                            wrapping for v2 simplicity. Equivalent
+ *                            tool-result-driven behavior is expressed
+ *                            via `activeWhen: (ctx) =>
+ *                            ctx.lastToolResult?.toolName === 'X'`.
+ *   Flexibility            ✓ Same Instruction can be active across
+ *                            multiple iterations; can inject tools
+ *                            in addition to prompt; predicates can
+ *                            inspect history + last tool result.
+ *   Abstraction-modular    ✓ Three small files: types, builder,
+ *                            evaluator. Agent integration is one
+ *                            call into `evaluateInstructions()`.
+ *   Software engineering   ✓ Predicate errors are caught + surfaced
+ *                            (no crash). Frozen instructions prevent
+ *                            mutation. 7-pattern test coverage.
+ *
+ * ─── 7-pattern test coverage ────────────────────────────────────────
+ *
+ *   See `test/lib/instructions/*.test.ts`.
+ */
+export { defineInstruction, type DefineInstructionOptions, } from './defineInstruction.js';
+export { evaluateInstructions, } from './evaluator.js';
+export type { Instruction, InstructionContext, InstructionEvaluation, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/instructions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/types/lib/instructions/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Instructions — types.
+ *
+ * An Instruction is a declarative rule for conditional system-prompt
+ * injection. The agent evaluates each Instruction's `activeWhen`
+ * predicate at the start of every iteration; matching instructions'
+ * `prompt` text is prepended to the system prompt for that iteration.
+ *
+ * This is the rule-based flavor of the unified context-engineering
+ * model: slot=system-prompt, role=system, timing=per-iteration,
+ * decision=rule. (Compare with Skills: timing=on-activation,
+ * decision=LLM-guided.)
+ *
+ * Pattern: Strategy (GoF) — each Instruction is a strategy for
+ *          "should I add this prompt to the next iteration?"
+ * Role:    Consumer-facing shape. Agent.create(...).instruction(...).
+ * Emits:   `agentfootprint.context.injected` with source='instruction'
+ *          when an instruction activates.
+ */
+import type { Tool } from '../../core/tools.js';
+/**
+ * Read-only snapshot of the agent's state that an Instruction can
+ * inspect to decide activation. Includes only the fields a predicate
+ * can safely depend on — internal mutable state is hidden.
+ */
+export interface InstructionContext {
+    /** Current ReAct iteration (1-based). */
+    readonly iteration: number;
+    /** The current user message that started this turn. */
+    readonly userMessage: string;
+    /**
+     * Conversation history up to (but not including) the current
+     * iteration's LLM call. Includes system / user / assistant / tool
+     * messages from prior iterations of the same turn.
+     */
+    readonly history: ReadonlyArray<{
+        readonly role: 'system' | 'user' | 'assistant' | 'tool';
+        readonly content: string;
+        readonly toolName?: string;
+    }>;
+    /**
+     * The most recent tool result, if the previous iteration ended in a
+     * tool call. Undefined on the first iteration of a turn.
+     */
+    readonly lastToolResult?: {
+        readonly toolName: string;
+        readonly result: string;
+    };
+    /** Custom decision-scope state the consumer placed via Agent options. */
+    readonly decision?: Readonly<Record<string, unknown>>;
+}
+/**
+ * A single declarative instruction.
+ *
+ * @example
+ *   const calmTone = defineInstruction({
+ *     id: 'calm-tone',
+ *     description: 'Use a calm, empathetic tone after the user expresses frustration.',
+ *     activeWhen: (ctx) => ctx.userMessage.includes('frustrated')
+ *                       || ctx.userMessage.includes('angry'),
+ *     prompt: 'The user is upset. Respond calmly. Acknowledge feelings before facts.',
+ *   });
+ *
+ *   const agent = Agent.create({ provider }).instruction(calmTone).build();
+ */
+export interface Instruction {
+    /** Unique id — used for observability + de-duplication. */
+    readonly id: string;
+    /** Human-readable description (Lens / docs / debug). */
+    readonly description?: string;
+    /**
+     * Predicate to decide activation. Synchronous; side-effect free.
+     * If omitted, the instruction is always active. Predicates that
+     * throw are skipped (fail-open) and the error is surfaced via the
+     * emit channel for observability — they don't crash the run.
+     */
+    readonly activeWhen?: (ctx: InstructionContext) => boolean;
+    /** Text appended to the next iteration's system prompt when active. */
+    readonly prompt?: string;
+    /**
+     * Tools to add to the agent's tool registry when the instruction is
+     * active. Merged with the agent's base tools (later instructions win
+     * on duplicate ids). Empty by default.
+     */
+    readonly tools?: readonly Tool[];
+}
+/**
+ * @internal
+ * Branded result returned by `evaluateInstructions()`. Lets the
+ * agent's pre-LLM stage consume the projection without re-running
+ * the predicates.
+ */
+export interface InstructionEvaluation {
+    readonly active: readonly Instruction[];
+    readonly skipped: ReadonlyArray<{
+        readonly id: string;
+        readonly error: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/instructions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/instructions/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;QAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;QACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC,CAAC;IACH;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE;QACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC;IAC3D,uEAAuE;IACvE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClF"}

package/dist/types/lib/mcp/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MCP — Model Context Protocol client integration. Connect to an MCP
+ * server, register its tools on your Agent. Server-side support is
+ * separate (consumer exposes their agent as an MCP tool — different
+ * use case, not yet shipped).
+ */
+export { mcpClient } from './mcpClient.js';
+export { mockMcpClient, type MockMcpClientOptions, type MockMcpTool } from './mockMcpClient.js';
+export type { McpClient, McpClientOptions, McpHttpTransport, McpStdioTransport, McpTransport, McpSdkClient, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAChG,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/types/lib/mcp/mcpClient.d.ts

@@ -0,0 +1,47 @@
+/**
+ * mcpClient — connect to an MCP server, expose its tools to your Agent.
+ *
+ *   const slack = await mcpClient({
+ *     name: 'slack',
+ *     transport: { transport: 'stdio', command: 'npx', args: ['@example/slack-mcp'] },
+ *   });
+ *
+ *   const tools = await slack.tools();   // → readonly Tool[]
+ *   const agent = Agent.create({ ... }).tools(tools).build();
+ *
+ *   // ...
+ *
+ *   await slack.close();
+ *
+ * Pattern: Adapter (GoF) — translates MCP `listTools()` / `callTool()`
+ *          into agentfootprint's `Tool` interface (schema + execute).
+ *          Each MCP tool becomes ONE agentfootprint Tool. The agent's
+ *          existing tool-call handler invokes `client.callTool()`
+ *          inside the wrapped `execute`.
+ *
+ * Role:    Layer-3 integration. Sits next to `defineTool` — same
+ *          shape, different source. Once tools land on the agent,
+ *          the rest of the library doesn't know they came from MCP.
+ *
+ * Emits:   N/A — wrapped tools emit the standard
+ *          `agentfootprint.stream.tool_start` / `tool_end` events
+ *          when the agent calls them. Add `name: '<mcp-server>'` to
+ *          `McpClientOptions` so observability surfaces can group
+ *          tool calls by server.
+ *
+ * Lazy-require pattern: the `@modelcontextprotocol/sdk` peer-dep
+ * loads only when a consumer actually constructs a client. Tests
+ * inject `_client` and skip the import path entirely.
+ */
+import type { McpClient, McpClientOptions } from './types.js';
+/**
+ * Connect to an MCP server. Returns an `McpClient` that exposes the
+ * server's tools as agentfootprint `Tool[]` and a `close()` to tear
+ * down the transport.
+ *
+ * @throws when `@modelcontextprotocol/sdk` is not installed (see
+ *   error message for `npm install` hint), or when the transport
+ *   fails to connect.
+ */
+export declare function mcpClient(opts: McpClientOptions): Promise<McpClient>;
+//# sourceMappingURL=mcpClient.d.ts.map

package/dist/types/lib/mcp/mcpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpClient.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/mcpClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAA8B,MAAM,YAAY,CAAC;AAU1F;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAyC1E"}

package/dist/types/lib/mcp/mockMcpClient.d.ts

@@ -0,0 +1,66 @@
+/**
+ * mockMcpClient — in-memory MCP client for development and tests.
+ *
+ *   const slack = mockMcpClient({
+ *     tools: [
+ *       {
+ *         name: 'send_message',
+ *         description: 'Post a message to a channel',
+ *         inputSchema: { type: 'object' },
+ *         handler: async ({ text }) => `Posted: ${text}`,
+ *       },
+ *     ],
+ *   });
+ *
+ *   const agent = Agent.create({ provider: mock({ reply: 'ok' }) })
+ *     .tools(await slack.tools())
+ *     .build();
+ *
+ * Pattern: Adapter (GoF) — produces an `McpClient` with the same shape
+ *          as `mcpClient(opts)` but driven by an in-memory tool table
+ *          instead of the MCP SDK + transport. Drop-in for development:
+ *          start with `mockMcpClient`, swap to `mcpClient` once the
+ *          real server is ready.
+ *
+ * Why public: `mcpClient`'s `_client` injection is `@internal` because
+ * the SDK shape isn't a stable public surface. `mockMcpClient` exposes
+ * a curated tool-handler shape that's tied to OUR Tool contract instead
+ * — stable, documented, and the right level of abstraction for
+ * mock-first development.
+ */
+import type { McpClient } from './types.js';
+/** A scripted tool exposed by the mock MCP server. */
+export interface MockMcpTool {
+    /** Tool name as the LLM sees it. */
+    readonly name: string;
+    /** Description surfaced to the LLM via the tool schema. */
+    readonly description?: string;
+    /**
+     * JSON-schema-like input schema. Passed through to the agent's tool
+     * registry verbatim — same as a real MCP server's `listTools()`.
+     */
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    /**
+     * Async handler that runs when the agent calls this tool. Receives
+     * the args the LLM produced; returns the string result the agent
+     * sees as the tool-result message.
+     *
+     * Defaults to `async () => '[mock result]'` when omitted — useful
+     * when the consumer cares about wiring not behavior.
+     */
+    readonly handler?: (args: Record<string, unknown>) => Promise<string>;
+}
+export interface MockMcpClientOptions {
+    /** Logical server name. Surfaces in observability + error messages. */
+    readonly name?: string;
+    /** Tools exposed by the mock server. */
+    readonly tools: readonly MockMcpTool[];
+}
+/**
+ * Build an in-memory `McpClient`. Useful when you want to develop
+ * against MCP semantics without spawning subprocesses, hitting the
+ * network, or installing `@modelcontextprotocol/sdk`. Same `McpClient`
+ * shape as `mcpClient(opts)` — code that consumes one accepts the other.
+ */
+export declare function mockMcpClient(options: MockMcpClientOptions): McpClient;
+//# sourceMappingURL=mockMcpClient.d.ts.map

package/dist/types/lib/mcp/mockMcpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockMcpClient.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/mockMcpClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxD;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,oBAAoB;IACnC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAoCtE"}

package/dist/types/lib/mcp/types.d.ts

@@ -0,0 +1,134 @@
+/**
+ * MCP — Model Context Protocol client integration.
+ *
+ * MCP (https://modelcontextprotocol.io) is an open standard for
+ * connecting LLMs to external tools and data sources. agentfootprint's
+ * MCP adapter is **client-only** — it consumes MCP servers and exposes
+ * their tools as agentfootprint `Tool[]` so consumers can plug them
+ * straight into `agent.tool(...)`.
+ *
+ * Pattern: Adapter (GoF) — translates MCP wire format ↔ agentfootprint
+ *          `Tool` interface. The MCP SDK does the protocol work; we
+ *          just bridge.
+ * Role:    Layer-3 tool integration. Pairs with `defineTool` (the
+ *          inline alternative for non-MCP tools).
+ * Emits:   N/A directly — wrapped tools emit the standard
+ *          `agentfootprint.stream.tool_start` / `tool_end` events
+ *          when the agent calls them.
+ *
+ * Server-side support (exposing an agent or LLMCall as an MCP tool)
+ * is a separate concern not yet shipped. This module covers the
+ * 80% case: pulling an existing MCP server's tools INTO an agent.
+ */
+import type { Tool } from '../../core/tools.js';
+/**
+ * `stdio` transport — spawns a local subprocess and speaks MCP over
+ * its stdin/stdout. Best for development, single-user scenarios, and
+ * testing against locally-installed MCP servers.
+ */
+export interface McpStdioTransport {
+    readonly transport: 'stdio';
+    /** Executable to spawn (e.g., `'npx'`, `'node'`, `'python'`). */
+    readonly command: string;
+    /** CLI args passed to the executable. */
+    readonly args?: readonly string[];
+    /** Optional env vars set on the subprocess. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Working directory for the subprocess. */
+    readonly cwd?: string;
+}
+/**
+ * `http` transport — speaks MCP over Streamable HTTP. Best for remote
+ * servers, web environments, and multi-user scenarios.
+ */
+export interface McpHttpTransport {
+    readonly transport: 'http';
+    /** MCP server endpoint URL. */
+    readonly url: string;
+    /** Optional auth headers (e.g., `Authorization: Bearer ...`). */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+export type McpTransport = McpStdioTransport | McpHttpTransport;
+export interface McpClientOptions {
+    /**
+     * Logical name for observability + tool-call routing. Surfaces in
+     * Lens chips and event payloads. Defaults to `'mcp'`. Recommend
+     * setting per-server (`'slack-mcp'`, `'github-mcp'`) when you
+     * connect to multiple servers.
+     */
+    readonly name?: string;
+    /** Transport configuration — stdio or http. */
+    readonly transport: McpTransport;
+    /**
+     * Optional client identity sent on connect. Default:
+     * `{ name: 'agentfootprint', version: <package version> }`.
+     */
+    readonly clientInfo?: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /** Abort the connection / list / call paths. Honored by the SDK. */
+    readonly signal?: AbortSignal;
+    /**
+     * @internal Pre-built SDK client for tests. Skips SDK import +
+     * transport construction. Same convention as `AnthropicProvider._client`.
+     */
+    readonly _client?: McpSdkClient;
+}
+/**
+ * What `mcpClient(opts)` returns. Connect once; call `.tools()` to
+ * snapshot the tool list, `.refresh()` to re-list after the server's
+ * tools change, `.close()` when done.
+ */
+export interface McpClient {
+    /** Logical name from options (or default `'mcp'`). */
+    readonly name: string;
+    /**
+     * List the server's tools as agentfootprint `Tool[]`. First call
+     * after `mcpClient(...)` is the snapshot used to register on the
+     * agent; subsequent calls re-fetch (cheap, in-memory cached by the
+     * SDK between fetches).
+     */
+    tools(): Promise<readonly Tool[]>;
+    /**
+     * Force a refresh from the server. Use when you suspect the server
+     * has dynamically added/removed tools mid-session (e.g., after the
+     * server processes a config update).
+     */
+    refresh(): Promise<readonly Tool[]>;
+    /** Close the underlying transport. After `close()` the client is unusable. */
+    close(): Promise<void>;
+}
+/**
+ * Minimal structural type capturing the parts of the MCP SDK client
+ * we touch. Defined locally so we can:
+ *   1. Inject a mock for tests (`McpClientOptions._client`)
+ *   2. Avoid a hard import on `@modelcontextprotocol/sdk` (which is
+ *      a lazy peer-dep)
+ *
+ * The real SDK exports a richer surface; we narrow to what's needed.
+ */
+export interface McpSdkClient {
+    connect(transport: unknown): Promise<void>;
+    listTools(): Promise<{
+        readonly tools: ReadonlyArray<{
+            readonly name: string;
+            readonly description?: string;
+            readonly inputSchema: Readonly<Record<string, unknown>>;
+        }>;
+    }>;
+    callTool(args: {
+        readonly name: string;
+        readonly arguments?: Readonly<Record<string, unknown>>;
+        /** Forwarded from `McpClientOptions.signal` so consumers can cancel hung tool calls. */
+        readonly signal?: AbortSignal;
+    }): Promise<{
+        readonly content: ReadonlyArray<{
+            readonly type: string;
+            readonly text?: string;
+        }>;
+        readonly isError?: boolean;
+    }>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/mcp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAIhD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACrD;AAED,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAIhE,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IAEjC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAE1E,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAE9B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC;AAID;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,KAAK,IAAI,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAElC;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAEpC,8EAA8E;IAC9E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,SAAS,IAAI,OAAO,CAAC;QACnB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;YAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAC9B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;SACzD,CAAC,CAAC;KACJ,CAAC,CAAC;IACH,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QACvD,wFAAwF;QACxF,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;KAC/B,GAAG,OAAO,CAAC;QACV,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;YAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;SACxB,CAAC,CAAC;QACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;KAC5B,CAAC,CAAC;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/types/lib/rag/defineRAG.d.ts

@@ -29,24 +29,6 @@
  *          `agentfootprint.context.injected` when retrieved chunks
  *          land in the messages slot.
  *
- * 7-panel review (2026-04-29):
- * - LLM Systems    ✅  injects as 'user' role by default — RAG chunks
- *                      land where the LLM treats them as authoritative
- *                      retrieved context, not behavior rules
- * - Architect      ✅  composition over defineMemory; zero new engine
- *                      code; multi-RAG layering works via per-id keys
- * - API Designer   ✅  one factory, mirrors defineMemory shape; consumer
- *                      ergonomics: `agent.rag(defineRAG({...}))`
- * - Performance    ✅  embedding cost is one call per turn (TURN_START
- *                      timing, default); strict threshold prevents
- *                      injecting low-confidence noise
- * - Privacy        ✅  multi-tenant via MemoryIdentity tuple; doc
- *                      content never crosses tenant boundaries
- * - ML / IR        ✅  embedder version pinned via `embedderId`; cosine
- *                      score semantics inherited from MemoryStore
- * - SoftEng        ✅  thin file (this one); existing memory tests
- *                      cover the underlying pipeline
- *
  * @see ./indexDocuments.ts  for the seeding helper
  * @see ../../memory/define.ts  for the underlying factory
  *
@@ -119,13 +101,28 @@ export interface DefineRAGOptions {
      * Minimum cosine similarity to inject. **Strict** — when no chunk
      * meets the threshold, NO injection happens (no fallback that would
      * pollute the prompt with weak matches). Default 0.7.
+     *
+     * Tuning note: 0.7 is a high bar for some embedders. Sentence-BERT
+     * relatives (`all-MiniLM-L6-v2`, etc.) often score 0.4–0.6 even on
+     * relevant chunks. If you see frequent zero-result silent skips,
+     * lower to ~0.5 and observe the `agentfootprint.context.injected`
+     * stream. OpenAI `text-embedding-3-*` and Cohere embed-v3 typically
+     * sit comfortably with 0.7.
      */
     readonly threshold?: number;
     /**
      * Role to use when injecting retrieved chunks into the messages
-     * slot. Default `'user'` — RAG chunks are most often treated as
-     * "context the user provided" by LLMs. Use `'system'` for
-     * authoritative reference docs that should outweigh user instruction.
+     * slot. Default `'user'`.
+     *
+     * Why `'user'`: in tool-using ReAct loops, retrieved chunks
+     * conceptually "augment what the user asked." Anthropic's tool-use
+     * cookbook and OpenAI's RAG cookbook both show retrieved context
+     * inside user-turn messages.
+     *
+     * Use `'system'` for authoritative reference docs that should
+     * outweigh user instruction (policy / compliance / brand-voice
+     * corpora). Use `'assistant'` only if you've persisted prior agent
+     * turns as context — rare.
      */
     readonly asRole?: ContextRole;
 }

package/dist/types/lib/rag/defineRAG.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defineRAG.d.ts","sourceRoot":"","sources":["../../../../src/lib/rag/defineRAG.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CA8BlE"}
+{"version":3,"file":"defineRAG.d.ts","sourceRoot":"","sources":["../../../../src/lib/rag/defineRAG.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAIrE,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CA8BlE"}

package/dist/types/lib/rag/indexDocuments.d.ts

@@ -41,7 +41,20 @@ export interface IndexDocumentsOptions {
     /**
      * Identity scope to write under. Default: a single shared
      * `{ conversationId: '_global' }` namespace, suitable for app-wide
-     * corpora. Override for per-tenant document partitions.
+     * corpora.
+     *
+     * **Multi-tenant footgun:** the read side (`agent.run({ identity })`)
+     * queries within whichever identity is passed at request time.
+     * If you index here under `_global` but query under
+     * `{ tenant: 'acme' }`, you'll get ZERO results — silently. Either:
+     *   1. Index every document under each tenant's identity (duplicated
+     *      storage, but isolated), or
+     *   2. Index under `_global` AND query under `_global` (shared
+     *      corpus across tenants — fine for product docs, NOT for
+     *      tenant-private data), or
+     *   3. Use a vector store adapter that supports multi-namespace
+     *      reads at query time (Pinecone, Qdrant — outside this helper's
+     *      scope).
      */
     readonly identity?: MemoryIdentity;
     /**
@@ -67,11 +80,27 @@ export interface IndexDocumentsOptions {
      * this through to abort batch indexing on shutdown / timeout.
      */
     readonly signal?: AbortSignal;
+    /**
+     * Max number of concurrent embed calls when the embedder doesn't
+     * implement `embedBatch`. Default `8`. Without this cap, a 10K-doc
+     * corpus would fire 10K parallel embed calls and trigger rate limits.
+     * Ignored when `embedBatch` is available (the embedder controls
+     * its own batching).
+     */
+    readonly maxConcurrency?: number;
 }
 /**
  * Embed + persist documents. Returns the count actually indexed
  * (skips duplicates if the store rejects them). Throws on embedder
  * failure or store error — fail loud at startup is desirable.
+ *
+ * **Re-indexing semantics:** entries are written with `version: 1` and
+ * `putMany` (most adapters: last-write-wins). Re-running this helper
+ * after the store has been mutated by other writers may stomp their
+ * versions. For idempotent corpus refresh, either delete-then-index
+ * or use a custom upsert via `store.putIfVersion()` per document. A
+ * first-class `mode: 'upsert' | 'replace'` API is planned for a
+ * future release.
  */
 export declare function indexDocuments(store: MemoryStore, embedder: Embedder, documents: readonly RagDocument[], options?: IndexDocumentsOptions): Promise<number>;
 //# sourceMappingURL=indexDocuments.d.ts.map

package/dist/types/lib/rag/indexDocuments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexDocuments.d.ts","sourceRoot":"","sources":["../../../../src/lib/rag/indexDocuments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IAExC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAID;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,MAAM,CAAC,CAwCjB"}
+{"version":3,"file":"indexDocuments.d.ts","sourceRoot":"","sources":["../../../../src/lib/rag/indexDocuments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;IAExC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAE9B;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAID;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,MAAM,CAAC,CA6CjB"}

package/dist/types/memory/causal/loadSnapshot.d.ts

@@ -12,7 +12,7 @@
  * Strict-threshold semantics:
  *   When `minScore` is set and no past snapshot meets it, returns an
  *   empty `formatted`. NO fallback — garbage past context is worse than
- *   no context. Aligns with the LLM-systems panel verdict in the design.
+ *   no context.
  *
  * Empty-query handling:
  *   No user message → no embedding → no search → empty result.

package/dist/types/memory/conversationHelpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure functions for conversation message management.
+ * No state — just transformations on message arrays.
+ */
+import type { Message, AssistantMessage, ToolResultMessage } from '../types';
+/** Append a message to the conversation. Returns new array. */
+export declare function appendMessage(messages: Message[], message: Message): Message[];
+/** Get the last message in the conversation. */
+export declare function lastMessage(messages: Message[]): Message | undefined;
+/** Get the last assistant message. */
+export declare function lastAssistantMessage(messages: Message[]): AssistantMessage | undefined;
+/** Check if the last assistant message has tool calls. */
+export declare function lastMessageHasToolCalls(messages: Message[]): boolean;
+/** Create tool result messages from a map of tool call ID → result. */
+export declare function createToolResults(results: Array<{
+    toolCallId: string;
+    content: string;
+}>): ToolResultMessage[];
+//# sourceMappingURL=conversationHelpers.d.ts.map

package/dist/types/memory/conversationHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationHelpers.d.ts","sourceRoot":"","sources":["../../../src/memory/conversationHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7E,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAE9E;AAED,gDAAgD;AAChD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,SAAS,CAEpE;AAED,sCAAsC;AACtC,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAKtF;AAED,0DAA0D;AAC1D,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAGpE;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,KAAK,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GACtD,iBAAiB,EAAE,CAErB"}

package/dist/types/memory/define.d.ts

@@ -23,22 +23,8 @@
  *          `agentfootprint.context.injected` with `source: 'memory'`
  *          when their formatter writes to the messages slot.
  *
- * 8-panel review (2026-04-28):
- * - LLM Systems   ✅  asRole knob honored when present, defaults to 'system'
- * - Architect     ✅  per-id scope keys (`memoryInjectionKey(id)`)
- * - API Designer  ✅  one factory; CAUSAL stays here, no separate snapshotMemory
- * - Performance   ✅  default `MEMORY_TIMING.TURN_START`; pipelines compiled once
- * - Privacy       ✅  redact field passes through
- * - ML / IR       ✅  threshold maps to semantic.minScore strictly; no fallback
- * - SoftEng       ✅  unsupported combos throw with clear remediation hint
- * - TS Engineer   ✅  discriminated union narrowing preserved across switches
- *
- * Book reference: AI Agents — The Definitive Guide, Ch 10 (Memory,
- *   Autonomy, Long-Horizon Use — chapter still unavailable in pre-pub).
- *
  * @see ./define.types.ts        for the const-objects + types
  * @see ./pipeline/*.ts          for the existing pipeline factories this dispatches to
- * @see MEMORY.md                load-bearing design memory
  */
 import { type DefineMemoryOptions } from './define.types.js';
 import type { MemoryDefinition, ReadonlyMemoryFlowChart } from './define.types.js';

package/dist/types/memory/define.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../../src/memory/define.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAaH,OAAO,EAIL,KAAK,mBAAmB,EAYzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAInF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB,CAqB3E;AA6RD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,OAAO,CAErF"}
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../../src/memory/define.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAaH,OAAO,EAIL,KAAK,mBAAmB,EAYzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAInF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB,CAqB3E;AA6RD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG,OAAO,CAErF"}