memwarden 0.0.1

package/dist/cli/connect.d.ts

@@ -0,0 +1,63 @@
+export interface ConnectOptions {
+    url?: string;
+    secret?: string;
+    mcpCommand?: string;
+    mcpArgs?: string[];
+}
+/** The MCP server entry pointing at the memwarden MCP stdio adapter. */
+export declare function buildMcpServerEntry(opts?: ConnectOptions): {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+};
+interface HookCommand {
+    type: "command";
+    command: string;
+}
+interface HookGroup {
+    matcher?: string;
+    hooks: HookCommand[];
+}
+interface ClaudeSettings {
+    hooks?: Record<string, HookGroup[]>;
+    [k: string]: unknown;
+}
+/** Claude Code settings path for hooks, rooted at `dir`. */
+export declare function claudeSettingsPathFor(dir: string): string;
+/**
+ * Build the SessionStart (auto-inject) + PostToolUse (auto-capture) hook
+ * groups. `hookBase` is the shell command that runs the memwarden CLI, e.g.
+ * `"node" "/abs/dist/cli/bin.js"`; the event subcommand is appended.
+ */
+export declare function buildClaudeHooks(hookBase: string): Record<string, HookGroup[]>;
+/**
+ * Merge memwarden's hooks into an existing Claude settings object without
+ * disturbing the user's other hooks. Idempotent: prior memwarden entries
+ * for an event are replaced, not duplicated. Pure; does not mutate input.
+ */
+export declare function mergeClaudeHooks(existing: ClaudeSettings | null, hookBase: string): ClaudeSettings;
+/** Write/merge the Claude Code hooks settings file. */
+export declare function writeClaudeHooks(settingsPath: string, hookBase: string): {
+    path: string;
+    created: boolean;
+};
+type McpConfig = {
+    mcpServers?: Record<string, unknown>;
+};
+/**
+ * Merge the memwarden server into an existing MCP config without clobbering
+ * other servers. Returns a new object; does not mutate the input.
+ */
+export declare function mergeMcpConfig(existing: McpConfig | null, entry: ReturnType<typeof buildMcpServerEntry>): McpConfig;
+/**
+ * Write/merge the MCP config file at `configPath`. Returns the path and the
+ * resulting config. Creates parent directories as needed.
+ */
+export declare function writeMcpConfig(configPath: string, opts?: ConnectOptions): {
+    path: string;
+    config: McpConfig;
+    created: boolean;
+};
+/** Default MCP config path for a given target tool, rooted at `dir`. */
+export declare function mcpConfigPathFor(target: string, dir: string): string;
+export {};

package/dist/cli/connect.js

@@ -0,0 +1,121 @@
+//
+// `memwarden connect` — wires the local memwarden daemon into MCP clients so
+// every agent shares one brain. The MCP config is the stable, universal
+// unlock (same block works for Claude Code, Cursor, Claude Desktop, Cline,
+// Windsurf), so that is what this writes. Auto-capture hooks are a separate,
+// tool-specific follow-up.
+//
+// The merge logic is pure and testable; the filesystem wrapper is thin.
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+/** The MCP server entry pointing at the memwarden MCP stdio adapter. */
+export function buildMcpServerEntry(opts = {}) {
+    const env = {
+        MEMWARDEN_URL: opts.url ?? "http://localhost:3111",
+    };
+    if (opts.secret)
+        env["MEMWARDEN_SECRET"] = opts.secret;
+    return {
+        command: opts.mcpCommand ?? "npx",
+        args: opts.mcpArgs ?? ["-y", "@memwarden/mcp"],
+        env,
+    };
+}
+/** Claude Code settings path for hooks, rooted at `dir`. */
+export function claudeSettingsPathFor(dir) {
+    return join(dir, ".claude", "settings.json");
+}
+/**
+ * Build the SessionStart (auto-inject) + PostToolUse (auto-capture) hook
+ * groups. `hookBase` is the shell command that runs the memwarden CLI, e.g.
+ * `"node" "/abs/dist/cli/bin.js"`; the event subcommand is appended.
+ */
+export function buildClaudeHooks(hookBase) {
+    return {
+        SessionStart: [
+            { hooks: [{ type: "command", command: `${hookBase} hook session-start` }] },
+        ],
+        PostToolUse: [
+            { matcher: "*", hooks: [{ type: "command", command: `${hookBase} hook capture` }] },
+        ],
+    };
+}
+function isMemwardenHookGroup(g) {
+    return g.hooks.some((h) => h.command.includes("memwarden") || h.command.includes("hook session-start") || h.command.includes("hook capture"));
+}
+/**
+ * Merge memwarden's hooks into an existing Claude settings object without
+ * disturbing the user's other hooks. Idempotent: prior memwarden entries
+ * for an event are replaced, not duplicated. Pure; does not mutate input.
+ */
+export function mergeClaudeHooks(existing, hookBase) {
+    const base = existing && typeof existing === "object" ? existing : {};
+    const ours = buildClaudeHooks(hookBase);
+    const hooks = { ...(base.hooks ?? {}) };
+    for (const event of Object.keys(ours)) {
+        const kept = (hooks[event] ?? []).filter((g) => !isMemwardenHookGroup(g));
+        hooks[event] = [...kept, ...(ours[event] ?? [])];
+    }
+    return { ...base, hooks };
+}
+/** Write/merge the Claude Code hooks settings file. */
+export function writeClaudeHooks(settingsPath, hookBase) {
+    let existing = null;
+    const created = !existsSync(settingsPath);
+    if (!created) {
+        try {
+            existing = JSON.parse(readFileSync(settingsPath, "utf8"));
+        }
+        catch {
+            existing = null;
+        }
+    }
+    const merged = mergeClaudeHooks(existing, hookBase);
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    return { path: settingsPath, created };
+}
+/**
+ * Merge the memwarden server into an existing MCP config without clobbering
+ * other servers. Returns a new object; does not mutate the input.
+ */
+export function mergeMcpConfig(existing, entry) {
+    const base = existing && typeof existing === "object" ? existing : {};
+    return {
+        ...base,
+        mcpServers: { ...(base.mcpServers ?? {}), memwarden: entry },
+    };
+}
+/**
+ * Write/merge the MCP config file at `configPath`. Returns the path and the
+ * resulting config. Creates parent directories as needed.
+ */
+export function writeMcpConfig(configPath, opts = {}) {
+    let existing = null;
+    const created = !existsSync(configPath);
+    if (!created) {
+        try {
+            existing = JSON.parse(readFileSync(configPath, "utf8"));
+        }
+        catch {
+            existing = null; // corrupt/non-JSON: start fresh rather than throw
+        }
+    }
+    const merged = mergeMcpConfig(existing, buildMcpServerEntry(opts));
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    return { path: configPath, config: merged, created };
+}
+/** Default MCP config path for a given target tool, rooted at `dir`. */
+export function mcpConfigPathFor(target, dir) {
+    switch (target) {
+        case "claude-code":
+        case "cursor":
+        case "cline":
+        case "windsurf":
+            // All of these read a project-level .mcp.json.
+            return join(dir, ".mcp.json");
+        default:
+            return join(dir, ".mcp.json");
+    }
+}

package/dist/cli/hook.d.ts

@@ -0,0 +1,24 @@
+export interface HookDeps {
+    baseUrl: string;
+    secret?: string;
+    fetchFn?: typeof fetch;
+    now?: () => string;
+}
+/**
+ * SessionStart: return a Claude-Code-style context injection containing this
+ * project's recent memory. Empty string when there is nothing to inject
+ * (a brand-new project, or the daemon is down) — a hook that prints nothing
+ * is a no-op, never an error.
+ */
+export declare function handleSessionStart(raw: string, deps: HookDeps): Promise<string>;
+/**
+ * PostToolUse: forward the tool call to the daemon's observe path, and — the
+ * Déjà Fix path — if the tool's output looks like an error, ask the daemon
+ * whether any agent already solved it and inject the verified fix. Capture is
+ * best-effort and failures are swallowed so a downed daemon never breaks the
+ * agent's turn. Returns the Déjà Fix injection (or "" when there's nothing
+ * verified to surface).
+ */
+export declare function handleCapture(raw: string, deps: HookDeps): Promise<string>;
+/** Read all of stdin as a string. */
+export declare function readStdin(): Promise<string>;

package/dist/cli/hook.js

@@ -0,0 +1,186 @@
+//
+// Agent lifecycle hook handlers — the "knows before you ask" path.
+//
+// Coding agents (Claude Code, Codex, …) run hook commands and pass a JSON
+// event on stdin. memwarden wires two:
+//
+//   SessionStart -> handleSessionStart: pulls this project's recent memory
+//      from the daemon and prints it as injected context, so a freshly
+//      opened agent already knows what was done here — even by another tool.
+//   PostToolUse  -> handleCapture: forwards the tool call/result to the
+//      daemon's observe path so memory accrues with zero manual effort.
+//
+// Both are pure over their (rawStdin, deps): the daemon call is an injected
+// fetch and the clock is injected, so they unit-test without a network or a
+// live agent.
+import { isCaptureEnabled, isInjectEnabled, isProjectExcluded, } from "../functions/config.js";
+function headers(deps) {
+    const h = { "content-type": "application/json" };
+    if (deps.secret)
+        h["authorization"] = `Bearer ${deps.secret}`;
+    return h;
+}
+function parse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * SessionStart: return a Claude-Code-style context injection containing this
+ * project's recent memory. Empty string when there is nothing to inject
+ * (a brand-new project, or the daemon is down) — a hook that prints nothing
+ * is a no-op, never an error.
+ */
+export async function handleSessionStart(raw, deps) {
+    const evt = parse(raw);
+    const cwd = evt.cwd ?? process.cwd();
+    // User switches: MEMWARDEN_INJECT=off (clean-slate sessions) and the
+    // per-project exclude list both silence auto-injection entirely.
+    if (!isInjectEnabled() || isProjectExcluded(cwd))
+        return "";
+    const doFetch = deps.fetchFn ?? fetch;
+    try {
+        const res = await doFetch(`${deps.baseUrl}/memwarden/search`, {
+            method: "POST",
+            headers: headers(deps),
+            body: JSON.stringify({
+                query: "recent work and decisions in this project",
+                cwd,
+                format: "narrative",
+                limit: 20,
+                token_budget: 1500,
+                safe_only: true, // Verified Recall: SessionStart never injects stale memory
+            }),
+        });
+        if (!res.ok)
+            return "";
+        // Narrative-format /search returns the packed block under `text`.
+        const data = (await res.json());
+        const text = data.text ?? "";
+        if (!text.trim())
+            return "";
+        return JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: "SessionStart",
+                additionalContext: "Relevant memory from previous sessions in this project " +
+                    "(captured by memwarden across all your agents):\n\n" +
+                    text,
+            },
+        });
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * PostToolUse: forward the tool call to the daemon's observe path, and — the
+ * Déjà Fix path — if the tool's output looks like an error, ask the daemon
+ * whether any agent already solved it and inject the verified fix. Capture is
+ * best-effort and failures are swallowed so a downed daemon never breaks the
+ * agent's turn. Returns the Déjà Fix injection (or "" when there's nothing
+ * verified to surface).
+ */
+export async function handleCapture(raw, deps) {
+    const evt = parse(raw);
+    const cwd = evt.cwd ?? process.cwd();
+    // An excluded project never reaches the brain (no capture) AND the brain
+    // never reaches it (no Déjà Fix injection) — the exclude gates every
+    // automatic surface, not just some of them.
+    if (isProjectExcluded(cwd))
+        return "";
+    const doFetch = deps.fetchFn ?? fetch;
+    const now = deps.now ? deps.now() : new Date().toISOString();
+    if (!isCaptureEnabled()) {
+        return isInjectEnabled() ? dejaFixInjection(evt, cwd, deps, doFetch) : "";
+    }
+    try {
+        await doFetch(`${deps.baseUrl}/memwarden/observe`, {
+            method: "POST",
+            headers: headers(deps),
+            body: JSON.stringify({
+                hookType: "post_tool_use",
+                sessionId: evt.session_id ?? "hook",
+                project: cwd,
+                cwd,
+                timestamp: now,
+                data: {
+                    tool_name: evt.tool_name ?? "unknown",
+                    tool_input: evt.tool_input ?? {},
+                    tool_output: evt.tool_response ?? "",
+                },
+            }),
+        });
+    }
+    catch {
+        // swallow — capture is best-effort
+    }
+    return isInjectEnabled() ? dejaFixInjection(evt, cwd, deps, doFetch) : "";
+}
+// Cheap client-side gate: only ask the daemon for a fix when the output plausibly
+// contains an error, so a clean tool call doesn't cost a second round-trip.
+const ERROR_HINT_RE = /\b(error|errno|exception|traceback|failed|failure|panic)\b|[✕✗×]/i;
+function outputText(toolResponse) {
+    if (typeof toolResponse === "string")
+        return toolResponse;
+    if (toolResponse == null)
+        return "";
+    try {
+        return JSON.stringify(toolResponse);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * If the tool output looks like an error, look it up in Déjà Fix. Inject ONLY
+ * a "verified current" fix (every referenced file still hash-matches) — the
+ * conservative, trustworthy default; sourced-but-unverified fixes stay
+ * available via /recall and the dejafix tools but are never auto-injected.
+ */
+async function dejaFixInjection(evt, cwd, deps, doFetch) {
+    const text = outputText(evt.tool_response);
+    if (!text.trim() || !ERROR_HINT_RE.test(text))
+        return "";
+    try {
+        const res = await doFetch(`${deps.baseUrl}/memwarden/dejafix/lookup`, {
+            method: "POST",
+            headers: headers(deps),
+            body: JSON.stringify({ error_text: text, cwd }),
+        });
+        if (!res.ok)
+            return "";
+        const data = (await res.json());
+        const fix = (data.fixes ?? []).find((f) => f.status === "verified" && f.fix);
+        if (!fix || !fix.fix)
+            return "";
+        const who = fix.tool ? `by ${fix.tool}` : "earlier";
+        const when = fix.timestamp ? ` on ${fix.timestamp.slice(0, 10)}` : "";
+        const cause = fix.rootCause ? `\nRoot cause: ${fix.rootCause}` : "";
+        return JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: "PostToolUse",
+                additionalContext: `Déjà Fix (memwarden): this error was solved ${who}${when} ` +
+                    `and the fix is verified current against your working tree.${cause}\n` +
+                    `Fix: ${fix.fix}`,
+            },
+        });
+    }
+    catch {
+        return "";
+    }
+}
+/** Read all of stdin as a string. */
+export function readStdin() {
+    return new Promise((resolve) => {
+        let buf = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (c) => (buf += c));
+        process.stdin.on("end", () => resolve(buf));
+        // If nothing is piped, don't hang forever.
+        if (process.stdin.isTTY)
+            resolve("");
+    });
+}

package/dist/cli/tools.d.ts

@@ -0,0 +1,47 @@
+/** How the memwarden MCP server is launched (stdio). */
+export interface LaunchInfo {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+/** Whether memory flows automatically, and by what mechanism. */
+export type AutoMode = "hooks" | "agents-md";
+export interface ToolAdapter {
+    id: string;
+    label: string;
+    /** User-scope config file for this tool, rooted at `home`. */
+    configPath(home: string): string;
+    /** Heuristic: does this tool appear installed for this user? */
+    detect(home: string): boolean;
+    /**
+     * Merge the memwarden MCP server into the tool's existing config text
+     * (null when the file does not exist yet). Returns the new file text.
+     * Throws if `existing` is present but not parseable — the caller skips
+     * rather than clobber a config it cannot understand.
+     */
+    merge(existing: string | null, launch: LaunchInfo): string;
+    /** How recall/capture happens for this tool, for the summary + wiring. */
+    auto: AutoMode;
+}
+export declare const TOOLS: ToolAdapter[];
+export declare function toolById(id: string): ToolAdapter | undefined;
+export declare function memwardenAgentsBlock(): string;
+/** Insert/replace the memwarden block in an AGENTS.md body. Idempotent. */
+export declare function mergeAgentsMd(existing: string | null): string;
+export declare function writeAgentsMd(dir: string): {
+    path: string;
+    created: boolean;
+};
+export interface WireResult {
+    id: string;
+    label: string;
+    path: string;
+    status: "wired" | "skipped";
+    reason?: string;
+}
+/**
+ * Write/merge the memwarden MCP server into one tool's config. Safe by
+ * default: if the existing file cannot be parsed, it is left untouched and
+ * the result is reported as skipped (never clobbered).
+ */
+export declare function writeTool(adapter: ToolAdapter, home: string, launch: LaunchInfo): WireResult;

package/dist/cli/tools.js

@@ -0,0 +1,246 @@
+//
+// Tool adapter registry — the per-tool knowledge that lets `memwarden up`
+// wire one local brain into every AI coding tool. Each adapter knows that
+// tool's user-scope config file and how to merge the memwarden MCP server
+// into it in the tool's exact schema. The merges are pure string->string so
+// they are unit-testable without touching the filesystem; the thin fs
+// wrapper (writeTool) is the only side-effecting part.
+//
+// Config locations verified against each tool's 2026 docs:
+//   claude-code  ~/.claude.json                       (mcpServers)
+//   cursor       ~/.cursor/mcp.json                   (mcpServers)
+//   kiro         ~/.kiro/settings/mcp.json            (mcpServers)
+//   antigravity  ~/.gemini/config/mcp_config.json     (mcpServers; shared by IDE/CLI)
+//   opencode     ~/.config/opencode/opencode.json     (mcp -> {type,command[],environment})
+//   openclaw     ~/.openclaw/openclaw.json            (mcp.servers)
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Parse existing config, or {} when absent. Throws on present-but-corrupt. */
+function parseOrEmpty(existing) {
+    if (existing === null)
+        return {};
+    const trimmed = existing.trim();
+    if (!trimmed)
+        return {};
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object")
+        return {};
+    return parsed;
+}
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function serialize(obj) {
+    return JSON.stringify(obj, null, 2) + "\n";
+}
+// --- per-schema merges ---------------------------------------------
+/** The common `{ mcpServers: { memwarden: {command,args,env} } }` shape. */
+function mergeMcpServers(existing, launch) {
+    const base = parseOrEmpty(existing);
+    base["mcpServers"] = {
+        ...asObject(base["mcpServers"]),
+        memwarden: { command: launch.command, args: launch.args, env: launch.env },
+    };
+    return serialize(base);
+}
+/** OpenCode: `mcp` map, `type:"local"`, command is one array, `environment`. */
+function mergeOpencode(existing, launch) {
+    const base = parseOrEmpty(existing);
+    if (!base["$schema"])
+        base["$schema"] = "https://opencode.ai/config.json";
+    base["mcp"] = {
+        ...asObject(base["mcp"]),
+        memwarden: {
+            type: "local",
+            command: [launch.command, ...launch.args],
+            enabled: true,
+            environment: launch.env,
+        },
+    };
+    return serialize(base);
+}
+/** OpenClaw: servers live one level down, under `mcp.servers`. */
+function mergeOpenclaw(existing, launch) {
+    const base = parseOrEmpty(existing);
+    const mcp = asObject(base["mcp"]);
+    mcp["servers"] = {
+        ...asObject(mcp["servers"]),
+        memwarden: { command: launch.command, args: launch.args, env: launch.env },
+    };
+    base["mcp"] = mcp;
+    return serialize(base);
+}
+/**
+ * Codex uses TOML (~/.codex/config.toml), not JSON. We can't safely re-parse
+ * arbitrary TOML without a parser, so we touch only our own table: strip a
+ * prior [mcp_servers.memwarden] table (header through the line before the
+ * next table or EOF), then append a fresh one. Every other table is left
+ * byte-for-byte intact. Idempotent.
+ */
+function codexBlock(launch) {
+    const args = launch.args.map((a) => JSON.stringify(a)).join(", ");
+    const env = Object.entries(launch.env)
+        .map(([k, v]) => `${k} = ${JSON.stringify(v)}`)
+        .join(", ");
+    return ("[mcp_servers.memwarden]\n" +
+        `command = ${JSON.stringify(launch.command)}\n` +
+        `args = [${args}]\n` +
+        (env ? `env = { ${env} }\n` : ""));
+}
+function mergeCodexToml(existing, launch) {
+    const block = codexBlock(launch);
+    if (!existing || !existing.trim())
+        return block;
+    const stripped = existing
+        .replace(/\[mcp_servers\.memwarden\][\s\S]*?(?=\n\[|$)/, "")
+        .replace(/\s*$/, "");
+    return stripped ? stripped + "\n\n" + block : block;
+}
+// --- the registry --------------------------------------------------
+export const TOOLS = [
+    {
+        id: "claude-code",
+        label: "Claude Code",
+        configPath: (home) => join(home, ".claude.json"),
+        detect: (home) => existsSync(join(home, ".claude.json")) || existsSync(join(home, ".claude")),
+        merge: mergeMcpServers,
+        auto: "hooks", // also gets SessionStart/PostToolUse hooks (true auto)
+    },
+    {
+        id: "codex",
+        label: "Codex",
+        configPath: (home) => join(home, ".codex", "config.toml"),
+        detect: (home) => existsSync(join(home, ".codex")),
+        merge: mergeCodexToml,
+        auto: "agents-md",
+    },
+    {
+        id: "cursor",
+        label: "Cursor",
+        configPath: (home) => join(home, ".cursor", "mcp.json"),
+        detect: (home) => existsSync(join(home, ".cursor")),
+        merge: mergeMcpServers,
+        auto: "agents-md",
+    },
+    {
+        id: "kiro",
+        label: "Kiro",
+        configPath: (home) => join(home, ".kiro", "settings", "mcp.json"),
+        detect: (home) => existsSync(join(home, ".kiro")),
+        merge: mergeMcpServers,
+        auto: "agents-md",
+    },
+    {
+        id: "antigravity",
+        label: "Antigravity",
+        configPath: (home) => join(home, ".gemini", "config", "mcp_config.json"),
+        detect: (home) => existsSync(join(home, ".gemini")),
+        merge: mergeMcpServers,
+        auto: "agents-md",
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        configPath: (home) => join(home, ".config", "opencode", "opencode.json"),
+        detect: (home) => existsSync(join(home, ".config", "opencode")) ||
+            existsSync(join(home, ".opencode")),
+        merge: mergeOpencode,
+        auto: "agents-md",
+    },
+    {
+        id: "openclaw",
+        label: "OpenClaw",
+        configPath: (home) => join(home, ".openclaw", "openclaw.json"),
+        detect: (home) => existsSync(join(home, ".openclaw")),
+        merge: mergeOpenclaw,
+        auto: "agents-md",
+    },
+];
+export function toolById(id) {
+    return TOOLS.find((t) => t.id === id);
+}
+// --- AGENTS.md: instruction-driven auto-recall ---------------------
+//
+// Tools without a hook system (Cursor, Antigravity, OpenCode, …) can't be
+// made to auto-recall mechanically. The cross-tool lever is AGENTS.md (the
+// Linux Foundation standard read by Cursor, Gemini/Antigravity, OpenCode,
+// Codex): a project instruction telling the agent to use the memory tools at
+// task boundaries. Soft (the agent must follow it) but it is how the
+// ecosystem gets automatic behavior without hooks.
+const AGENTS_START = "<!-- memwarden:start -->";
+const AGENTS_END = "<!-- memwarden:end -->";
+export function memwardenAgentsBlock() {
+    return [
+        AGENTS_START,
+        "## Memory — always use it (memwarden)",
+        "",
+        "This project has shared, cross-tool memory (memwarden). Treat it as part of every task, automatically, without being asked:",
+        "",
+        "1. **Before starting any task**, call the `memory_resume` tool (or `/recall`) to load what past sessions — in Claude Code, Codex, Cursor, or any other tool — already learned here.",
+        "2. **Whenever you learn something durable** (a decision, a fix, how something works, a preference), call `memory_remember` to save it.",
+        "",
+        "What you save is available in every tool, so always recall first and save as you go.",
+        AGENTS_END,
+        "",
+    ].join("\n");
+}
+/** Insert/replace the memwarden block in an AGENTS.md body. Idempotent. */
+export function mergeAgentsMd(existing) {
+    const block = memwardenAgentsBlock();
+    if (!existing || !existing.trim())
+        return `# AGENTS.md\n\n${block}`;
+    const start = existing.indexOf(AGENTS_START);
+    const end = existing.indexOf(AGENTS_END);
+    if (start !== -1 && end !== -1 && end > start) {
+        return (existing.slice(0, start) +
+            block.trimEnd() +
+            existing.slice(end + AGENTS_END.length));
+    }
+    return existing.replace(/\s*$/, "") + "\n\n" + block;
+}
+export function writeAgentsMd(dir) {
+    const path = join(dir, "AGENTS.md");
+    const created = !existsSync(path);
+    const existing = created ? null : readFileSync(path, "utf8");
+    writeFileSync(path, mergeAgentsMd(existing), "utf8");
+    return { path, created };
+}
+/**
+ * Write/merge the memwarden MCP server into one tool's config. Safe by
+ * default: if the existing file cannot be parsed, it is left untouched and
+ * the result is reported as skipped (never clobbered).
+ */
+export function writeTool(adapter, home, launch) {
+    const path = adapter.configPath(home);
+    let existing = null;
+    if (existsSync(path)) {
+        try {
+            existing = readFileSync(path, "utf8");
+        }
+        catch (err) {
+            return {
+                id: adapter.id,
+                label: adapter.label,
+                path,
+                status: "skipped",
+                reason: `could not read (${err instanceof Error ? err.message : err})`,
+            };
+        }
+    }
+    let next;
+    try {
+        next = adapter.merge(existing, launch);
+    }
+    catch {
+        return {
+            id: adapter.id,
+            label: adapter.label,
+            path,
+            status: "skipped",
+            reason: "existing config is not valid JSON — left untouched",
+        };
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, next, "utf8");
+    return { id: adapter.id, label: adapter.label, path, status: "wired" };
+}