@cairnkeep/cli 2.17.3 → 2.19.0

package/omp/extensions/cairnkeep-capture.ts

@@ -0,0 +1,226 @@
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// omp port of the claude/hooks memory-capture + memory-wakeup pair (D-03/D-04,
+// OCP-01/OCP-05 contracts).
+//
+// CAPTURE: on the first `session_stop` of a main session (the event never
+// fires for task/subagent sessions and is awaited while the process is fully
+// alive), the session branch is converted to transcript text and piped to a
+// DETACHED, unref'd `node scripts/lib/omp-capture-stage.mjs` child that runs
+// the shared `extract` subcommand and stages candidates under
+// .planning/memory-staging/ — so staging survives even if the agent process
+// exits before the extraction call returns. Extraction candidates are staged
+// for review only; writes to AgentFS stay agent-gated via the memory_* tools
+// from cairnkeep-memory.ts.
+//
+// WAKEUP: on `session_start` of the main session (and only when the extension
+// runtime is initialized — omp's title-generation ephemeral agents rebind
+// extensions with uninitialized action stubs), staged candidates are surfaced
+// via a UI notification and a `deliverAs: "nextTurn"` context message injected
+// at the next real user turn. `/cairn-staged` lists staged files on demand.
+//
+// Fail-open everywhere: every guard is a cheap check and every path is
+// try/caught so a throw can never reach the extension runner.
+const CAIRN_ROOT = "@@INFRA_ROOT@@";
+const SERVER_ENTRY = join(CAIRN_ROOT, "mcp-memory-server", "dist", "index.js");
+const STAGE_ENTRY = join(CAIRN_ROOT, "scripts", "lib", "omp-capture-stage.mjs");
+
+const MAX_TEXT_CHARS = 12000;
+const STAGED_MAX_FILES = 5;
+const STAGED_FILE_READ_CAP = 8192;
+const STAGED_CUSTOM_TYPE = "sh.cairnkeep.staged-memory";
+
+// Minimal structural view of omp's persisted SessionEntry (entry.type
+// "message", camelCase role per docs/extensions.md); anything else is skipped.
+type BranchEntry = {
+    type?: string;
+    message?: {
+        role?: string;
+        content?: unknown;
+    };
+};
+
+type SessionStopLike = {
+    type: "session_stop";
+    session_id?: string;
+};
+
+function transcriptText(branch: BranchEntry[]): string {
+    const turns: string[] = [];
+    for (const entry of branch) {
+        if (entry?.type !== "message") continue;
+        const role = entry.message?.role;
+        if (role !== "user" && role !== "assistant") continue;
+        if (!Array.isArray(entry.message?.content)) continue;
+        const text = (entry.message.content as Array<{ type?: string; text?: unknown }>)
+            .filter((block) => block && block.type === "text" && typeof block.text === "string")
+            .map((block) => block.text as string)
+            .join("\n")
+            .trim();
+        if (!text) continue;
+        turns.push(`${role === "user" ? "USER" : "ASSISTANT"}: ${text}`);
+    }
+    let out = turns.join("\n\n");
+    if (out.length > MAX_TEXT_CHARS) out = out.slice(-MAX_TEXT_CHARS);
+    return out;
+}
+
+// Same detection as cairnkeep-memory.ts: omp rebinds extensions to ephemeral
+// side-turn runtimes whose action methods are uninitialized throwing stubs.
+function runtimeUninitialized(pi: ExtensionAPI): boolean {
+    try {
+        pi.getAllTools();
+        return false;
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("Extension runtime not initialized")) return true;
+        throw error;
+    }
+}
+
+type StagedCandidate = {
+    file: string;
+    count: number;
+};
+
+// Bounded staged-candidate scan: the STAGED_MAX_FILES most recent *.json
+// files, each read capped, malformed JSON skipped (fail-open).
+function stagedCandidates(repo: string): StagedCandidate[] {
+    const stagingDir = join(repo, ".planning", "memory-staging");
+    if (!existsSync(stagingDir)) return [];
+    const files = readdirSync(stagingDir)
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => ({ name, mtime: statSync(join(stagingDir, name)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, STAGED_MAX_FILES)
+        .map(({ name }) => name);
+    const staged: StagedCandidate[] = [];
+    for (const file of files) {
+        try {
+            const path = join(stagingDir, file);
+            if (statSync(path).size > STAGED_FILE_READ_CAP) continue;
+            const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+            const count = Array.isArray((parsed as { candidates?: unknown })?.candidates)
+                ? ((parsed as { candidates: unknown[] }).candidates.length)
+                : 0;
+            if (count > 0) staged.push({ file, count });
+        } catch {
+            // Malformed staged file — skip it, never wedge session start.
+        }
+    }
+    return staged;
+}
+
+export default function cairnCaptureExtension(pi: ExtensionAPI): void {
+    const capturedSessions = new Set<string>();
+
+    pi.on("session_stop", async (event: SessionStopLike, ctx: ExtensionContext) => {
+        try {
+            if (ctx.agent?.kind !== "main") return;
+            const sessionId = typeof event?.session_id === "string" ? event.session_id : "";
+            // One capture attempt per session, no matter how many times
+            // session_stop fires for it (continuation cap).
+            if (!sessionId || capturedSessions.has(sessionId)) return;
+
+            const repo = ctx.cwd;
+            // Cheap guards first, mirroring the claude hook's ordering.
+            if (!existsSync(join(repo, ".agentfs", "project.db"))) return;
+            if (!existsSync(SERVER_ENTRY)) return;
+            if (!existsSync(STAGE_ENTRY)) return;
+            const apiKey = process.env.CAIRN_LLM_API_KEY;
+            const model = process.env.CAIRN_LLM_EXTRACTION_MODEL;
+            if (!apiKey || !model) return;
+
+            // Mark before the async boundary so a re-fire never double-stages.
+            capturedSessions.add(sessionId);
+
+            let text = "";
+            try {
+                text = transcriptText(ctx.sessionManager.getBranch() as BranchEntry[]);
+            } catch {
+                return;
+            }
+            if (!text) return;
+
+            // Detached + unref'd: the staging child outlives the agent process,
+            // so the result lands even if omp exits right after settle.
+            const child = spawn(
+                process.execPath,
+                [STAGE_ENTRY, repo, SERVER_ENTRY, model],
+                { detached: true, stdio: ["pipe", "ignore", "ignore"] },
+            );
+            child.on("error", () => undefined);
+            child.stdin.on("error", () => undefined);
+            child.stdin.write(text);
+            child.stdin.end();
+            child.unref();
+        } catch {
+            // Fail open — never block session settle because capture failed.
+        }
+    });
+
+    pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+        try {
+            if (ctx.agent?.kind !== "main") return;
+            if (runtimeUninitialized(pi)) return;
+            const staged = stagedCandidates(ctx.cwd);
+            if (staged.length === 0) return;
+
+            const notice =
+                `${staged.length} memory candidate file(s) staged for review in ` +
+                `.planning/memory-staging/ (${staged.reduce((total, { count }) => total + count, 0)} candidate(s) from ` +
+                "the previous session's transcript). Review them and write accepted ones with the memory_write tool " +
+                "(agent-gated), then remove or rename the staged file. Do not write to AgentFS without that review.";
+            if (ctx.hasUI) ctx.ui.notify(notice, "info");
+            pi.sendMessage(
+                {
+                    customType: STAGED_CUSTOM_TYPE,
+                    content: notice,
+                    attribution: "agent",
+                    display: false,
+                },
+                { deliverAs: "nextTurn" },
+            );
+        } catch {
+            // Fail open — never block session start because wakeup failed.
+        }
+    });
+
+    pi.registerCommand("cairn-staged", {
+        description: "List staged memory candidates awaiting review",
+        handler: async (_args, ctx: ExtensionContext) => {
+            try {
+                const stagingDir = join(ctx.cwd, ".planning", "memory-staging");
+                if (!existsSync(stagingDir)) {
+                    if (ctx.hasUI) ctx.ui.notify("No staged memory candidates (.planning/memory-staging is absent).", "info");
+                    return;
+                }
+                const files = readdirSync(stagingDir)
+                    .filter((name) => name.endsWith(".json"))
+                    .map((name) => ({ name, mtime: statSync(join(stagingDir, name)).mtimeMs }))
+                    .sort((a, b) => b.mtime - a.mtime)
+                    .slice(0, STAGED_MAX_FILES)
+                    .map(({ name }) => name);
+                if (files.length === 0) {
+                    if (ctx.hasUI) ctx.ui.notify("No staged memory candidates.", "info");
+                    return;
+                }
+                const sections = files.map((file) => {
+                    let body: string;
+                    try {
+                        body = readFileSync(join(stagingDir, file), "utf8").slice(0, STAGED_FILE_READ_CAP);
+                    } catch {
+                        body = "(unreadable)";
+                    }
+                    return `### ${file}\n${body}`;
+                });
+                const listing = `Staged memory candidates — review, then accept via memory_write or discard.\n\n${sections.join("\n\n")}`;
+                if (ctx.hasUI) ctx.ui.notify(listing, "info");
+            } catch {
+                // Fail open — command inspection is best-effort.
+            }
+        },
+    });
+}

package/omp/extensions/cairnkeep-memory.ts

@@ -0,0 +1,288 @@
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@oh-my-pi/pi-coding-agent";
+import { spawn, type ChildProcess } from "node:child_process";
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+
+// The bridge runs as a node child process because compiled Bun standalone
+// binaries cannot resolve node_modules for runtime-imported files.
+const CAIRN_ROOT = "@@INFRA_ROOT@@";
+const CHILD_ENTRY = join(CAIRN_ROOT, "mcp-memory-server", "dist", "pi-bridge-child.js");
+
+const STARTUP_TIMEOUT_MS = 10_000;
+const CALL_TIMEOUT_MS = 30_000;
+const STDERR_LIMIT_BYTES = 16 * 1024;
+const SHUTDOWN_GRACE_MS = 3_000;
+
+type CatalogTool = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+};
+
+type ChildResult =
+    | { type: "ready" }
+    | { type: "result"; id: number; ok: true; tools?: CatalogTool[]; result?: unknown }
+    | { type: "result"; id: number; ok: false; error: string; stderr?: string };
+
+type PendingRequest = {
+    resolve: (value: unknown) => void;
+    reject: (error: Error) => void;
+    timer: ReturnType<typeof setTimeout>;
+};
+
+// Minimal line-delimited JSON client for pi-bridge-child.js: requests carry
+// an id, results route back by id, and an unexpected child exit rejects
+// everything pending with the captured stderr tail.
+class BridgeChildClient {
+    #child: ChildProcess;
+    #nextId = 1;
+    #stdoutBuffer = "";
+    #stderrTail = "";
+    #pending = new Map<number, PendingRequest>();
+    #readyPending: PendingRequest | undefined;
+    #exitPromise: Promise<void>;
+    #closed = false;
+
+    private constructor(child: ChildProcess) {
+        this.#child = child;
+        this.#exitPromise = new Promise((resolvePromise) => {
+            child.once("exit", () => resolvePromise());
+            child.once("error", () => resolvePromise());
+        });
+        child.stdout?.on("data", (chunk: Buffer | string) => this.#onStdout(chunk));
+        child.stderr?.on("data", (chunk: Buffer | string) => this.#appendStderr(chunk));
+        child.on("error", () => this.#failAll(new Error("Cairnkeep bridge child failed to start.")));
+        child.once("exit", (code, signal) => {
+            const detail = this.#stderrTail.trim();
+            const suffix = detail ? ` (child stderr: ${detail})` : "";
+            this.#failAll(new Error(`Cairnkeep bridge child exited (${signal ?? code}).${suffix}`));
+            this.#readyPending?.reject(new Error(`Cairnkeep bridge child exited before ready (${signal ?? code}).${suffix}`));
+            this.#readyPending = undefined;
+        });
+        const pidLog = process.env.CAIRN_BRIDGE_CHILD_PID_LOG;
+        if (pidLog && child.pid) appendFileSync(pidLog, `${child.pid}\n`);
+    }
+
+    static spawn(cwd: string): BridgeChildClient {
+        const child = spawn("node", [CHILD_ENTRY, cwd], { stdio: ["pipe", "pipe", "pipe"] });
+        child.stdin.on("error", () => undefined);
+        return new BridgeChildClient(child);
+    }
+
+    ready(): Promise<void> {
+        return new Promise((resolvePromise, rejectPromise) => {
+            const timer = setTimeout(() => {
+                this.#readyPending = undefined;
+                rejectPromise(new Error("Cairnkeep bridge child timed out waiting for ready."));
+            }, STARTUP_TIMEOUT_MS);
+            this.#readyPending = {
+                resolve: () => {
+                    clearTimeout(timer);
+                    resolvePromise();
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    rejectPromise(error);
+                },
+                timer,
+            };
+        });
+    }
+
+    request(message: Omit<{ type: "list" | "close" }, "id"> | { type: "call"; tool: unknown; args: Record<string, unknown> }, timeoutMs: number): Promise<unknown> {
+        const id = this.#nextId++;
+        return new Promise((resolvePromise, rejectPromise) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(id);
+                rejectPromise(new Error(`Cairnkeep bridge child request ${message.type} timed out after ${timeoutMs}ms.`));
+            }, timeoutMs);
+            this.#pending.set(id, { resolve: resolvePromise, reject: rejectPromise, timer });
+            this.#write({ ...message, id });
+        });
+    }
+
+    // One MCP tool call: 30s backstop timer plus cancellation forwarded to the
+    // child as a protocol-level cancel.
+    call(tool: unknown, args: Record<string, unknown>, signal: AbortSignal | undefined): Promise<unknown> {
+        const id = this.#nextId++;
+        return new Promise((resolvePromise, rejectPromise) => {
+            let timer: ReturnType<typeof setTimeout> | undefined;
+            const cancel = (): void => {
+                if (timer) clearTimeout(timer);
+                this.#pending.delete(id);
+                this.#write({ type: "cancel", id });
+                rejectPromise(new Error("cancelled"));
+            };
+            timer = setTimeout(() => {
+                this.#pending.delete(id);
+                this.#write({ type: "cancel", id });
+                rejectPromise(new Error(`Cairnkeep MCP call timed out after ${CALL_TIMEOUT_MS}ms.`));
+            }, CALL_TIMEOUT_MS);
+            this.#pending.set(id, { resolve: resolvePromise, reject: rejectPromise, timer });
+            if (signal) {
+                if (signal.aborted) {
+                    cancel();
+                    return;
+                }
+                signal.addEventListener("abort", cancel, { once: true });
+            }
+            this.#write({ type: "call", id, tool, args });
+        });
+    }
+
+    async close(): Promise<void> {
+        if (this.#closed) return;
+        this.#closed = true;
+        try {
+            this.#write({ type: "close" });
+        } catch {
+            // Child already gone — the exit handler rejected everything pending.
+        }
+        const grace = setTimeout(() => {
+            try {
+                this.#child.kill("SIGKILL");
+            } catch {
+                // best-effort kill only
+            }
+        }, SHUTDOWN_GRACE_MS);
+        await this.#exitPromise;
+        clearTimeout(grace);
+    }
+
+    #write(message: unknown): void {
+        this.#child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+
+    #appendStderr(chunk: Buffer | string): void {
+        const next = this.#stderrTail + (Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk);
+        this.#stderrTail = next.length <= STDERR_LIMIT_BYTES ? next : next.slice(next.length - STDERR_LIMIT_BYTES);
+    }
+
+    #onStdout(chunk: Buffer | string): void {
+        this.#stdoutBuffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+        let newline = this.#stdoutBuffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.#stdoutBuffer.slice(0, newline);
+            this.#stdoutBuffer = this.#stdoutBuffer.slice(newline + 1);
+            newline = this.#stdoutBuffer.indexOf("\n");
+            if (!line.trim()) continue;
+            let message: ChildResult;
+            try {
+                message = JSON.parse(line) as ChildResult;
+            } catch {
+                continue;
+            }
+            if (message.type === "ready") {
+                this.#readyPending?.resolve(undefined);
+                this.#readyPending = undefined;
+                continue;
+            }
+            if (message.type !== "result") continue;
+            const pending = this.#pending.get(message.id);
+            if (!pending) continue;
+            this.#pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.ok) pending.resolve(message.tools ?? message.result);
+            else {
+                const detail = typeof message.stderr === "string" && message.stderr.trim() ? ` (child stderr: ${message.stderr.trim()})` : "";
+                pending.reject(new Error(`${message.error}${detail}`));
+            }
+        }
+    }
+
+    #failAll(error: Error): void {
+        for (const pending of this.#pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.#pending.clear();
+    }
+}
+
+// AgentToolResult.content accepts text and base64 image blocks; the bridge
+// child already reduces MCP content to exactly those two shapes.
+function toAgentToolResult(result: unknown): AgentToolResult {
+    const { content, details } = result as {
+        content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+        details?: unknown;
+    };
+    return {
+        content: content.map((item) =>
+            item.type === "text"
+                ? { type: "text" as const, text: item.text ?? "" }
+                : { type: "image" as const, data: item.data ?? "", mimeType: item.mimeType ?? "" },
+        ),
+        details,
+    };
+}
+
+// omp rebinds extensions to ephemeral side-turn runtimes (e.g. title
+// generation) whose action methods are uninitialized stubs that throw; bridge
+// startup is skipped there and the real session starts it later.
+function runtimeUninitialized(pi: ExtensionAPI): boolean {
+    try {
+        pi.getAllTools();
+        return false;
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("Extension runtime not initialized")) return true;
+        throw error;
+    }
+}
+
+function existingToolNames(pi: ExtensionAPI): Set<string> {
+    return new Set(pi.getAllTools().map((tool) => tool.name));
+}
+
+export default function cairnMemoryExtension(pi: ExtensionAPI): void {
+    let client: BridgeChildClient | undefined;
+    let startPromise: Promise<void> | undefined;
+    let shutdownPromise: Promise<void> | undefined;
+
+    const start = async (ctx: ExtensionContext): Promise<void> => {
+        const connected = BridgeChildClient.spawn(ctx.cwd);
+        try {
+            await connected.ready();
+            const tools = (await connected.request({ type: "list" }, STARTUP_TIMEOUT_MS)) as CatalogTool[];
+            const existing = existingToolNames(pi);
+            const collisions = tools.map(({ name }) => name).filter((name) => existing.has(name));
+            if (collisions.length) {
+                throw new Error(`Cairnkeep MCP tool collision would override an existing omp tool: ${collisions.join(", ")}.`);
+            }
+            for (const tool of tools) {
+                pi.registerTool({
+                    name: tool.name,
+                    label: tool.title ?? tool.name,
+                    description: tool.description ?? tool.title ?? tool.name,
+                    // omp accepts a plain JSON Schema document (TJsonSchema) for
+                    // extension-authored tools; MCP inputSchema is already one.
+                    parameters: tool.inputSchema as ToolDefinition["parameters"],
+                    strict: false,
+                    execute: async (_toolCallId, args, signal) =>
+                        toAgentToolResult(await connected.call(tool, args as Record<string, unknown>, signal)),
+                });
+            }
+            client = connected;
+        } catch (error) {
+            await connected.close().catch(() => undefined);
+            throw error;
+        }
+    };
+
+    pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+        if (shutdownPromise) throw new Error("Cairnkeep MCP bridge is already shutting down.");
+        if (runtimeUninitialized(pi)) return;
+        if (!startPromise) startPromise = start(ctx);
+        await startPromise;
+    });
+
+    pi.on("session_shutdown", async () => {
+        if (!shutdownPromise) {
+            shutdownPromise = (async () => {
+                await startPromise?.catch(() => undefined);
+                await client?.close();
+            })();
+        }
+        await shutdownPromise;
+    });
+}

package/package.json

@@ -1,78 +1,79 @@
 {
-  "name": "@cairnkeep/cli",
-  "version": "2.17.3",
-  "description": "A durable, harness-agnostic memory + context layer for coding agents and MCP clients.",
-  "license": "Apache-2.0",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bin": {
-    "cairn": "bin/cairn",
-    "cairn-container": "bin/cairn-container"
-  },
-  "files": [
-    "bin/",
-    "scripts/",
-    "templates/",
-    "claude/",
-    "opencode/",
-    "pi/",
-    "kimi/",
-    "examples/anythingllm/",
-    "examples/overlay-distribution/",
-    "examples/eval/",
-    "containers/",
-    "schemas/",
-    "docs/",
-    "CHANGELOG.md",
-    "CONTRIBUTING.md",
-    "SECURITY.md",
-    "mcp-memory-server/dist/",
-    "mcp-memory-server/scripts/fixtures/compaction-*.json",
-    "mcp-memory-server/package.json",
-    "AGENTS.md"
-  ],
-  "engines": {
-    "node": ">=22"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "agentfs-sdk": "^0.6.4",
-    "yaml": "2.9.0",
-    "zod": "^4.4.3"
-  },
-  "scripts": {
-    "build:server": "npm --prefix mcp-memory-server ci --include=dev --global=false --dry-run=false && npm --prefix mcp-memory-server run build --global=false --dry-run=false",
-    "fix:perms": "node scripts/fix-permissions.mjs",
-    "prepack": "npm run build:server && npm run fix:perms",
-    "test": "node scripts/run-repository-tests.mjs",
-    "test:windows": "node scripts/test-windows-native.mjs",
-    "audit:runtime": "node scripts/verify-dependency-security.mjs && npm audit --omit=dev --audit-level=high && npm --prefix mcp-memory-server audit --omit=dev --audit-level=high",
-    "check:public": "scripts/verify-no-private-references.sh && scripts/verify-docs-parity.sh && npm run audit:runtime && npm run build:server && npm test",
-    "prepublishOnly": "npm run check:public && npm --prefix mcp-memory-server test --global=false --dry-run=false"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cairnkeep/cairnkeep.git"
-  },
-  "homepage": "https://github.com/cairnkeep/cairnkeep#readme",
-  "bugs": {
-    "url": "https://github.com/cairnkeep/cairnkeep/issues"
-  },
-  "keywords": [
-    "mcp",
-    "memory",
-    "agent",
-    "claude-code",
-    "codex-cli",
-    "opencode",
-    "qwen-code",
-    "pi-coding-agent",
-    "context",
-    "rag"
-  ],
-  "devDependencies": {
-    "@cyclonedx/cyclonedx-npm": "6.0.1"
-  }
+    "name": "@cairnkeep/cli",
+    "version": "2.19.0",
+    "description": "A durable, harness-agnostic memory + context layer for coding agents and MCP clients.",
+    "license": "Apache-2.0",
+    "type": "module",
+    "publishConfig": {
+        "access": "public"
+    },
+    "bin": {
+        "cairn": "bin/cairn",
+        "cairn-container": "bin/cairn-container"
+    },
+    "files": [
+        "bin/",
+        "scripts/",
+        "templates/",
+        "claude/",
+        "opencode/",
+        "pi/",
+        "kimi/",
+        "omp/",
+        "examples/anythingllm/",
+        "examples/overlay-distribution/",
+        "examples/eval/",
+        "containers/",
+        "schemas/",
+        "docs/",
+        "CHANGELOG.md",
+        "CONTRIBUTING.md",
+        "SECURITY.md",
+        "mcp-memory-server/dist/",
+        "mcp-memory-server/scripts/fixtures/compaction-*.json",
+        "mcp-memory-server/package.json",
+        "AGENTS.md"
+    ],
+    "engines": {
+        "node": ">=22"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.30.0",
+        "agentfs-sdk": "^0.6.4",
+        "yaml": "2.9.0",
+        "zod": "^4.4.3"
+    },
+    "scripts": {
+        "build:server": "npm --prefix mcp-memory-server ci --include=dev --global=false --dry-run=false && npm --prefix mcp-memory-server run build --global=false --dry-run=false",
+        "fix:perms": "node scripts/fix-permissions.mjs",
+        "prepack": "npm run build:server && npm run fix:perms",
+        "test": "node scripts/run-repository-tests.mjs",
+        "test:windows": "node scripts/test-windows-native.mjs",
+        "audit:runtime": "node scripts/verify-dependency-security.mjs && npm audit --omit=dev --audit-level=high && npm --prefix mcp-memory-server audit --omit=dev --audit-level=high",
+        "check:public": "scripts/verify-no-private-references.sh && scripts/verify-docs-parity.sh && npm run audit:runtime && npm run build:server && npm test",
+        "prepublishOnly": "npm run check:public && npm --prefix mcp-memory-server test --global=false --dry-run=false"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/cairnkeep/cairnkeep.git"
+    },
+    "homepage": "https://github.com/cairnkeep/cairnkeep#readme",
+    "bugs": {
+        "url": "https://github.com/cairnkeep/cairnkeep/issues"
+    },
+    "keywords": [
+        "mcp",
+        "memory",
+        "agent",
+        "claude-code",
+        "codex-cli",
+        "opencode",
+        "qwen-code",
+        "pi-coding-agent",
+        "context",
+        "rag"
+    ],
+    "devDependencies": {
+        "@cyclonedx/cyclonedx-npm": "6.0.1"
+    }
 }