@spinabot/brigade 0.1.2 → 1.0.1

package/dist/agents/memory/maintenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance.js","sourceRoot":"","sources":["../../../src/agents/memory/maintenance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAA+B,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,SAAS,EAAqB,eAAe,EAAE,MAAM,cAAc,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CACnC,YAAoB,EACpB,OAAkF,EAClF,gBAA4D;IAE5D,IAAI,CAAC;QACJ,UAAU,CAAC,YAAY,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,CAAC;QACJ,6EAA6E;QAC7E,oFAAoF;QACpF,UAAU,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,EAAE;YACvC,KAAK,EAAE,EAAE,aAAa,EAAE,MAAM,CAAC,iBAAiB,EAAE;YAClD,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC;SAC5C,CAAC,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,EAAE,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAC3B,CAAC;IACD,2FAA2F;IAC3F,4FAA4F;IAC5F,8FAA8F;IAC9F,iEAAiE;IACjE,IAAI,gBAAgB,EAAE,CAAC;QACtB,IAAI,CAAC;YACJ,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;YAClD,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;YAClD,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC3B,IAAI,GAAG;oBAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;oBAChB,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1B,CAAC;YACD,MAAM,KAAK,GAA6B,EAAE,CAAC;YAC3C,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE;gBAAE,KAAK,CAAC,IAAI,CAAC,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;YACjF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;gBAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC/C,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACd,OAAO,EAAE,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/agents/memory/memory-mcp-server.d.ts

@@ -0,0 +1,39 @@
+import type { MemoryRecordOrigin } from "./records.js";
+import type { Tideline } from "./tideline.js";
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface MemoryMcpServer {
+    /** Answer one request. Returns `null` for a notification (no reply expected). */
+    handle(req: JsonRpcRequest): JsonRpcResponse | null;
+    /** The tool count exposed (for diagnostics). */
+    toolCount: number;
+}
+export declare function createMemoryMcpServer(tide: Tideline, opts: {
+    origin: MemoryRecordOrigin;
+    serverName?: string;
+    serverVersion?: string;
+}): MemoryMcpServer;
+/**
+ * Run the server over stdio (newline-delimited JSON-RPC). Protocol I/O goes on
+ * stdout; everything else (diagnostics) MUST go to stderr so it can't corrupt
+ * the stream. Resolves when stdin closes.
+ */
+export declare function runMemoryMcpStdio(server: MemoryMcpServer, io?: {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}): Promise<void>;
+//# sourceMappingURL=memory-mcp-server.d.ts.map

package/dist/agents/memory/memory-mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-mcp-server.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/memory-mcp-server.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AACD,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC/B,iFAAiF;IACjF,MAAM,CAAC,GAAG,EAAE,cAAc,GAAG,eAAe,GAAG,IAAI,CAAC;IACpD,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/E,eAAe,CAoDjB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,eAAe,EACvB,EAAE,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,cAAc,CAAA;CAAO,GACxE,OAAO,CAAC,IAAI,CAAC,CA6Cf"}

package/dist/agents/memory/memory-mcp-server.js

@@ -0,0 +1,122 @@
+// src/agents/memory/memory-mcp-server.ts
+//
+// Tideline Step 23 — a spec-compliant MCP server over the memory tool surface.
+//
+// `createMemoryMcpServer` is the TRANSPORT-AGNOSTIC dispatch: it answers the
+// JSON-RPC 2.0 methods an MCP client speaks (initialize / tools/list /
+// tools/call / ping), backed by `memoryMcpTools` bound to a principal. Fully
+// unit-testable (feed it request objects). `runMemoryMcpStdio` is the thin
+// stdio transport shell (newline-delimited JSON-RPC on stdin/stdout) the
+// `brigade mcp` CLI runs. No external SDK — the protocol is small and Brigade
+// stays air-gap-clean.
+import * as readline from "node:readline";
+import { memoryMcpTools } from "./memory-mcp.js";
+export const MCP_PROTOCOL_VERSION = "2024-11-05";
+export function createMemoryMcpServer(tide, opts) {
+    const tools = memoryMcpTools(tide, { origin: opts.origin });
+    const byName = new Map(tools.map((t) => [t.name, t]));
+    const handle = (req) => {
+        // Validate the wire shape BEFORE reading fields: a malformed request (missing
+        // or non-string `method`) must produce a JSON-RPC error, never throw out of
+        // handle() and crash the transport.
+        const rawId = req?.id;
+        const id = typeof rawId === "string" || typeof rawId === "number" ? rawId : null;
+        const method = req?.method;
+        if (typeof method !== "string") {
+            // Had an id ⇒ addressable, reply Invalid Request; otherwise un-addressable ⇒ drop.
+            return rawId !== undefined
+                ? { jsonrpc: "2.0", id, error: { code: -32600, message: "Invalid Request: missing or invalid 'method'" } }
+                : null;
+        }
+        // A JSON-RPC notification (no `id`) or any `notifications/*` method gets no reply.
+        const isNotification = rawId === undefined || method.startsWith("notifications/");
+        const ok = (result) => (isNotification ? null : { jsonrpc: "2.0", id, result });
+        const fail = (code, message) => isNotification ? null : { jsonrpc: "2.0", id, error: { code, message } };
+        switch (method) {
+            case "initialize":
+                return ok({
+                    protocolVersion: MCP_PROTOCOL_VERSION,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: opts.serverName ?? "brigade-memory", version: opts.serverVersion ?? "1.0.0" },
+                });
+            case "notifications/initialized":
+                return null;
+            case "ping":
+                return ok({});
+            case "tools/list":
+                return ok({ tools: tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })) });
+            case "tools/call": {
+                const p = req.params;
+                const tool = p?.name ? byName.get(p.name) : undefined;
+                if (!tool)
+                    return fail(-32602, `unknown tool: ${p?.name ?? "(none)"}`);
+                try {
+                    return ok(tool.handler(p?.arguments ?? {}));
+                }
+                catch (e) {
+                    return fail(-32603, `tool error: ${e.message}`);
+                }
+            }
+            default:
+                return fail(-32601, `method not found: ${method}`);
+        }
+    };
+    return { handle, toolCount: tools.length };
+}
+/**
+ * Run the server over stdio (newline-delimited JSON-RPC). Protocol I/O goes on
+ * stdout; everything else (diagnostics) MUST go to stderr so it can't corrupt
+ * the stream. Resolves when stdin closes.
+ */
+export function runMemoryMcpStdio(server, io = {}) {
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    return new Promise((resolve) => {
+        const safeWrite = (res) => {
+            try {
+                output.write(`${JSON.stringify(res)}\n`);
+            }
+            catch {
+                // EPIPE / closed peer — the client went away; drop the reply rather
+                // than throw out of the line handler.
+            }
+        };
+        // A stdin READ error (fd error, terminal/parent disconnect) must resolve the
+        // run, not crash. readline re-emits input 'error' events onto the interface,
+        // and an interface with NO error listener throws (uncaught). So we listen on
+        // the raw input (registered BEFORE createInterface) AND on `rl` itself.
+        input.on("error", () => resolve());
+        const rl = readline.createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+        rl.on("error", () => resolve());
+        rl.on("line", (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let req;
+            try {
+                req = JSON.parse(trimmed);
+            }
+            catch {
+                // Malformed line — can't recover an id; skip (per JSON-RPC, a parse
+                // error with no id has no addressable response).
+                return;
+            }
+            // A single bad request must never crash the transport: handle() is
+            // hardened, but belt-and-suspenders the dispatch too.
+            try {
+                const res = server.handle(req);
+                if (res)
+                    safeWrite(res);
+            }
+            catch {
+                /* swallow — keep the server alive for the next line */
+            }
+        });
+        // A closed stdout surfaced as an async 'error' event (EPIPE) must not crash.
+        output.on("error", () => {
+            /* peer gone; subsequent writes are no-ops via safeWrite */
+        });
+        rl.on("close", () => resolve());
+    });
+}
+//# sourceMappingURL=memory-mcp-server.js.map

package/dist/agents/memory/memory-mcp-server.js.map

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

package/dist/agents/memory/memory-mcp.d.ts

@@ -0,0 +1,34 @@
+import { type MemoryRecordOrigin, type MemorySourceType } from "./records.js";
+import type { Tideline } from "./tideline.js";
+export interface McpToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    handler: (args: Record<string, unknown>) => McpToolResult;
+}
+export interface MemoryMcpOpts {
+    /** The connected principal — REQUIRED. Reads are scoped to it; writes are
+     *  stamped with it. Never omit (an omitted origin = whole-store leak). */
+    origin: MemoryRecordOrigin;
+    /** Trust of MCP writes. Default: owner → trusted (undefined); any other
+     *  principal → "retrieved_document" so the write-gate + recall trust engage. */
+    sourceType?: MemorySourceType;
+}
+/**
+ * The three memory tools backed by `tide`, bound to `opts.origin`. Mount on an
+ * MCP transport: list them for `tools/list`, dispatch `tools/call` to the
+ * matching tool's `handler`.
+ */
+export declare function memoryMcpTools(tide: Tideline, opts: MemoryMcpOpts): McpTool[];
+//# sourceMappingURL=memory-mcp.d.ts.map

package/dist/agents/memory/memory-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-mcp.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/memory-mcp.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAmB,KAAK,kBAAkB,EAAsB,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACnH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,OAAO;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC1F,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,aAAa,CAAC;CAC1D;AAED,MAAM,WAAW,aAAa;IAC7B;8EAC0E;IAC1E,MAAM,EAAE,kBAAkB,CAAC;IAC3B;oFACgF;IAChF,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAKD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,EAAE,CA+F7E"}

package/dist/agents/memory/memory-mcp.js

@@ -0,0 +1,130 @@
+// src/agents/memory/memory-mcp.ts
+//
+// Tideline Step 23 — the MCP tool surface for memory.
+//
+// Exposes add / search / context as MCP-style tools backed by the Tideline
+// facade. TRANSPORT-AGNOSTIC: each tool is {name, description, inputSchema,
+// handler} returning the MCP `CallToolResult` shape, so the same registry
+// mounts on any transport — the stdio MCP SDK, or Brigade's plugin HTTP —
+// without this module taking a protocol dependency.
+//
+// PRINCIPAL-BOUND (security): `memoryMcpTools` REQUIRES the connected
+// principal's `origin`. Reads are scoped to it (never the whole store — an
+// omitted origin would leak the operator's + every channel peer's facts); writes
+// are stamped with it as `createdBy`, plus a trust-appropriate `sourceType` so
+// the WRITE-GATE engages for non-owner clients (an external MCP client can't
+// poison owner-authored memory or recall at owner trust).
+//
+// DEFANG: search results are run through `sanitizeForPromptLiteral` (strips
+// control / bidi / line-separator codepoints), `<`/`>`-escaped, and wrapped in
+// an untrusted-data block, so a stored fact can't smuggle markup or instructions
+// into the consuming client's context.
+import { sanitizeForPromptLiteral, wrapUntrustedDataBlock } from "../../system-prompt/sanitize.js";
+import { MEMORY_SEGMENTS } from "./records.js";
+const text = (t, isError = false) => ({ content: [{ type: "text", text: t }], ...(isError ? { isError } : {}) });
+const escapeMarkup = (s) => s.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+/**
+ * The three memory tools backed by `tide`, bound to `opts.origin`. Mount on an
+ * MCP transport: list them for `tools/list`, dispatch `tools/call` to the
+ * matching tool's `handler`.
+ */
+export function memoryMcpTools(tide, opts) {
+    const origin = opts.origin;
+    const writeSourceType = opts.sourceType ?? (origin.kind === "owner" ? undefined : "retrieved_document");
+    const renderHits = (hits) => wrapUntrustedDataBlock({
+        label: "memory",
+        text: hits
+            .map((h) => {
+            // Recall-time content scan FIRST (mirrors tide.context() + auto-recall):
+            // a fact carrying an injection/exfil/C2 payload is surfaced as a
+            // non-actionable [BLOCKED] line, never its raw text. Markup-escape stays
+            // the always-on second layer for everything else.
+            const threats = tide.scanThreats(h.content);
+            return threats.length > 0
+                ? `- [${h.segment}] [BLOCKED] this fact matched threat pattern(s): ${threats.join(", ")} — omitted`
+                : `- [${h.segment}] ${escapeMarkup(sanitizeForPromptLiteral(h.content))}`;
+        })
+            .join("\n"),
+    });
+    return [
+        {
+            name: "memory_add",
+            description: "Store a fact in long-term memory (subject to the write-gate + your principal's trust).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    content: { type: "string", description: "the fact to remember" },
+                    segment: { type: "string", enum: [...MEMORY_SEGMENTS], description: "kind of fact (default: knowledge)" },
+                },
+                required: ["content"],
+            },
+            handler: (args) => {
+                const content = String(args.content ?? "").trim();
+                if (!content)
+                    return text("content is required", true);
+                const seg = typeof args.segment === "string" && MEMORY_SEGMENTS.includes(args.segment)
+                    ? args.segment
+                    : "knowledge";
+                try {
+                    const rec = tide.add({
+                        content,
+                        segment: seg,
+                        createdBy: origin,
+                        ...(writeSourceType ? { sourceType: writeSourceType } : {}),
+                    });
+                    return text(`stored ${rec.memoryId}`);
+                }
+                catch (e) {
+                    return text(`blocked: ${e.message}`, true);
+                }
+            },
+        },
+        {
+            name: "memory_search",
+            description: "Search YOUR long-term memory; returns ranked facts (scoped to your principal).",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" }, limit: { type: "number", description: "max results (default 8)" } },
+                required: ["query"],
+            },
+            handler: (args) => {
+                const query = String(args.query ?? "").trim();
+                if (!query)
+                    return text("query is required", true);
+                const limit = typeof args.limit === "number" && args.limit > 0 ? args.limit : 8;
+                try {
+                    const hits = tide.recall(query, { limit, markAccessed: false, origin });
+                    if (hits.length === 0)
+                        return text("(no matches)");
+                    return text(renderHits(hits));
+                }
+                catch (e) {
+                    return text(`error: ${e.message}`, true);
+                }
+            },
+        },
+        {
+            name: "memory_context",
+            description: "A budgeted memory block for a query, scoped to your principal, ready to drop into a prompt.",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" }, maxChars: { type: "number", description: "budget cap (default 1200)" } },
+                required: ["query"],
+            },
+            handler: (args) => {
+                const query = String(args.query ?? "").trim();
+                if (!query)
+                    return text("query is required", true);
+                const maxChars = typeof args.maxChars === "number" && args.maxChars > 0 ? args.maxChars : 1200;
+                try {
+                    const block = tide.context(query, { maxChars, origin });
+                    return text(block ? wrapUntrustedDataBlock({ label: "memory", text: block }) : "(nothing relevant)");
+                }
+                catch (e) {
+                    return text(`error: ${e.message}`, true);
+                }
+            },
+        },
+    ];
+}
+//# sourceMappingURL=memory-mcp.js.map

package/dist/agents/memory/memory-mcp.js.map

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

package/dist/agents/memory/plugin-runtime.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Brigade memory plugin SDK runtime — the seam between the built-in
+ * file-based memory store (FactStore + FileMemoryStore) and an out-of-tree
+ * `MemoryCapability` plugin.
+ *
+ * Goal: present Brigade's built-in memory through the SAME `MemoryCapability`
+ * shape a plugin would register, so the tool layer (`recall_memory` /
+ * `write_memory`) and the auto-recall injection don't care which is active —
+ * they call `capability.search(query)` and `capability.recordFact(content)`
+ * uniformly, and the slot resolver picks the active backend.
+ *
+ * Note on origin scoping: the public `search()` is the minimal,
+ * origin-agnostic SDK contract — it's what plugin backends implement and what
+ * origin-unaware consumers fall back to. It is NOT the origin-aware path. For
+ * the DEFAULT backend the origin-aware path is `searchRich`, which accepts a
+ * `RecordOriginFilter` so fact recall stays scoped per owner/channel; callers
+ * that need isolation must route through `searchRich` (or the rich-aware
+ * recall tool), not the plain `search()`.
+ *
+ * Selection: `extensions.slots.memory` in `brigade.json`. When unset, the
+ * default backend wins. When pinned to a registered capability id, that
+ * plugin owns memory for the turn (vector DB, knowledge graph, sqlite-fts,
+ * whatever the plugin author shipped).
+ *
+ * The default backend exports a slightly RICHER shape (`DefaultMemoryCapability`)
+ * than the SDK contract — it surfaces the underlying `FactStore` results
+ * (segment / importance / accessCount) and `FileMemoryStore` snippets
+ * (relPath / startLine / endLine) so the built-in `recall_memory` tool can
+ * render the same detailed output it has today when no plugin is pinned.
+ * Plugins implementing only the public `MemoryCapability` interface degrade
+ * gracefully to the minimal shape.
+ */
+import type { BrigadeConfig } from "../../config/io.js";
+import type { BrigadeExtensionRegistry } from "../extensions/registry.js";
+import type { MemoryCapability } from "../extensions/types.js";
+import { FactStore, type MemoryRecord, type RecordOriginFilter } from "./records.js";
+import { FileMemoryStore, type MemorySearchResult } from "./storage.js";
+/**
+ * Rich result row produced by the default file-backed backend. Plugins are
+ * not required to populate the extension fields; the recall_memory tool
+ * checks `kind` and renders accordingly. The `id`/`content`/`score`/`source`
+ * fields are the public `MemoryCapability` contract.
+ */
+export interface DefaultMemoryHit {
+    id: string;
+    content: string;
+    score: number;
+    source: "memory" | "session";
+    /** Discriminant — present only on default-backend results. */
+    kind?: "fact" | "note";
+    /** Fact-only (default backend). */
+    segment?: string;
+    importance?: number;
+    accessCount?: number;
+    /** Note-only (default backend). */
+    relPath?: string;
+    startLine?: number;
+    endLine?: number;
+    snippet?: string;
+}
+/**
+ * The default backend exposes its underlying stores so the recall_memory tool
+ * can render the rich detail (segment / importance / file:line citations) it
+ * always has, without paying for a second filesystem walk. Plugins don't
+ * implement this extended surface — they only have to satisfy
+ * `MemoryCapability` from the public SDK.
+ */
+export interface DefaultMemoryCapability extends MemoryCapability {
+    readonly id: "brigade.memory.default";
+    readonly fileStore: FileMemoryStore;
+    readonly factStore: FactStore;
+    /**
+     * Same as `search` but returns the rich rows the built-in tool renders.
+     * `origin` filters facts by `MemoryRecord.createdBy` so peer + operator
+     * state stay isolated. Notes (markdown files) are NOT origin-filtered
+     * because the underlying file store has no per-record origin concept —
+     * they're shared workspace state and have always been treated that way.
+     */
+    searchRich(query: string, opts?: {
+        limit?: number;
+        origin?: RecordOriginFilter;
+    }): Promise<{
+        notes: MemorySearchResult[];
+        facts: Array<MemoryRecord & {
+            score: number;
+        }>;
+    }>;
+}
+/**
+ * Build a `MemoryCapability` that wraps the built-in `FactStore` +
+ * `FileMemoryStore`. The result is interchangeable with a plugin-registered
+ * capability — every consumer reads memory through `capability.search` /
+ * `capability.recordFact` and never touches the stores directly.
+ *
+ * `searchRich` is the extension hook that lets the built-in recall_memory
+ * tool keep its detailed rendering when this default is active; plugins
+ * route through the minimal contract.
+ */
+export declare function createDefaultMemoryCapability(args: {
+    workspaceDir: string;
+    /**
+     * Reserved for future use — accepted so callers (e.g. `resolveActiveMemoryCapability`)
+     * can forward it without a breaking API change, but neither `FactStore` nor
+     * `FileMemoryStore` currently consume it. Wire it once the stores gain
+     * per-agent scoping (e.g. an `agentId` partition key in the JSONL schema).
+     */
+    agentId?: string;
+}): DefaultMemoryCapability;
+/**
+ * Resolve the active memory capability for a turn. When
+ * `extensions.slots.memory` pins a registered plugin id, that plugin wins;
+ * otherwise the built-in file-based default takes over. The result is the
+ * single object every memory consumer (recall tool, write tool, auto-recall)
+ * routes through — no per-call-site branching.
+ */
+export declare function resolveActiveMemoryCapability(args: {
+    config: BrigadeConfig;
+    registry: BrigadeExtensionRegistry;
+    workspaceDir: string;
+    /**
+     * Forwarded to `createDefaultMemoryCapability` unchanged. Currently unused
+     * by the stores; present so callers can pass agent context without an API
+     * change when per-agent scoping lands.
+     */
+    agentId?: string;
+}): MemoryCapability;
+/**
+ * Narrow a `MemoryCapability` to the default backend (truthy when the
+ * built-in store is active). Lets the recall_memory tool decide whether to
+ * render the rich notes+facts layout or the minimal plugin layout.
+ */
+export declare function isDefaultMemoryCapability(capability: MemoryCapability): capability is DefaultMemoryCapability;
+//# sourceMappingURL=plugin-runtime.d.ts.map

package/dist/agents/memory/plugin-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-runtime.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/plugin-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC7B,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAChE,QAAQ,CAAC,EAAE,EAAE,wBAAwB,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B;;;;;;OAMG;IACH,UAAU,CACT,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,kBAAkB,CAAA;KAAE,GACpD,OAAO,CAAC;QAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,YAAY,GAAG;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CAC5F;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,uBAAuB,CAgF1B;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IACnD,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,wBAAwB,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,gBAAgB,CAOnB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,UAAU,EAAE,gBAAgB,GAC1B,UAAU,IAAI,uBAAuB,CAEvC"}

package/dist/agents/memory/plugin-runtime.js

@@ -0,0 +1,149 @@
+/**
+ * Brigade memory plugin SDK runtime — the seam between the built-in
+ * file-based memory store (FactStore + FileMemoryStore) and an out-of-tree
+ * `MemoryCapability` plugin.
+ *
+ * Goal: present Brigade's built-in memory through the SAME `MemoryCapability`
+ * shape a plugin would register, so the tool layer (`recall_memory` /
+ * `write_memory`) and the auto-recall injection don't care which is active —
+ * they call `capability.search(query)` and `capability.recordFact(content)`
+ * uniformly, and the slot resolver picks the active backend.
+ *
+ * Note on origin scoping: the public `search()` is the minimal,
+ * origin-agnostic SDK contract — it's what plugin backends implement and what
+ * origin-unaware consumers fall back to. It is NOT the origin-aware path. For
+ * the DEFAULT backend the origin-aware path is `searchRich`, which accepts a
+ * `RecordOriginFilter` so fact recall stays scoped per owner/channel; callers
+ * that need isolation must route through `searchRich` (or the rich-aware
+ * recall tool), not the plain `search()`.
+ *
+ * Selection: `extensions.slots.memory` in `brigade.json`. When unset, the
+ * default backend wins. When pinned to a registered capability id, that
+ * plugin owns memory for the turn (vector DB, knowledge graph, sqlite-fts,
+ * whatever the plugin author shipped).
+ *
+ * The default backend exports a slightly RICHER shape (`DefaultMemoryCapability`)
+ * than the SDK contract — it surfaces the underlying `FactStore` results
+ * (segment / importance / accessCount) and `FileMemoryStore` snippets
+ * (relPath / startLine / endLine) so the built-in `recall_memory` tool can
+ * render the same detailed output it has today when no plugin is pinned.
+ * Plugins implementing only the public `MemoryCapability` interface degrade
+ * gracefully to the minimal shape.
+ */
+import { FactStore } from "./records.js";
+import { FileMemoryStore } from "./storage.js";
+/**
+ * Build a `MemoryCapability` that wraps the built-in `FactStore` +
+ * `FileMemoryStore`. The result is interchangeable with a plugin-registered
+ * capability — every consumer reads memory through `capability.search` /
+ * `capability.recordFact` and never touches the stores directly.
+ *
+ * `searchRich` is the extension hook that lets the built-in recall_memory
+ * tool keep its detailed rendering when this default is active; plugins
+ * route through the minimal contract.
+ */
+export function createDefaultMemoryCapability(args) {
+    const fileStore = new FileMemoryStore(args.workspaceDir);
+    const factStore = new FactStore(args.workspaceDir);
+    const searchRich = async (query, opts) => {
+        const limit = opts?.limit;
+        const origin = opts?.origin;
+        const notes = await fileStore.search(query, limit !== undefined ? { maxResults: limit } : {});
+        const factOpts = {};
+        if (limit !== undefined)
+            factOpts.limit = limit;
+        if (origin !== undefined)
+            factOpts.origin = origin;
+        const facts = factStore.recall(query, factOpts);
+        return { notes, facts };
+    };
+    return {
+        id: "brigade.memory.default",
+        label: "Brigade file-based memory (built-in)",
+        fileStore,
+        factStore,
+        searchRich,
+        async search(query, opts) {
+            const limit = opts?.limit;
+            const { notes, facts } = await searchRich(query, limit !== undefined ? { limit } : {});
+            const factHits = facts.map((f) => ({
+                id: f.memoryId,
+                content: f.content,
+                score: f.score,
+                source: "memory",
+                kind: "fact",
+                segment: f.segment,
+                importance: f.importance,
+                accessCount: f.accessCount,
+            }));
+            const noteHits = notes.map((n) => ({
+                id: `${n.relPath}:${n.startLine}-${n.endLine}`,
+                content: n.snippet,
+                score: n.score,
+                source: "session",
+                kind: "note",
+                relPath: n.relPath,
+                startLine: n.startLine,
+                endLine: n.endLine,
+                snippet: n.snippet,
+            }));
+            // Facts first (structured signal wins ties), then notes. The
+            // SDK contract is order-agnostic but consumers tend to render
+            // the higher-signal block first.
+            return [...factHits, ...noteHits];
+        },
+        async recordFact(content, opts) {
+            // `meta.segment` / `meta.importance` are optional plugin-supplied
+            // hints; default to a `context` fact when not provided, which is
+            // what `write_memory` falls back to for ambient observations.
+            const meta = opts?.meta ?? {};
+            const segment = meta.segment ?? "context";
+            const importanceStr = meta.importance;
+            const importance = typeof importanceStr === "string" && Number.isFinite(Number(importanceStr))
+                ? Number(importanceStr)
+                : undefined;
+            const sourceTurn = typeof meta.sourceTurn === "string" ? meta.sourceTurn : undefined;
+            const rec = factStore.write({
+                content,
+                // FactStore validates the segment against MEMORY_SEGMENTS; passing
+                // an unknown segment falls back to `context` defaults internally.
+                segment: segment,
+                ...(importance !== undefined ? { importance } : {}),
+                ...(sourceTurn ? { sourceTurn } : {}),
+            });
+            return { id: rec.memoryId };
+        },
+        async status() {
+            // Counts active facts — the field consumers (`brigade doctor`)
+            // care about most. Notes are an unbounded file tree; reporting
+            // them here would be misleading without a separate breakdown.
+            const itemCount = factStore.list({ lifecycle: "active" }).length;
+            return { ready: true, itemCount };
+        },
+    };
+}
+/**
+ * Resolve the active memory capability for a turn. When
+ * `extensions.slots.memory` pins a registered plugin id, that plugin wins;
+ * otherwise the built-in file-based default takes over. The result is the
+ * single object every memory consumer (recall tool, write tool, auto-recall)
+ * routes through — no per-call-site branching.
+ */
+export function resolveActiveMemoryCapability(args) {
+    const pinned = args.registry.resolveSlot("memory", args.config, args.registry.memoryCapabilities);
+    if (pinned)
+        return pinned;
+    return createDefaultMemoryCapability({
+        workspaceDir: args.workspaceDir,
+        ...(args.agentId ? { agentId: args.agentId } : {}),
+    });
+}
+/**
+ * Narrow a `MemoryCapability` to the default backend (truthy when the
+ * built-in store is active). Lets the recall_memory tool decide whether to
+ * render the rich notes+facts layout or the minimal plugin layout.
+ */
+export function isDefaultMemoryCapability(capability) {
+    return capability.id === "brigade.memory.default";
+}
+//# sourceMappingURL=plugin-runtime.js.map