memroot 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/index.js

@@ -1129,359 +1129,245 @@ var i = `${styleText("gray", S_BAR)}  `;
 
 // src/auth.ts
 import { spawn } from "node:child_process";
-import { createHash as createHash2, randomBytes } from "node:crypto";
-import { createServer, request as httpRequest } from "node:http";
-import { request as httpsRequest } from "node:https";
+import { createHash as createHash2, randomBytes as randomBytes3 } from "node:crypto";
+import { createServer, request as httpRequest2 } from "node:http";
+import { request as httpsRequest2 } from "node:https";
 
-// src/codex-mcp.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
+// src/capture/status.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute as isAbsolute4, join as join9 } from "node:path";
 
-// src/native.ts
+// src/credentials.ts
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { delimiter, isAbsolute, join } from "node:path";
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
-var agents = ["claude", "codex", "grok"];
-var labels = {
-  claude: "Claude Code",
-  codex: "Codex",
-  grok: "Grok"
+import {
+  chmod as chmod2,
+  lstat as lstat3,
+  readFile as readFile3,
+  rename as rename3,
+  rm as rm3,
+  writeFile as writeFile3
+} from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// src/config.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  chmod,
+  lstat as lstat2,
+  readFile as readFile2,
+  rename as rename2,
+  rm as rm2,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// src/api-base.ts
+function isLoopbackHostname(hostname) {
+  return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1" || hostname === "[::1]";
+}
+function isAllowedApiBase(value) {
+  try {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash) return false;
+    if (url.protocol === "https:") return true;
+    return url.protocol === "http:" && isLoopbackHostname(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+// src/capture/paths.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, normalize } from "node:path";
+var UnsafePathError = class extends Error {
+  constructor(code = "UNSAFE_PATH") {
+    super(`${code}: refusing an unexpected file type or symbolic link.`);
+    this.code = code;
+  }
+  code;
 };
-function executable(agent) {
-  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
-    if (!isAbsolute(directory)) continue;
-    for (const extension of [""]) {
-      const path = join(directory, agent + extension);
-      try {
-        accessSync(path, constants.X_OK);
-        if (statSync(path).isFile()) return path;
-      } catch {
-      }
+function absoluteEnv(name) {
+  const value = process.env[name];
+  if (!value) return void 0;
+  if (!isAbsolute(value))
+    throw new Error(`INVALID_STATE_DIRECTORY: ${name} must be absolute.`);
+  return normalize(value);
+}
+function stateBoundary() {
+  const explicit = absoluteEnv("MEMROOT_STATE_DIR");
+  if (explicit) return { boundary: explicit, dir: explicit };
+  const base = absoluteEnv("XDG_STATE_HOME") ?? join(homedir(), ".local", "state");
+  return { boundary: base, dir: join(base, "memroot", "capture") };
+}
+function stateDir() {
+  return stateBoundary().dir;
+}
+function memrootConfigDir() {
+  const override = process.env.MEMROOT_TEST_CONFIG_DIR;
+  if (process.env.NODE_ENV === "test" && override && isAbsolute(override))
+    return normalize(override);
+  return join(homedir(), ".memroot");
+}
+function consentPath() {
+  return join(memrootConfigDir(), "capture.json");
+}
+function assertRealDirectory(path) {
+  const info = lstatSync(path);
+  if (info.isSymbolicLink() || !info.isDirectory()) throw new UnsafePathError();
+}
+function ensurePrivateDir(path, boundary, checkRoot = false) {
+  const target = normalize(path);
+  const root = normalize(boundary);
+  if (target !== root && !target.startsWith(`${root}/`))
+    throw new UnsafePathError();
+  mkdirSync(target, { recursive: true, mode: 448 });
+  let current = target;
+  for (; ; ) {
+    if (current === root) {
+      if (checkRoot) assertRealDirectory(current);
+      break;
     }
+    assertRealDirectory(current);
+    current = dirname(current);
   }
-  return void 0;
+  const info = lstatSync(target);
+  if ((info.mode & 511) !== 448) chmodSync(target, 448);
 }
-function native(path, agent, args) {
-  const result = spawnSync(path, args, {
-    encoding: "utf8",
-    timeout: 6e4,
-    maxBuffer: 4 * 1024 * 1024,
-    shell: false
-  });
-  if (result.error || result.status !== 0) {
-    throw new Error(
-      `NATIVE_COMMAND_FAILED: ${agent} ${args.slice(0, 3).join(" ")} failed (${result.status ?? result.error?.code ?? "signal"}). Check '${agent} plugin --help', update the agent CLI, and retry. Its plugin manager may have partially registered Memroot; no success receipt was written.`
-    );
+function stateSubdir(...parts) {
+  const { boundary, dir } = stateBoundary();
+  const path = join(dir, ...parts);
+  ensurePrivateDir(path, boundary, boundary === dir);
+  return path;
+}
+function readPrivateFile(path, maxBytes = 16 * 1024 * 1024) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile()) throw new UnsafePathError();
+    if (info.size > maxBytes) throw new UnsafePathError("FILE_TOO_LARGE");
+    return readFileSync(fd, "utf8");
+  } finally {
+    closeSync(fd);
   }
-  return result.stdout;
 }
-function installCommands(agent, marketplace) {
-  if (agent === "claude")
-    return [
-      ["plugin", "marketplace", "add", marketplace, "--scope", "user"],
-      ["plugin", "install", "memroot@memroot", "--scope", "user"]
-    ];
-  if (agent === "codex")
-    return [
-      ["plugin", "marketplace", "add", marketplace, "--json"],
-      ["plugin", "add", "memroot@memroot", "--json"]
-    ];
-  return [
-    ["plugin", "install", join(marketplace, "plugins", "memroot"), "--trust"]
-  ];
+function readPrivateFileIfExists(path, maxBytes) {
+  try {
+    return readPrivateFile(path, maxBytes);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    if (error.code === "ELOOP")
+      throw new UnsafePathError();
+    throw error;
+  }
 }
-function preflight(path, agent) {
-  native(path, agent, ["plugin", "--help"]);
-  if (agent !== "grok")
-    native(path, agent, ["plugin", "marketplace", "add", "--help"]);
-  native(path, agent, [
-    "plugin",
-    agent === "codex" ? "add" : "install",
-    "--help"
-  ]);
+function writePrivateFileAtomic(path, content) {
+  const temporary = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    writeFileSync(temporary, content, { flag: "wx", mode: 384 });
+    renameSync(temporary, path);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
 }
-function rows(output, field) {
-  let value;
+function removeFile(path) {
+  rmSync(path, { force: true });
+}
+function listFiles(path) {
   try {
-    value = JSON.parse(output);
-  } catch {
-    throw new Error(
-      "NATIVE_STATUS_UNSUPPORTED: Agent plugin status is not valid JSON. Update the agent CLI and retry."
-    );
+    assertRealDirectory(path);
+    return readdirSync(path).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
   }
-  if (field)
-    value = value && typeof value === "object" ? value[field] : void 0;
-  if (!Array.isArray(value) || value.some((row) => !row || typeof row !== "object" || Array.isArray(row)))
-    throw new Error(
-      "NATIVE_STATUS_UNSUPPORTED: Unrecognized agent plugin status; refusing to change it."
-    );
-  return value;
 }
-function samePath(left, right) {
-  if (typeof left !== "string") return false;
+function pathExists(path) {
   try {
-    return realpathSync(left) === realpathSync(right);
+    lstatSync(path);
+    return true;
   } catch {
-    return left === right;
+    return false;
   }
 }
-function inspectNative(path, agent, marketplace, previousMarketplace) {
-  if (agent === "grok") {
-    const output = stripVTControlCharacters2(
-      native(path, agent, ["plugin", "list"])
-    );
-    const lines = output.split("\n").filter((line) => line.trim());
-    const empty = output.trim() === "No plugins installed. Run `grok plugin install --help` to get started.";
-    if (!empty && (!lines.length || lines.some(
-      (line) => !/^\s*\S+:\s+[^[]+\[.+\](?:\s+\(disabled\))?\s*$/.test(line)
-    ))) {
-      throw new Error(
-        "NATIVE_STATUS_UNSUPPORTED: Unrecognized Grok plugin list format. Update Grok and inspect its native plugin manager before retrying."
-      );
-    }
-    const matching = output.split("\n").filter((line) => /:\s*memroot(?:\s|$)/.test(line));
-    for (const line of matching) {
-      const source = line.match(/\[local: (.*)\]/)?.[1];
-      if (!samePath(source, join(marketplace, "plugins", "memroot")) && !(previousMarketplace && samePath(source, join(previousMarketplace, "plugins", "memroot"))))
-        throw new Error(
-          "PLUGIN_COLLISION: Grok already has a different Memroot plugin. Resolve it with the native plugin manager first."
-        );
-      if (/disabled/i.test(line))
-        throw new Error(
-          "PLUGIN_DISABLED: Memroot is disabled in Grok. Enable it in the native plugin manager when ready."
-        );
-    }
-    return {
-      registered: false,
-      currentMarketplace: false,
-      installed: matching.length > 0
-    };
-  }
-  const markets = rows(
-    native(path, agent, ["plugin", "marketplace", "list", "--json"]),
-    agent === "codex" ? "marketplaces" : void 0
-  );
-  const plugins = rows(
-    native(path, agent, ["plugin", "list", "--json"]),
-    agent === "codex" ? "installed" : void 0
-  );
-  const matchingMarkets = markets.filter((row) => row.name === "memroot");
-  if (matchingMarkets.length > 1)
+
+// src/storage.ts
+import { createHash, randomUUID } from "node:crypto";
+import {
+  cp,
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var version = "0.1.0-alpha.3";
+function dataDirectory() {
+  const base = process.platform === "win32" ? process.env.LOCALAPPDATA ?? join2(homedir2(), "AppData", "Local") : process.env.XDG_DATA_HOME ?? join2(homedir2(), ".local", "share");
+  if (!isAbsolute2(base))
     throw new Error(
-      "MARKETPLACE_COLLISION: Multiple Memroot marketplaces were reported; refusing to change them."
+      "INVALID_DATA_DIRECTORY: XDG_DATA_HOME or LOCALAPPDATA must be absolute."
     );
-  for (const market of matchingMarkets) {
-    const source = agent === "codex" ? market.root : market.path;
-    if (!samePath(source, marketplace) && !(previousMarketplace && samePath(source, previousMarketplace)))
-      throw new Error(
-        "MARKETPLACE_COLLISION: memroot is already registered from a different source. Resolve it with the native plugin manager first."
-      );
+  return join2(base, "memroot");
+}
+async function exists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
   }
-  const matchingPlugins = plugins.filter(
-    (row) => row.id === "memroot@memroot" || row.pluginId === "memroot@memroot" || row.name === "memroot"
-  );
-  if (matchingPlugins.length && !matchingMarkets.length)
+}
+async function safeDirectory(path) {
+  const boundary = dataDirectory();
+  if (path !== boundary && path.startsWith(`${boundary}/`))
+    await safeDirectory(dirname2(path));
+  await mkdir(path, { recursive: true, mode: 448 });
+  const info = await lstat(path);
+  if (!info.isDirectory() || info.isSymbolicLink())
+    throw new Error(`UNSAFE_PATH: Expected a real directory at ${path}.`);
+}
+async function fileEntries(root, prefix = "") {
+  const directory = await lstat(join2(root, prefix));
+  if (!directory.isDirectory() || directory.isSymbolicLink())
     throw new Error(
-      "PLUGIN_COLLISION: An existing Memroot plugin has no matching managed marketplace. Resolve it with the native plugin manager first."
+      "INTEGRITY_ERROR: Managed plugin directory is not a real directory."
     );
-  for (const plugin of matchingPlugins) {
-    if (plugin.enabled === false)
-      throw new Error(
-        `PLUGIN_DISABLED: Memroot is disabled in ${labels[agent]}. Enable it in the native plugin manager when ready; setup preserves your choice.`
-      );
-    if (plugin.enabled !== true || agent === "claude" && plugin.scope !== "user")
+  const result = [];
+  for (const name of (await readdir(join2(root, prefix))).sort()) {
+    const path = join2(root, prefix, name);
+    const info = await lstat(path);
+    const key = join2(prefix, name);
+    if (info.isSymbolicLink())
       throw new Error(
-        "PLUGIN_COLLISION: Existing Memroot plugin status or scope cannot be safely managed. Check the native plugin manager."
+        "INTEGRITY_ERROR: Plugin assets must not contain symbolic links."
       );
+    if (info.isDirectory()) result.push(...await fileEntries(root, key));
+    else if (info.isFile()) result.push([key, await readFile(path)]);
+    else throw new Error("INTEGRITY_ERROR: Unsupported plugin asset.");
   }
-  const currentMarketplace = matchingMarkets.some(
-    (market) => samePath(agent === "codex" ? market.root : market.path, marketplace)
-  );
-  if (agent === "codex" && matchingMarkets.length > 0 && !currentMarketplace && plugins.some(
-    (plugin) => plugin.marketplaceName === "memroot" && plugin.pluginId !== "memroot@memroot"
-  ))
-    throw new Error(
-      "MARKETPLACE_COLLISION: The previous Memroot marketplace contains another installed plugin; refusing to remove it."
-    );
-  return {
-    registered: matchingMarkets.length > 0,
-    currentMarketplace,
-    installed: matchingPlugins.length > 0
-  };
-}
-
-// src/codex-mcp.ts
-var codexMcpUrl = "https://api.memroot.dev/mcp";
-function command(path, args, interactive = false) {
-  const result = spawnSync2(path, ["mcp", ...args], {
-    shell: false,
-    encoding: "utf8",
-    timeout: interactive ? 3e5 : 3e4,
-    maxBuffer: 1024 * 1024,
-    // Let Codex present browser authentication directly; never capture credentials.
-    stdio: interactive ? "inherit" : "pipe"
-  });
-  if (result.error || result.status !== 0)
-    throw new Error(
-      "MCP_COMMAND_FAILED: Codex MCP command did not complete. Your configuration is preserved; retry memroot setup --agent codex --yes."
-    );
-  return result.stdout ?? "";
-}
-function inspectCodexMcp(path) {
-  let rows2;
-  try {
-    rows2 = JSON.parse(command(path, ["list", "--json"]));
-  } catch {
-    throw new Error(
-      "MCP_STATUS_UNAVAILABLE: Cannot inspect Codex MCP state. Retry later; no new authorization was requested."
-    );
-  }
-  if (!Array.isArray(rows2) || rows2.some((row2) => !row2 || typeof row2 !== "object"))
-    throw new Error(
-      "MCP_STATUS_UNAVAILABLE: Unsupported Codex MCP status format."
-    );
-  const matching = rows2.filter((row2) => row2.name === "memroot");
-  if (!matching.length)
-    return { configured: false, authorized: false, verified: false };
-  const row = matching[0];
-  if (matching.length !== 1 || row.enabled !== true || row.transport?.type !== "streamable_http" || row.transport?.url !== codexMcpUrl || row.transport?.bearer_token_env_var || row.transport?.http_headers || row.transport?.env_http_headers || row.transport?.http_headers_helper)
-    throw new Error(
-      "MCP_CONFLICT: Existing memroot MCP configuration differs from production OAuth or is disabled. Inspect it in Codex; setup preserves your settings."
-    );
-  if (row.auth_status !== "oauth" && row.auth_status !== "not_logged_in")
-    throw new Error(
-      "MCP_AUTH_UNKNOWN: Codex could not establish OAuth status. Resolve it in Codex before retrying; no replacement grant was requested."
-    );
-  return {
-    configured: true,
-    authorized: row.auth_status === "oauth",
-    verified: false
-  };
-}
-function codexMcpPreflight(path) {
-  for (const [args, flags] of [
-    [["list", "--help"], ["--json"]],
-    [
-      ["add", "--help"],
-      ["--url", "--oauth-resource"]
-    ],
-    [["login", "--help"], []]
-  ]) {
-    const help2 = command(path, [...args]);
-    if (flags.some((flag) => !help2.includes(flag)))
-      throw new Error(
-        "MCP_UNSUPPORTED: Update Codex to a version supporting native remote OAuth MCP setup."
-      );
-  }
-}
-async function ensureCodexMcp(options) {
-  if (options.dryRun)
-    return { configured: false, authorized: false, verified: false };
-  const path = executable("codex");
-  if (!path)
-    throw new Error("AGENT_NOT_FOUND: Install Codex before linking Memroot.");
-  codexMcpPreflight(path);
-  let state = inspectCodexMcp(path);
-  if (!state.configured) {
-    command(
-      path,
-      ["add", "memroot", "--url", codexMcpUrl, "--oauth-resource", codexMcpUrl],
-      true
-    );
-    state = inspectCodexMcp(path);
-    if (!state.authorized)
-      throw new Error(
-        "MCP_AUTH_PENDING: Codex MCP is configured; authorization has not completed. Retry setup to resume."
-      );
-  } else if (!state.authorized) {
-    command(path, ["login", "memroot"], true);
-    state = inspectCodexMcp(path);
-  }
-  if (!state.authorized)
-    throw new Error(
-      "MCP_AUTH_PENDING: Codex has not confirmed OAuth authorization."
-    );
-  return state;
-}
-function describeCodexMcp(state) {
-  return `Codex MCP: ${state.configured ? "configured" : "not configured"}; OAuth: ${state.authorized ? "authorized" : "not authorized"}; memory verification: not verified. Ask Codex to call connection_status, then save and retrieve a test memory.`;
-}
-
-// src/config.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import {
-  chmod,
-  lstat as lstat2,
-  readFile as readFile2,
-  rename as rename2,
-  rm as rm2,
-  writeFile as writeFile2
-} from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
-
-// src/storage.ts
-import { createHash, randomUUID } from "node:crypto";
-import {
-  cp,
-  lstat,
-  mkdir,
-  readdir,
-  readFile,
-  rename,
-  rm,
-  writeFile
-} from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
-var version = "0.1.0-alpha.1";
-function dataDirectory() {
-  const base = process.platform === "win32" ? process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local") : process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share");
-  if (!isAbsolute2(base))
-    throw new Error(
-      "INVALID_DATA_DIRECTORY: XDG_DATA_HOME or LOCALAPPDATA must be absolute."
-    );
-  return join2(base, "memroot");
-}
-async function exists(path) {
-  try {
-    await lstat(path);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-}
-async function safeDirectory(path) {
-  const boundary = dataDirectory();
-  if (path !== boundary && path.startsWith(`${boundary}/`))
-    await safeDirectory(dirname(path));
-  await mkdir(path, { recursive: true, mode: 448 });
-  const info = await lstat(path);
-  if (!info.isDirectory() || info.isSymbolicLink())
-    throw new Error(`UNSAFE_PATH: Expected a real directory at ${path}.`);
-}
-async function fileEntries(root, prefix = "") {
-  const directory = await lstat(join2(root, prefix));
-  if (!directory.isDirectory() || directory.isSymbolicLink())
-    throw new Error(
-      "INTEGRITY_ERROR: Managed plugin directory is not a real directory."
-    );
-  const result = [];
-  for (const name of (await readdir(join2(root, prefix))).sort()) {
-    const path = join2(root, prefix, name);
-    const info = await lstat(path);
-    const key = join2(prefix, name);
-    if (info.isSymbolicLink())
-      throw new Error(
-        "INTEGRITY_ERROR: Plugin assets must not contain symbolic links."
-      );
-    if (info.isDirectory()) result.push(...await fileEntries(root, key));
-    else if (info.isFile()) result.push([key, await readFile(path)]);
-    else throw new Error("INTEGRITY_ERROR: Unsupported plugin asset.");
-  }
-  return result;
+  return result;
 }
 async function integrity(root) {
   const hash = createHash("sha256");
@@ -1573,7 +1459,7 @@ async function stage(data, agent) {
     });
     if (agent !== "grok") {
       const metadata = marketplaceMetadata(agent);
-      await mkdir(dirname(join2(temporary, metadata.path)), { recursive: true });
+      await mkdir(dirname2(join2(temporary, metadata.path)), { recursive: true });
       await writeFile(
         join2(temporary, metadata.path),
         `${JSON.stringify(metadata.value, null, 2)}
@@ -1622,24 +1508,11 @@ async function acquireLock(data) {
 
 // src/config.ts
 function configDirectory() {
-  return join3(homedir2(), ".memroot");
+  return memrootConfigDir();
 }
 function configPath() {
   return join3(configDirectory(), "config.json");
 }
-function isLoopbackHostname(hostname) {
-  return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1" || hostname === "[::1]";
-}
-function isAllowedApiBase(value) {
-  try {
-    const url = new URL(value);
-    if (url.username || url.password || url.search || url.hash) return false;
-    if (url.protocol === "https:") return true;
-    return url.protocol === "http:" && isLoopbackHostname(url.hostname);
-  } catch {
-    return false;
-  }
-}
 function optionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -1707,6 +1580,17 @@ async function readConfig() {
   if (clientIdApiBase) config.clientIdApiBase = clientIdApiBase;
   const userId = optionalString(record.userId);
   if (userId) config.userId = userId;
+  const mcp = record.mcpRegistered;
+  if (mcp && typeof mcp === "object" && !Array.isArray(mcp)) {
+    const registered = {};
+    if (mcp.claude === true)
+      registered.claude = true;
+    if (mcp.codex === true)
+      registered.codex = true;
+    if (mcp.grok === true) registered.grok = true;
+    if (registered.claude || registered.codex || registered.grok)
+      config.mcpRegistered = registered;
+  }
   return config;
 }
 async function writeConfig(config) {
@@ -1728,16 +1612,6 @@ async function writeConfig(config) {
 }
 
 // src/credentials.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
-import {
-  chmod as chmod2,
-  lstat as lstat3,
-  readFile as readFile3,
-  rename as rename3,
-  rm as rm3,
-  writeFile as writeFile3
-} from "node:fs/promises";
-import { join as join4 } from "node:path";
 var SERVICE = "memroot";
 var TOOL_TIMEOUT_MS = 15e3;
 function credentialStoreKind() {
@@ -1756,7 +1630,7 @@ function unavailable(tool) {
   );
 }
 function run(tool, args, input, allowNotFound = false) {
-  const result = spawnSync3(tool, args, {
+  const result = spawnSync(tool, args, {
     encoding: "utf8",
     input,
     timeout: TOOL_TIMEOUT_MS,
@@ -1864,55 +1738,1170 @@ async function readSecret(account) {
       void 0,
       true
     );
-    if (result2.status !== 0) {
-      if (/could not be found|item not found/i.test(result2.stderr))
-        return void 0;
+    if (result2.status !== 0) {
+      if (/could not be found|item not found/i.test(result2.stderr))
+        return void 0;
+      throw new Error(
+        `AUTH_KEYCHAIN_FAILED: security find-generic-password failed (${result2.status ?? "signal"}).`
+      );
+    }
+    const secret2 = result2.stdout.replace(/\n$/, "");
+    return secret2.length ? secret2 : void 0;
+  }
+  const result = run(
+    "secret-tool",
+    ["lookup", "service", SERVICE, "account", account],
+    void 0,
+    true
+  );
+  if (result.status !== 0) return void 0;
+  const secret = result.stdout.replace(/\n$/, "");
+  return secret.length ? secret : void 0;
+}
+async function deleteSecret(account) {
+  const kind = credentialStoreKind();
+  if (kind === "test-file") {
+    const entries = await readTestStore();
+    if (account in entries) {
+      delete entries[account];
+      await writeTestStore(entries);
+    }
+    return;
+  }
+  if (kind === "macos-keychain") {
+    const result = run(
+      "security",
+      ["delete-generic-password", "-s", SERVICE, "-a", account],
+      void 0,
+      true
+    );
+    if (result.status !== 0 && !/could not be found|item not found/i.test(result.stderr))
+      throw new Error(
+        `AUTH_KEYCHAIN_FAILED: security delete-generic-password failed (${result.status ?? "signal"}).`
+      );
+    return;
+  }
+  run(
+    "secret-tool",
+    ["clear", "service", SERVICE, "account", account],
+    void 0,
+    true
+  );
+}
+
+// src/capture/consent.ts
+import { dirname as dirname3 } from "node:path";
+var CAPTURE_AGENTS = ["claude", "codex", "grok"];
+var CONSENT_TEXT_VERSION = "capture-consent-v2";
+var DEFAULT_MAX_ITEMS_PER_SESSION = 3;
+var DEFAULT_MAX_ITEMS_PER_DAY = 10;
+var KEYS = [
+  "schemaVersion",
+  "enabled",
+  "enabledAt",
+  "consentTextVersion",
+  "apiBase",
+  "agents",
+  "crossAgentExtraction",
+  "includeHeadlessSessions",
+  "maxItemsPerSession",
+  "maxItemsPerDay",
+  "models"
+];
+var MODEL = /^[A-Za-z0-9._:/@+-]{1,128}$/;
+function isInt(value, min, max) {
+  return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+function parseConsent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const record = value;
+  const keys = Object.keys(record);
+  if (keys.some((key) => !KEYS.includes(key)) || keys.length !== KEYS.length)
+    return void 0;
+  const agents2 = record.agents;
+  const models = record.models;
+  if (record.schemaVersion !== 1 || typeof record.enabled !== "boolean" || typeof record.enabledAt !== "string" || Number.isNaN(Date.parse(record.enabledAt)) || record.consentTextVersion !== CONSENT_TEXT_VERSION || typeof record.apiBase !== "string" || !isAllowedApiBase(record.apiBase) || record.apiBase.endsWith("/") || !Array.isArray(agents2) || agents2.length === 0 || agents2.length > CAPTURE_AGENTS.length || new Set(agents2).size !== agents2.length || agents2.some((agent) => !CAPTURE_AGENTS.includes(agent)) || typeof record.crossAgentExtraction !== "boolean" || typeof record.includeHeadlessSessions !== "boolean" || !isInt(record.maxItemsPerSession, 1, 5) || !isInt(record.maxItemsPerDay, 1, 20) || !models || typeof models !== "object" || Array.isArray(models))
+    return void 0;
+  const modelRecord = models;
+  const modelKeys = Object.keys(modelRecord);
+  if (modelKeys.length !== CAPTURE_AGENTS.length || modelKeys.some((key) => !CAPTURE_AGENTS.includes(key)) || Object.values(modelRecord).some(
+    (model) => model !== null && (typeof model !== "string" || !MODEL.test(model))
+  ))
+    return void 0;
+  return record;
+}
+function readConsent() {
+  let raw;
+  try {
+    raw = readPrivateFileIfExists(consentPath(), 64 * 1024);
+  } catch {
+    return { kind: "invalid" };
+  }
+  if (raw === void 0) return { kind: "absent" };
+  try {
+    const consent = parseConsent(JSON.parse(raw));
+    return consent ? { kind: "ok", consent } : { kind: "invalid" };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+function writeConsent(consent) {
+  if (!parseConsent(consent))
+    throw new Error("INVALID_CONSENT: Refusing to write invalid consent.");
+  ensurePrivateDir(memrootConfigDir(), dirname3(memrootConfigDir()), false);
+  writePrivateFileAtomic(
+    consentPath(),
+    `${JSON.stringify(consent, null, 2)}
+`
+  );
+}
+
+// src/capture/extract/run.ts
+import { accessSync, constants as constants2, statSync } from "node:fs";
+import { delimiter, isAbsolute as isAbsolute3, join as join5 } from "node:path";
+var MAX_OUTPUT_BYTES = 256 * 1024;
+var MAX_STDERR_BYTES = 8 * 1024;
+function findExecutable(name) {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!isAbsolute3(directory)) continue;
+    const path = join5(directory, name);
+    try {
+      accessSync(path, constants2.X_OK);
+      if (statSync(path).isFile()) return path;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/capture/queue/job.ts
+import { join as join6 } from "node:path";
+var JOB_STATES = [
+  "pending",
+  "extracted",
+  "quota_blocked",
+  "auth_required",
+  "server_unsupported",
+  "runner_unavailable"
+];
+var JOB_ID = /^(claude|codex|grok)-[a-f0-9]{32}$/;
+var HEX64 = /^[a-f0-9]{64}$/;
+function queueDir() {
+  return stateSubdir("queue");
+}
+function jobPath(jobId) {
+  return join6(queueDir(), `${jobId}.json`);
+}
+function parseJob(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const job = value;
+  const optionalTime = (field) => field === null || typeof field === "string" && !Number.isNaN(Date.parse(field));
+  if (job.schemaVersion !== 1 || typeof job.jobId !== "string" || !JOB_ID.test(job.jobId) || !CAPTURE_AGENTS.includes(job.agent) || !job.jobId.startsWith(`${job.agent}-`) || typeof job.sessionId !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/.test(job.sessionId) || typeof job.sessionRef !== "string" || !HEX64.test(job.sessionRef) || job.jobId !== `${job.agent}-${job.sessionRef.slice(0, 32)}` || !(job.transcriptPath === null || typeof job.transcriptPath === "string") || typeof job.cwd !== "string" || !job.cwd.startsWith("/") || typeof job.reason !== "string" || !optionalTime(job.endedAt) || job.endedAt === null || !optionalTime(job.createdAt) || job.createdAt === null || !JOB_STATES.includes(job.state) || typeof job.attempts !== "number" || !Number.isInteger(job.attempts) || job.attempts < 0 || !optionalTime(job.nextAttemptAt) || !(job.lastError === null || typeof job.lastError === "string"))
+    return void 0;
+  return job;
+}
+function readJob(jobId) {
+  const raw = readPrivateFileIfExists(jobPath(jobId), 64 * 1024);
+  if (raw === void 0) return void 0;
+  try {
+    return parseJob(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function deleteJob(jobId) {
+  removeFile(jobPath(jobId));
+}
+function listJobIds() {
+  return listFiles(queueDir()).filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -5)).filter((id) => JOB_ID.test(id));
+}
+
+// src/capture/queue/ledger.ts
+import { join as join7 } from "node:path";
+var MAX_TITLE_HASHES = 200;
+var UPLOAD_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var HEX642 = /^[a-f0-9]{64}$/;
+function empty() {
+  return {
+    schemaVersion: 1,
+    cursors: {},
+    uploads: [],
+    titleHashes: [],
+    project: null,
+    lastRun: null
+  };
+}
+function ledgerPath() {
+  return join7(stateSubdir(), "ledger.json");
+}
+function sanitize(value) {
+  const ledger = empty();
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return ledger;
+  const record = value;
+  if (record.schemaVersion !== 1) return ledger;
+  if (record.cursors && typeof record.cursors === "object")
+    for (const [key, entry] of Object.entries(
+      record.cursors
+    )) {
+      const cursor3 = entry;
+      if (HEX642.test(key) && typeof cursor3?.turns === "number" && Number.isInteger(cursor3.turns) && cursor3.turns >= 0 && typeof cursor3.updatedAt === "string")
+        ledger.cursors[key] = {
+          turns: cursor3.turns,
+          updatedAt: cursor3.updatedAt
+        };
+    }
+  if (Array.isArray(record.uploads))
+    for (const entry of record.uploads) {
+      const upload = entry;
+      if (typeof upload?.at === "string" && !Number.isNaN(Date.parse(upload.at)) && typeof upload.titleHash === "string" && HEX642.test(upload.titleHash))
+        ledger.uploads.push({
+          at: upload.at,
+          titleHash: upload.titleHash,
+          memoryId: typeof upload.memoryId === "string" && /^[A-Za-z0-9._:-]{1,256}$/.test(upload.memoryId) ? upload.memoryId : null
+        });
+    }
+  if (Array.isArray(record.titleHashes))
+    ledger.titleHashes = record.titleHashes.filter(
+      (hash) => typeof hash === "string" && HEX642.test(hash)
+    ).slice(-MAX_TITLE_HASHES);
+  const project = record.project;
+  if (project && typeof project.apiBase === "string" && typeof project.projectId === "string" && /^[A-Za-z0-9-]{1,128}$/.test(project.projectId))
+    ledger.project = { apiBase: project.apiBase, projectId: project.projectId };
+  const lastRun = record.lastRun;
+  if (lastRun && typeof lastRun.startedAt === "string" && typeof lastRun.finishedAt === "string" && lastRun.outcomes && typeof lastRun.outcomes === "object") {
+    const outcomes = {};
+    for (const [key, count] of Object.entries(lastRun.outcomes))
+      if (/^[a-z_]{1,40}$/.test(key) && typeof count === "number")
+        outcomes[key] = count;
+    ledger.lastRun = {
+      startedAt: lastRun.startedAt,
+      finishedAt: lastRun.finishedAt,
+      outcomes
+    };
+  }
+  return ledger;
+}
+function readLedger() {
+  try {
+    const raw = readPrivateFileIfExists(ledgerPath(), 4 * 1024 * 1024);
+    return raw === void 0 ? empty() : sanitize(JSON.parse(raw));
+  } catch {
+    return empty();
+  }
+}
+function uploadsInLastDay(ledger, now = Date.now()) {
+  return ledger.uploads.filter(
+    (upload) => now - Date.parse(upload.at) < 24 * 60 * 60 * 1e3
+  ).length;
+}
+
+// src/capture/upload/http.ts
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+var HTTP_TIMEOUT_MS = 3e4;
+var MAX_RESPONSE_BYTES = 1024 * 1024;
+var TransportError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+  code;
+};
+function httpPost(target, headers, payload, timeoutMs = HTTP_TIMEOUT_MS) {
+  const transport = target.protocol === "https:" ? httpsRequest : httpRequest;
+  return new Promise((resolve, reject) => {
+    const req = transport(
+      target,
+      {
+        method: "POST",
+        agent: false,
+        timeout: timeoutMs,
+        headers: { ...headers, "content-length": Buffer.byteLength(payload) }
+      },
+      (response) => {
+        const chunks = [];
+        let size = 0;
+        response.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > MAX_RESPONSE_BYTES) {
+            req.destroy(new TransportError("response_too_large"));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        response.on(
+          "end",
+          () => resolve({
+            status: response.statusCode ?? 0,
+            headers: response.headers,
+            body: Buffer.concat(chunks).toString("utf8")
+          })
+        );
+        response.on("error", () => reject(new TransportError("network_error")));
+      }
+    );
+    req.on("timeout", () => req.destroy(new TransportError("timeout")));
+    req.on(
+      "error",
+      (error) => reject(
+        error instanceof TransportError ? error : new TransportError("network_error")
+      )
+    );
+    req.end(payload);
+  });
+}
+
+// src/capture/queue/lock.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join8 } from "node:path";
+function lockPath(name) {
+  return join8(stateSubdir("locks"), name);
+}
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function readOwner(path) {
+  try {
+    const value = JSON.parse(
+      readFileSync2(join8(path, "owner.json"), "utf8")
+    );
+    const createdAt = typeof value.createdAt === "string" ? Date.parse(value.createdAt) : NaN;
+    if (typeof value.pid !== "number" || Number.isNaN(createdAt))
+      return void 0;
+    const heartbeat = typeof value.heartbeatAt === "string" ? Date.parse(value.heartbeatAt) : NaN;
+    return {
+      pid: value.pid,
+      createdAt,
+      heartbeatAt: Number.isNaN(heartbeat) ? createdAt : heartbeat
+    };
+  } catch {
+    return void 0;
+  }
+}
+function isStale(path, staleMs) {
+  let info;
+  try {
+    info = lstatSync2(path);
+  } catch {
+    return false;
+  }
+  if (info.isSymbolicLink() || !info.isDirectory()) return true;
+  const owner = readOwner(path);
+  if (!owner) return Date.now() - info.mtimeMs > staleMs;
+  if (!processAlive(owner.pid)) return true;
+  return Date.now() - owner.heartbeatAt > staleMs;
+}
+var held = /* @__PURE__ */ new Map();
+function tryMkdir(path) {
+  try {
+    mkdirSync2(path, { mode: 448 });
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+  const token = randomBytes2(8).toString("hex");
+  held.set(path, { ino: lstatSync2(path).ino, token });
+  writeOwner(path, (/* @__PURE__ */ new Date()).toISOString(), token);
+  return true;
+}
+function writeOwner(path, createdAt, token) {
+  const temporary = join8(path, `owner.${process.pid}.${token}.tmp`);
+  writeFileSync2(
+    temporary,
+    JSON.stringify({
+      pid: process.pid,
+      createdAt,
+      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+      token
+    }),
+    { mode: 384 }
+  );
+  renameSync2(temporary, join8(path, "owner.json"));
+}
+function readToken(path) {
+  try {
+    const value = JSON.parse(
+      readFileSync2(join8(path, "owner.json"), "utf8")
+    );
+    return typeof value.token === "string" ? value.token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function stillOurs(path) {
+  const mine = held.get(path);
+  if (!mine) return false;
+  try {
+    return lstatSync2(path).ino === mine.ino && readToken(path) === mine.token;
+  } catch {
+    return false;
+  }
+}
+function clearStale(path, staleMs) {
+  const tombstone = `${path}.stale-${process.pid}-${randomBytes2(4).toString("hex")}`;
+  try {
+    renameSync2(path, tombstone);
+  } catch {
+    return;
+  }
+  if (!isStale(tombstone, staleMs)) {
+    try {
+      renameSync2(tombstone, path);
+      return;
+    } catch {
+    }
+  }
+  rmSync2(tombstone, { recursive: true, force: true });
+}
+async function acquireLock2(name, options) {
+  const path = lockPath(name);
+  const deadline = Date.now() + (options.waitMs ?? 0);
+  let cleanups = 0;
+  for (; ; ) {
+    if (tryMkdir(path)) {
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        if (stillOurs(path)) rmSync2(path, { recursive: true, force: true });
+        held.delete(path);
+      };
+    }
+    if (cleanups < 3 && isStale(path, options.staleMs)) {
+      cleanups++;
+      clearStale(path, options.staleMs);
+      continue;
+    }
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? 100));
+  }
+}
+
+// src/capture/upload/token-broker.ts
+var MCP_CLIENT_ID = "memroot-cli";
+var REFRESH_SKEW_MS = 3e4;
+var AuthRequiredError = class extends Error {
+  constructor() {
+    super("AUTH_REQUIRED");
+  }
+};
+function mcpAccount(apiBase) {
+  return `${apiBase}#mcp`;
+}
+function mcpResource(apiBase) {
+  return `${apiBase}/mcp`;
+}
+var TokenBroker = class {
+  constructor(apiBase) {
+    this.apiBase = apiBase;
+  }
+  apiBase;
+  cached;
+  invalidate() {
+    this.cached = void 0;
+  }
+  async accessToken() {
+    if (this.cached && this.cached.expiresAt - Date.now() > REFRESH_SKEW_MS)
+      return this.cached.token;
+    const release = await acquireLock2("auth.lock", {
+      staleMs: 6e4,
+      waitMs: 2e4,
+      pollMs: 100
+    });
+    if (!release) throw new TransportError("auth_lock_busy");
+    try {
+      const refreshToken = await readSecret(mcpAccount(this.apiBase));
+      if (!refreshToken) throw new AuthRequiredError();
+      const response = await httpPost(
+        new URL(`${this.apiBase}/oauth/token`),
+        {
+          "content-type": "application/x-www-form-urlencoded",
+          accept: "application/json"
+        },
+        new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: refreshToken,
+          client_id: MCP_CLIENT_ID,
+          resource: mcpResource(this.apiBase)
+        }).toString()
+      );
+      let body = {};
+      try {
+        const parsed = JSON.parse(response.body || "{}");
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+          body = parsed;
+      } catch {
+        body = {};
+      }
+      if (response.status >= 400) {
+        if (response.status === 400 && (body.error === "invalid_grant" || body.error === "invalid_client" || body.error === "invalid_target"))
+          throw new AuthRequiredError();
+        throw new TransportError(`token_http_${response.status}`);
+      }
+      if (typeof body.access_token !== "string" || !body.access_token)
+        throw new TransportError("token_response_invalid");
+      if (typeof body.refresh_token === "string" && body.refresh_token && body.refresh_token !== refreshToken)
+        await storeSecret(mcpAccount(this.apiBase), body.refresh_token);
+      const lifetime = typeof body.expires_in === "number" && body.expires_in > 0 ? body.expires_in : 300;
+      this.cached = {
+        token: body.access_token,
+        expiresAt: Date.now() + lifetime * 1e3
+      };
+      return body.access_token;
+    } finally {
+      release();
+    }
+  }
+};
+
+// src/capture/upload/mcp-client.ts
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var McpInputRejected = class extends Error {
+  constructor(rules) {
+    super("MCP_INPUT_REJECTED");
+    this.rules = rules;
+  }
+  rules;
+};
+var McpToolError = class extends Error {
+  constructor(code) {
+    super(`MCP_TOOL_ERROR:${code}`);
+    this.code = code;
+  }
+  code;
+};
+var McpRateLimited = class extends Error {
+  constructor(retryAfterMs) {
+    super("MCP_RATE_LIMITED");
+    this.retryAfterMs = retryAfterMs;
+  }
+  retryAfterMs;
+};
+var MIN_RETRY_MS = 6e4;
+var MAX_RETRY_MS = 36e5;
+function retryAfter(value) {
+  const header = Array.isArray(value) ? value[0] : value;
+  const seconds = header ? Number(header) : Number.NaN;
+  let ms = MIN_RETRY_MS;
+  if (Number.isFinite(seconds) && seconds >= 0) ms = seconds * 1e3;
+  else {
+    const date = header ? Date.parse(header) : Number.NaN;
+    if (Number.isFinite(date)) ms = date - Date.now();
+  }
+  return Math.min(Math.max(ms, MIN_RETRY_MS), MAX_RETRY_MS);
+}
+function parseRpc(contentType, body) {
+  let text = body;
+  if (contentType.includes("text/event-stream")) {
+    const data = body.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+    text = data.at(-1) ?? "";
+  }
+  const value = JSON.parse(text);
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TransportError("rpc_invalid");
+  return value;
+}
+var McpClient = class {
+  constructor(apiBase, broker, userAgent) {
+    this.apiBase = apiBase;
+    this.broker = broker;
+    this.userAgent = userAgent;
+  }
+  apiBase;
+  broker;
+  userAgent;
+  id = 0;
+  async post(token, payload) {
+    return httpPost(
+      new URL(`${this.apiBase}/mcp`),
+      {
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+        authorization: `Bearer ${token}`,
+        "user-agent": this.userAgent
+      },
+      payload
+    );
+  }
+  async call(name, args) {
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id: ++this.id,
+      method: "tools/call",
+      params: { name, arguments: args }
+    });
+    let response = await this.post(await this.broker.accessToken(), payload);
+    if (response.status === 401) {
+      this.broker.invalidate();
+      response = await this.post(await this.broker.accessToken(), payload);
+      if (response.status === 401) throw new AuthRequiredError();
+    }
+    if (response.status === 403) throw new AuthRequiredError();
+    if (response.status === 429)
+      throw new McpRateLimited(retryAfter(response.headers["retry-after"]));
+    if (response.status !== 200)
+      throw new TransportError(`mcp_http_${response.status}`);
+    let message;
+    try {
+      message = parseRpc(
+        String(response.headers["content-type"] ?? ""),
+        response.body
+      );
+    } catch {
+      throw new TransportError("rpc_invalid");
+    }
+    const error = message.error;
+    if (error) {
+      if (error.code === -32602) {
+        const issues = error.data?.issues;
+        const rules = Array.isArray(issues) ? issues.map((issue) => issue.rule).filter((rule) => typeof rule === "string") : [];
+        throw new McpInputRejected(rules);
+      }
+      throw new TransportError(
+        `rpc_error_${typeof error.code === "number" ? error.code : "unknown"}`
+      );
+    }
+    const result = message.result;
+    const text = result?.content?.find((item) => item.type === "text")?.text;
+    let value;
+    try {
+      value = typeof text === "string" ? JSON.parse(text) : void 0;
+    } catch {
+      value = void 0;
+    }
+    if (result?.isError === true) {
+      const error2 = value?.error;
+      if (error2?.code === "invalid_request" && Array.isArray(error2.issues))
+        throw new McpInputRejected(
+          error2.issues.map((issue) => issue.rule).filter((rule) => typeof rule === "string")
+        );
+      const code = error2?.code;
+      const safe = typeof code === "string" && /^[a-z_]{1,64}$/.test(code) ? code : "unknown";
+      if (safe === "rate_limited") throw new McpRateLimited(6e4);
+      throw new McpToolError(safe);
+    }
+    if (value === void 0) throw new TransportError("rpc_result_invalid");
+    return value;
+  }
+};
+
+// src/capture/status.ts
+function readText(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function absoluteEnv2(name) {
+  const value = process.env[name];
+  return value && isAbsolute4(value) ? value : void 0;
+}
+function codexHookTrust() {
+  const home = absoluteEnv2("CODEX_HOME") ?? join9(homedir3(), ".codex");
+  const text = readText(join9(home, "config.toml"));
+  if (text === void 0) return "not checked (no Codex config.toml)";
+  const trusted = /* @__PURE__ */ new Set();
+  let section;
+  for (const line of text.split("\n")) {
+    const header = line.match(
+      /^\s*\[hooks\.state\."(memroot@[^"]*:hooks\/hooks\.json:[^"]*)"\]\s*$/
+    );
+    if (header) {
+      section = header[1];
+      continue;
+    }
+    if (/^\s*\[/.test(line)) section = void 0;
+    else if (section && /^\s*trusted_hash\s*=\s*"sha256:[a-f0-9]+"/.test(line))
+      trusted.add(section);
+  }
+  const end = [...trusted].some((key) => /:session_end:/.test(key));
+  const start = [...trusted].some((key) => /:session_start:/.test(key));
+  if (!end && !start)
+    return "SessionEnd hook not trusted yet; open /hooks in Codex and trust the Memroot hooks";
+  return `SessionStart ${start ? "trusted" : "not trusted"}, SessionEnd ${end ? "trusted" : "not trusted (open /hooks in Codex)"}`;
+}
+function claudeHooksDisabled() {
+  const config = absoluteEnv2("CLAUDE_CONFIG_DIR") ?? join9(homedir3(), ".claude");
+  const text = readText(join9(config, "settings.json"));
+  if (!text) return false;
+  try {
+    return JSON.parse(text).disableAllHooks === true;
+  } catch {
+    return false;
+  }
+}
+async function captureReport(options) {
+  const lines = [];
+  const consent = readConsent();
+  if (consent.kind === "absent") {
+    lines.push(
+      "Session capture: off (not enabled). Run memroot capture on to opt in."
+    );
+    return lines;
+  }
+  if (consent.kind === "invalid") {
+    lines.push(
+      "Session capture: consent file is invalid; capture is disabled. Run memroot capture on to repair it."
+    );
+    return lines;
+  }
+  const value = consent.consent;
+  lines.push(
+    `Session capture: ${value.enabled ? "on" : "off"} (agents: ${value.agents.join(", ")}; cross-agent extraction ${value.crossAgentExtraction ? "on" : "off"}; headless sessions ${value.includeHeadlessSessions ? "included" : "excluded"})`
+  );
+  lines.push(
+    `  Caps: ${value.maxItemsPerSession} per session, ${value.maxItemsPerDay} per 24 h; API ${value.apiBase}`
+  );
+  if (pathExists(stateDir())) {
+    const states = {};
+    for (const jobId of listJobIds()) {
+      const job = readJob(jobId);
+      if (job) states[job.state] = (states[job.state] ?? 0) + 1;
+    }
+    const pending = Object.entries(states).map(([state, count]) => `${state} ${count}`).join(", ");
+    lines.push(`  Queue: ${pending || "empty"}`);
+    const ledger = readLedger();
+    lines.push(`  Uploaded in the last 24 h: ${uploadsInLastDay(ledger)}`);
+    if (ledger.lastRun) {
+      const outcomes = Object.entries(ledger.lastRun.outcomes).map(([key, count]) => `${key} ${count}`).join(", ");
+      lines.push(
+        `  Last worker run: ${ledger.lastRun.finishedAt} (${outcomes || "no jobs"})`
+      );
+    } else lines.push("  Last worker run: never");
+  } else lines.push("  Queue: empty; the worker has not run yet");
+  let credential = "missing (run memroot capture on)";
+  try {
+    if (await readSecret(mcpAccount(value.apiBase))) {
+      credential = "present";
+      if (options.probe) {
+        const broker = new TokenBroker(value.apiBase);
+        try {
+          await broker.accessToken();
+          const status2 = await new McpClient(
+            value.apiBase,
+            broker,
+            `memroot-cli/${"0.1.0-alpha.3"}`
+          ).call("connection_status", {});
+          credential = status2?.connected === true ? "present; connection verified" : "present; connection not verified";
+        } catch (error) {
+          credential = error instanceof AuthRequiredError ? "rejected or expired (run memroot capture on)" : `present; check failed (${error instanceof Error ? error.message : "error"})`;
+        }
+      }
+    }
+  } catch (error) {
+    credential = `unavailable (${error instanceof Error ? error.message.split(":")[0] : "error"})`;
+  }
+  lines.push(`  Capture connection: ${credential}`);
+  if (value.agents.includes("codex"))
+    lines.push(`  Codex hook trust: ${codexHookTrust()}`);
+  if (value.agents.includes("claude") && claudeHooksDisabled())
+    lines.push(
+      "  Claude Code: disableAllHooks is set in settings.json; capture cannot run."
+    );
+  const runners = ["claude", "codex", "grok"].map((agent) => `${agent} ${findExecutable(agent) ? "found" : "not found"}`).join(", ");
+  lines.push(`  Headless extractor CLIs on PATH: ${runners}`);
+  return lines;
+}
+
+// src/codex-mcp.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/native.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { accessSync as accessSync2, constants as constants3, realpathSync, statSync as statSync2 } from "node:fs";
+import { delimiter as delimiter2, isAbsolute as isAbsolute5, join as join10 } from "node:path";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+var agents = ["claude", "codex", "grok"];
+var labels = {
+  claude: "Claude Code",
+  codex: "Codex",
+  grok: "Grok"
+};
+function executable(agent) {
+  for (const directory of (process.env.PATH ?? "").split(delimiter2)) {
+    if (!isAbsolute5(directory)) continue;
+    for (const extension of [""]) {
+      const path = join10(directory, agent + extension);
+      try {
+        accessSync2(path, constants3.X_OK);
+        if (statSync2(path).isFile()) return path;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function native(path, agent, args) {
+  const result = spawnSync2(path, args, {
+    encoding: "utf8",
+    timeout: 6e4,
+    maxBuffer: 4 * 1024 * 1024,
+    shell: false
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `NATIVE_COMMAND_FAILED: ${agent} ${args.slice(0, 3).join(" ")} failed (${result.status ?? result.error?.code ?? "signal"}). Check '${agent} plugin --help', update the agent CLI, and retry. Its plugin manager may have partially registered Memroot; no success receipt was written.`
+    );
+  }
+  return result.stdout;
+}
+function installCommands(agent, marketplace) {
+  if (agent === "claude")
+    return [
+      ["plugin", "marketplace", "add", marketplace, "--scope", "user"],
+      ["plugin", "install", "memroot@memroot", "--scope", "user"]
+    ];
+  if (agent === "codex")
+    return [
+      ["plugin", "marketplace", "add", marketplace, "--json"],
+      ["plugin", "add", "memroot@memroot", "--json"]
+    ];
+  return [
+    ["plugin", "install", join10(marketplace, "plugins", "memroot"), "--trust"]
+  ];
+}
+function preflight(path, agent) {
+  native(path, agent, ["plugin", "--help"]);
+  if (agent !== "grok")
+    native(path, agent, ["plugin", "marketplace", "add", "--help"]);
+  native(path, agent, [
+    "plugin",
+    agent === "codex" ? "add" : "install",
+    "--help"
+  ]);
+}
+function rows(output, field) {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    throw new Error(
+      "NATIVE_STATUS_UNSUPPORTED: Agent plugin status is not valid JSON. Update the agent CLI and retry."
+    );
+  }
+  if (field)
+    value = value && typeof value === "object" ? value[field] : void 0;
+  if (!Array.isArray(value) || value.some((row) => !row || typeof row !== "object" || Array.isArray(row)))
+    throw new Error(
+      "NATIVE_STATUS_UNSUPPORTED: Unrecognized agent plugin status; refusing to change it."
+    );
+  return value;
+}
+function samePath(left, right) {
+  if (typeof left !== "string") return false;
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return left === right;
+  }
+}
+function inspectNative(path, agent, marketplace, previousMarketplace) {
+  if (agent === "grok") {
+    const output = stripVTControlCharacters2(
+      native(path, agent, ["plugin", "list"])
+    );
+    const lines = output.split("\n").filter((line) => line.trim());
+    const empty2 = output.trim() === "No plugins installed. Run `grok plugin install --help` to get started.";
+    if (!empty2 && (!lines.length || lines.some(
+      (line) => !/^\s*\S+:\s+[^[]+\[.+\](?:\s+\(disabled\))?\s*$/.test(line)
+    ))) {
+      throw new Error(
+        "NATIVE_STATUS_UNSUPPORTED: Unrecognized Grok plugin list format. Update Grok and inspect its native plugin manager before retrying."
+      );
+    }
+    const matching = output.split("\n").filter((line) => /:\s*memroot(?:\s|$)/.test(line));
+    for (const line of matching) {
+      const source = line.match(/\[local: (.*)\]/)?.[1];
+      if (!samePath(source, join10(marketplace, "plugins", "memroot")) && !(previousMarketplace && samePath(source, join10(previousMarketplace, "plugins", "memroot"))))
+        throw new Error(
+          "PLUGIN_COLLISION: Grok already has a different Memroot plugin. Resolve it with the native plugin manager first."
+        );
+      if (/disabled/i.test(line))
+        throw new Error(
+          "PLUGIN_DISABLED: Memroot is disabled in Grok. Enable it in the native plugin manager when ready."
+        );
+    }
+    return {
+      registered: false,
+      currentMarketplace: false,
+      installed: matching.length > 0
+    };
+  }
+  const markets = rows(
+    native(path, agent, ["plugin", "marketplace", "list", "--json"]),
+    agent === "codex" ? "marketplaces" : void 0
+  );
+  const plugins = rows(
+    native(path, agent, ["plugin", "list", "--json"]),
+    agent === "codex" ? "installed" : void 0
+  );
+  const matchingMarkets = markets.filter((row) => row.name === "memroot");
+  if (matchingMarkets.length > 1)
+    throw new Error(
+      "MARKETPLACE_COLLISION: Multiple Memroot marketplaces were reported; refusing to change them."
+    );
+  for (const market of matchingMarkets) {
+    const source = agent === "codex" ? market.root : market.path;
+    if (!samePath(source, marketplace) && !(previousMarketplace && samePath(source, previousMarketplace)))
+      throw new Error(
+        "MARKETPLACE_COLLISION: memroot is already registered from a different source. Resolve it with the native plugin manager first."
+      );
+  }
+  const matchingPlugins = plugins.filter(
+    (row) => row.id === "memroot@memroot" || row.pluginId === "memroot@memroot" || row.name === "memroot"
+  );
+  if (matchingPlugins.length && !matchingMarkets.length)
+    throw new Error(
+      "PLUGIN_COLLISION: An existing Memroot plugin has no matching managed marketplace. Resolve it with the native plugin manager first."
+    );
+  for (const plugin of matchingPlugins) {
+    if (plugin.enabled === false)
+      throw new Error(
+        `PLUGIN_DISABLED: Memroot is disabled in ${labels[agent]}. Enable it in the native plugin manager when ready; setup preserves your choice.`
+      );
+    if (plugin.enabled !== true || agent === "claude" && plugin.scope !== "user")
+      throw new Error(
+        "PLUGIN_COLLISION: Existing Memroot plugin status or scope cannot be safely managed. Check the native plugin manager."
+      );
+  }
+  const currentMarketplace = matchingMarkets.some(
+    (market) => samePath(agent === "codex" ? market.root : market.path, marketplace)
+  );
+  if (agent === "codex" && matchingMarkets.length > 0 && !currentMarketplace && plugins.some(
+    (plugin) => plugin.marketplaceName === "memroot" && plugin.pluginId !== "memroot@memroot"
+  ))
+    throw new Error(
+      "MARKETPLACE_COLLISION: The previous Memroot marketplace contains another installed plugin; refusing to remove it."
+    );
+  return {
+    registered: matchingMarkets.length > 0,
+    currentMarketplace,
+    installed: matchingPlugins.length > 0
+  };
+}
+
+// src/codex-mcp.ts
+var codexMcpUrl = "https://api.memroot.dev/mcp";
+function command(path, args, interactive = false) {
+  const result = spawnSync3(path, ["mcp", ...args], {
+    shell: false,
+    encoding: "utf8",
+    timeout: interactive ? 3e5 : 3e4,
+    maxBuffer: 1024 * 1024,
+    // Let Codex present browser authentication directly; never capture credentials.
+    stdio: interactive ? "inherit" : "pipe"
+  });
+  if (result.error || result.status !== 0)
+    throw new Error(
+      "MCP_COMMAND_FAILED: Codex MCP command did not complete. Your configuration is preserved; retry memroot setup --agent codex --yes."
+    );
+  return result.stdout ?? "";
+}
+function inspectCodexMcp(path) {
+  let rows2;
+  try {
+    rows2 = JSON.parse(command(path, ["list", "--json"]));
+  } catch {
+    throw new Error(
+      "MCP_STATUS_UNAVAILABLE: Cannot inspect Codex MCP state. Retry later; no new authorization was requested."
+    );
+  }
+  if (!Array.isArray(rows2) || rows2.some((row2) => !row2 || typeof row2 !== "object"))
+    throw new Error(
+      "MCP_STATUS_UNAVAILABLE: Unsupported Codex MCP status format."
+    );
+  const matching = rows2.filter((row2) => row2.name === "memroot");
+  if (!matching.length)
+    return { configured: false, authorized: false, verified: false };
+  const row = matching[0];
+  if (matching.length !== 1 || row.enabled !== true || row.transport?.type !== "streamable_http" || row.transport?.url !== codexMcpUrl || row.transport?.bearer_token_env_var || row.transport?.http_headers || row.transport?.env_http_headers || row.transport?.http_headers_helper)
+    throw new Error(
+      "MCP_CONFLICT: Existing memroot MCP configuration differs from production OAuth or is disabled. Inspect it in Codex; setup preserves your settings."
+    );
+  if (row.auth_status !== "oauth" && row.auth_status !== "not_logged_in")
+    throw new Error(
+      "MCP_AUTH_UNKNOWN: Codex could not establish OAuth status. Resolve it in Codex before retrying; no replacement grant was requested."
+    );
+  return {
+    configured: true,
+    authorized: row.auth_status === "oauth",
+    verified: false
+  };
+}
+function codexMcpPreflight(path) {
+  for (const [args, flags] of [
+    [["list", "--help"], ["--json"]],
+    [
+      ["add", "--help"],
+      ["--url", "--oauth-resource"]
+    ],
+    [["login", "--help"], []]
+  ]) {
+    const help2 = command(path, [...args]);
+    if (flags.some((flag) => !help2.includes(flag)))
+      throw new Error(
+        "MCP_UNSUPPORTED: Update Codex to a version supporting native remote OAuth MCP setup."
+      );
+  }
+}
+async function ensureCodexMcp(options) {
+  if (options.dryRun)
+    return { configured: false, authorized: false, verified: false };
+  const path = executable("codex");
+  if (!path)
+    throw new Error("AGENT_NOT_FOUND: Install Codex before linking Memroot.");
+  codexMcpPreflight(path);
+  let state = inspectCodexMcp(path);
+  if (!state.configured) {
+    command(
+      path,
+      ["add", "memroot", "--url", codexMcpUrl, "--oauth-resource", codexMcpUrl],
+      true
+    );
+    state = inspectCodexMcp(path);
+    if (!state.authorized)
+      throw new Error(
+        "MCP_AUTH_PENDING: Codex MCP is configured; authorization has not completed. Retry setup to resume."
+      );
+  } else if (!state.authorized) {
+    command(path, ["login", "memroot"], true);
+    state = inspectCodexMcp(path);
+  }
+  if (!state.authorized)
+    throw new Error(
+      "MCP_AUTH_PENDING: Codex has not confirmed OAuth authorization."
+    );
+  return state;
+}
+function describeCodexMcp(state) {
+  return `Codex MCP: ${state.configured ? "configured" : "not configured"}; OAuth: ${state.authorized ? "authorized" : "not authorized"}; memory verification: not verified. Ask Codex to call connection_status, then save and retrieve a test memory.`;
+}
+
+// src/grok-mcp.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { homedir as homedir4 } from "node:os";
+var grokMcpUrl = "https://api.memroot.dev/mcp";
+var MANAGED_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "scope",
+  "enabled",
+  "url",
+  "type",
+  "startup_timeout_sec",
+  "tool_timeout_sec",
+  "tool_timeouts",
+  "expose_image_base64"
+]);
+function command2(path, args) {
+  const result = spawnSync4(path, ["mcp", ...args], {
+    shell: false,
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 1024 * 1024,
+    stdio: "pipe",
+    // `grok mcp list` merges project-scoped servers from the working
+    // directory. Setup manages the user scope, so it never runs in a repo.
+    cwd: homedir4()
+  });
+  if (result.error || result.status !== 0)
+    throw new Error(
+      "MCP_COMMAND_FAILED: Grok MCP command did not complete. Your configuration is preserved; retry memroot setup --agent grok --yes."
+    );
+  return result.stdout ?? "";
+}
+function inspectGrokMcp(path) {
+  let rows2;
+  try {
+    rows2 = JSON.parse(command2(path, ["list", "--json"]));
+  } catch {
+    throw new Error(
+      "MCP_STATUS_UNAVAILABLE: Cannot inspect Grok MCP state. Retry later; your configuration was not changed."
+    );
+  }
+  if (!Array.isArray(rows2) || rows2.some((row2) => !row2 || typeof row2 !== "object" || Array.isArray(row2)))
+    throw new Error(
+      "MCP_STATUS_UNAVAILABLE: Unsupported Grok MCP status format."
+    );
+  const matching = rows2.filter(
+    (row2) => row2.name === "memroot"
+  );
+  const row = matching[0];
+  if (!row) return { configured: false, verified: false };
+  if (matching.length !== 1 || row.scope !== "user" || row.enabled !== true || row.url !== grokMcpUrl || row.type !== void 0 && row.type !== "http" || Object.keys(row).some((key) => !MANAGED_KEYS.has(key)))
+    throw new Error(
+      "MCP_CONFLICT: Existing memroot MCP configuration in Grok differs from production OAuth, is disabled or blocked, or is not user-scoped. Inspect it with grok mcp list; setup preserves your settings."
+    );
+  return { configured: true, verified: false };
+}
+function grokMcpPreflight(path) {
+  for (const [args, flags] of [
+    [["list", "--help"], ["--json"]],
+    [
+      ["add", "--help"],
+      ["--transport", "--scope"]
+    ]
+  ]) {
+    const help2 = command2(path, [...args]);
+    if (flags.some((flag) => !help2.includes(flag)))
       throw new Error(
-        `AUTH_KEYCHAIN_FAILED: security find-generic-password failed (${result2.status ?? "signal"}).`
+        "MCP_UNSUPPORTED: Update Grok to a version supporting remote HTTP MCP setup."
       );
-    }
-    const secret2 = result2.stdout.replace(/\n$/, "");
-    return secret2.length ? secret2 : void 0;
   }
-  const result = run(
-    "secret-tool",
-    ["lookup", "service", SERVICE, "account", account],
-    void 0,
-    true
-  );
-  if (result.status !== 0) return void 0;
-  const secret = result.stdout.replace(/\n$/, "");
-  return secret.length ? secret : void 0;
 }
-async function deleteSecret(account) {
-  const kind = credentialStoreKind();
-  if (kind === "test-file") {
-    const entries = await readTestStore();
-    if (account in entries) {
-      delete entries[account];
-      await writeTestStore(entries);
+function ensureGrokMcp(options) {
+  if (options.dryRun) return { configured: false, verified: false };
+  const path = executable("grok");
+  if (!path)
+    throw new Error("AGENT_NOT_FOUND: Install Grok before linking Memroot.");
+  grokMcpPreflight(path);
+  let state = inspectGrokMcp(path);
+  if (!state.configured) {
+    command2(path, [
+      "add",
+      "--scope",
+      "user",
+      "--transport",
+      "http",
+      "memroot",
+      grokMcpUrl
+    ]);
+    try {
+      state = inspectGrokMcp(path);
+    } catch {
+      throw new Error(
+        "MCP_COMMAND_FAILED: Setup added the memroot MCP server to Grok but could not verify the entry. Inspect it with grok mcp list; remove it with grok mcp remove memroot --scope user if it looks wrong, then retry memroot setup --agent grok --yes."
+      );
     }
-    return;
-  }
-  if (kind === "macos-keychain") {
-    const result = run(
-      "security",
-      ["delete-generic-password", "-s", SERVICE, "-a", account],
-      void 0,
-      true
-    );
-    if (result.status !== 0 && !/could not be found|item not found/i.test(result.stderr))
+    if (!state.configured)
       throw new Error(
-        `AUTH_KEYCHAIN_FAILED: security delete-generic-password failed (${result.status ?? "signal"}).`
+        "MCP_COMMAND_FAILED: Grok did not record the memroot MCP server. Retry memroot setup --agent grok --yes."
       );
-    return;
   }
-  run(
-    "secret-tool",
-    ["clear", "service", SERVICE, "account", account],
-    void 0,
-    true
-  );
+  return state;
+}
+function describeGrokMcp(state) {
+  if (!state.configured)
+    return "Grok MCP: not configured. Run memroot setup --agent grok --yes to register the Memroot MCP server.";
+  return "Grok MCP: configured; OAuth: not checked, Grok keeps the credentials in its own store; memory verification: not verified. Ask Grok to call connection_status, then save and retrieve a test memory.";
 }
 
 // src/auth.ts
@@ -1921,7 +2910,7 @@ var DEV_API_BASE = "http://localhost:8787";
 var STATIC_CLIENT_ID = "memroot-cli";
 var CALLBACK_PATH = "/callback";
 var LOGIN_TIMEOUT_MS = 18e4;
-var REFRESH_SKEW_MS = 3e4;
+var REFRESH_SKEW_MS2 = 3e4;
 var REQUESTED_SCOPE = "memory.read memory.write";
 var OAuthError = class extends Error {
   constructor(oauth, message) {
@@ -1969,7 +2958,7 @@ function parseTokenSet(body) {
 }
 var REQUEST_TIMEOUT_MS = 3e4;
 function request(target, method, contentType, payload) {
-  const transport = target.protocol === "https:" ? httpsRequest : httpRequest;
+  const transport = target.protocol === "https:" ? httpsRequest2 : httpRequest2;
   const headers = {
     accept: "application/json"
   };
@@ -2086,14 +3075,15 @@ async function registerClient(apiBase, redirectUri) {
     );
   return record.client_id;
 }
-async function exchangeCode(apiBase, clientId, redirectUri, code, verifier) {
+async function exchangeCode(apiBase, clientId, redirectUri, code, verifier, resource) {
   return parseTokenSet(
     await postForm(apiBase, "/oauth/token", {
       grant_type: "authorization_code",
       code,
       redirect_uri: redirectUri,
       client_id: clientId,
-      code_verifier: verifier
+      code_verifier: verifier,
+      ...resource ? { resource } : {}
     })
   );
 }
@@ -2267,7 +3257,7 @@ function openBrowser(url) {
 }
 var cachedAccessToken;
 async function getAccessToken(options = {}) {
-  if (cachedAccessToken && cachedAccessToken.expiresAt - Date.now() > REFRESH_SKEW_MS)
+  if (cachedAccessToken && cachedAccessToken.expiresAt - Date.now() > REFRESH_SKEW_MS2)
     return cachedAccessToken.token;
   const config = await readConfig();
   const apiBase = resolveApiBase(options, config);
@@ -2313,22 +3303,15 @@ async function tryExistingSession(apiBase, config) {
     throw error;
   }
 }
-async function login(options) {
-  if (process.platform !== "darwin" && process.platform !== "linux")
-    throw new Error(
-      "UNSUPPORTED_PLATFORM: memroot login supports macOS and Linux."
-    );
-  assertCredentialStoreAvailable();
-  const config = await readConfig();
-  const apiBase = resolveApiBase(options, config);
-  if (!options.force && await tryExistingSession(apiBase, config)) return;
-  const state = randomBytes(24).toString("base64url");
-  const verifier = randomBytes(32).toString("base64url");
+async function authorizePkce(requestOptions) {
+  const { apiBase, resource } = requestOptions;
+  const state = randomBytes3(24).toString("base64url");
+  const verifier = randomBytes3(32).toString("base64url");
   const challenge = createHash2("sha256").update(verifier).digest("base64url");
   const waiter = await startCallbackServer(state, apiBase);
   try {
     const redirectUri = `http://127.0.0.1:${waiter.port}${CALLBACK_PATH}`;
-    let clientId = config.clientId && config.clientIdApiBase === apiBase ? config.clientId : STATIC_CLIENT_ID;
+    let clientId = requestOptions.clientId;
     let retriedWithRegistration = false;
     for (; ; ) {
       const authorize = new URL(`${apiBase}/authorize`);
@@ -2339,8 +3322,10 @@ async function login(options) {
       authorize.searchParams.set("code_challenge", challenge);
       authorize.searchParams.set("code_challenge_method", "S256");
       authorize.searchParams.set("scope", REQUESTED_SCOPE);
+      if (resource) authorize.searchParams.set("resource", resource);
       const url = authorize.toString();
-      if (options.noBrowser) console.log(`Open this URL to sign in:
+      if (requestOptions.noBrowser)
+        console.log(`Open this URL to sign in:
 ${url}`);
       else {
         openBrowser(url);
@@ -2357,31 +3342,22 @@ ${url}`
           clientId,
           redirectUri,
           result.code,
-          verifier
+          verifier,
+          resource
         );
         if (!tokens.refreshToken)
           throw new Error(
             "AUTH_RESPONSE_INVALID: The token endpoint returned no refresh token."
           );
-        await storeSecret(apiBase, tokens.refreshToken);
-        const claims = decodeClaims(tokens.accessToken);
-        const next = {
-          schemaVersion: 1,
-          apiBase,
-          clientId,
-          clientIdApiBase: apiBase
-        };
-        if (typeof claims?.sub === "string") next.userId = claims.sub;
-        await writeConfig(next);
-        console.log(
-          `Signed in to ${apiBase}${next.userId ? ` as ${next.userId}` : ""}.`
-        );
-        console.log(
-          "Refresh token stored in the OS credential store; no tokens were written to files."
-        );
-        return;
+        return { tokens, clientId };
       }
-      if ((result.error === "invalid_client" || result.error === "unauthorized_client") && !retriedWithRegistration) {
+      const rejectedClient = result.error === "invalid_client" || result.error === "unauthorized_client";
+      if (rejectedClient && !requestOptions.allowDcr)
+        throw new OAuthError(
+          result.error,
+          "CAPTURE_CLIENT_REJECTED: The server did not accept the Memroot CLI capture client. Update memroot and retry."
+        );
+      if (rejectedClient && !retriedWithRegistration) {
         retriedWithRegistration = true;
         const registered = await registerClient(apiBase, redirectUri);
         if (registered && registered !== clientId) {
@@ -2405,6 +3381,59 @@ ${url}`
     waiter.close();
   }
 }
+async function login(options) {
+  if (process.platform !== "darwin" && process.platform !== "linux")
+    throw new Error(
+      "UNSUPPORTED_PLATFORM: memroot login supports macOS and Linux."
+    );
+  assertCredentialStoreAvailable();
+  const config = await readConfig();
+  const apiBase = resolveApiBase(options, config);
+  if (!options.force && await tryExistingSession(apiBase, config)) return;
+  const { tokens, clientId } = await authorizePkce({
+    apiBase,
+    clientId: config.clientId && config.clientIdApiBase === apiBase ? config.clientId : STATIC_CLIENT_ID,
+    noBrowser: Boolean(options.noBrowser),
+    allowDcr: true
+  });
+  await storeSecret(apiBase, tokens.refreshToken);
+  const claims = decodeClaims(tokens.accessToken);
+  const next = {
+    schemaVersion: 1,
+    apiBase,
+    clientId,
+    clientIdApiBase: apiBase
+  };
+  if (typeof claims?.sub === "string") next.userId = claims.sub;
+  if (config.mcpRegistered) next.mcpRegistered = config.mcpRegistered;
+  await writeConfig(next);
+  console.log(
+    `Signed in to ${apiBase}${next.userId ? ` as ${next.userId}` : ""}.`
+  );
+  console.log(
+    "Refresh token stored in the OS credential store; no tokens were written to files."
+  );
+}
+function mcpCredentialAccount(apiBase) {
+  return `${apiBase}#mcp`;
+}
+async function loginMcp(apiBase, options = {}) {
+  assertCredentialStoreAvailable();
+  const { tokens } = await authorizePkce({
+    apiBase,
+    clientId: STATIC_CLIENT_ID,
+    noBrowser: Boolean(options.noBrowser),
+    resource: `${apiBase}/mcp`,
+    allowDcr: false
+  });
+  await storeSecret(
+    mcpCredentialAccount(apiBase),
+    tokens.refreshToken
+  );
+  console.log(
+    "Capture connection authorized; its refresh token is stored in the OS credential store."
+  );
+}
 async function logout(options) {
   const config = await readConfig();
   const apiBase = resolveApiBase(options, config);
@@ -2419,16 +3448,32 @@ async function logout(options) {
       );
     }
   }
-  try {
-    await deleteSecret(apiBase);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!message.startsWith("AUTH_KEYCHAIN_UNAVAILABLE")) throw error;
-    console.error(message);
+  const mcpStored = await readSecret(mcpCredentialAccount(apiBase)).catch(
+    () => void 0
+  );
+  if (mcpStored) {
+    try {
+      await revokeRefreshToken(apiBase, mcpStored, STATIC_CLIENT_ID);
+    } catch (error) {
+      console.error(
+        `AUTH_REVOKE_FAILED: ${error instanceof Error ? error.message : "revocation failed"} Removing the local capture credential anyway.`
+      );
+    }
+  }
+  for (const account of [apiBase, mcpCredentialAccount(apiBase)]) {
+    try {
+      await deleteSecret(account);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.startsWith("AUTH_KEYCHAIN_UNAVAILABLE")) throw error;
+      console.error(message);
+      break;
+    }
   }
   cachedAccessToken = void 0;
   const next = { schemaVersion: 1 };
   if (config.apiBase) next.apiBase = config.apiBase;
+  if (config.mcpRegistered) next.mcpRegistered = config.mcpRegistered;
   await writeConfig(next);
   console.log("Signed out. Stored credentials and client state were removed.");
 }
@@ -2476,6 +3521,7 @@ async function status(options) {
       );
     else console.log(`Cloud auth: ${message}`);
   }
+  for (const line of await captureReport({ probe: false })) console.log(line);
   const data = dataDirectory();
   console.log("Agents:");
   for (const agent of agents) {
@@ -2499,8 +3545,254 @@ async function status(options) {
         );
       }
     }
+    if (agent === "grok" && path) {
+      try {
+        console.log(`  ${describeGrokMcp(inspectGrokMcp(path))}`);
+      } catch {
+        console.log(
+          "  Grok MCP: status unavailable; memory verification: not verified."
+        );
+      }
+    }
+  }
+}
+
+// src/capture/queue/purge.ts
+import { join as join11 } from "node:path";
+function removeJobFiles(jobId) {
+  deleteJob(jobId);
+  const work = stateSubdir("work");
+  for (const name of listFiles(work))
+    if (name.startsWith(`${jobId}.`)) removeFile(join11(work, name));
+}
+function purgeQueue() {
+  const jobs = listJobIds();
+  for (const jobId of jobs) removeJobFiles(jobId);
+  const work = stateSubdir("work");
+  for (const name of listFiles(work)) removeFile(join11(work, name));
+  return jobs.length;
+}
+
+// src/capture/command.ts
+var CAPTURE_CONSENT_TEXT_V1 = `Memroot session capture (opt-in)
+
+What runs locally, after a coding session ends:
+  - The plugin's SessionEnd hook only records a small job (session id, transcript path, working directory).
+  - A bundled background worker reads only that session's transcript (user and assistant text, tool names and
+    file paths; never tool output), removes secrets, email addresses and home paths locally, and runs your own
+    agent CLI (Claude Code, Codex or Grok) headless, with no tools, to propose memories. This uses your agent
+    subscription or API quota and sends the redacted excerpt (at most 48,000 characters) to that agent's model
+    provider. Other agents' CLIs are never used unless you pass --allow-cross-agent-extraction.
+
+What leaves your machine for Memroot (https://api.memroot.dev):
+  - Typed memories (title, summary, assertions, entities such as repo-relative file paths and symbols), labeled
+    session-extracted, not user-attested, with confidence <= 0.7.
+  - Up to 3 short evidence quotes per memory (<= 200 characters each) copied from the redacted transcript.
+  - Your repository identity (normalized git remote such as github.com/org/repo), a salted hash of the session
+    id, salted hashes of the quoted transcript segments, and the extractor's name, prompt version and model.
+  - One retrieval query per session containing only the repository name, to avoid duplicating saved memories.
+  - Raw transcripts are never uploaded. At most 3 memories per session and 10 per rolling 24 hours.
+
+How to stop:
+  - memroot capture off (stops capture and deletes queued work, including work already in progress),
+    or revoke "Memroot CLI" in the console, or memroot logout.`;
+async function verifyConnection(apiBase) {
+  const broker = new TokenBroker(apiBase);
+  const status2 = await new McpClient(
+    apiBase,
+    broker,
+    `memroot-cli/${"0.1.0-alpha.3"}`
+  ).call("connection_status", {});
+  if (status2?.connected !== true)
+    throw new Error(
+      "CAPTURE_CONNECTION_UNVERIFIED: connection_status did not confirm the connection."
+    );
+}
+async function ensureCaptureConnection(apiBase, noBrowser) {
+  const stored = await readSecret(mcpAccount(apiBase));
+  if (stored) {
+    try {
+      await verifyConnection(apiBase);
+      return;
+    } catch (error) {
+      if (!(error instanceof AuthRequiredError)) {
+        if (error instanceof TransportError)
+          throw new Error(
+            `CAPTURE_CONNECTION_FAILED: ${error.code}. Check the network and retry.`
+          );
+        throw error;
+      }
+    }
+  }
+  await loginMcp(apiBase, { noBrowser });
+  await verifyConnection(apiBase);
+}
+async function captureOn(options) {
+  const config = await readConfig();
+  const apiBase = resolveApiBase(options.auth, config);
+  const agents2 = options.agents.length ? options.agents : [...CAPTURE_AGENTS];
+  console.log(CAPTURE_CONSENT_TEXT_V1);
+  console.log(`
+Agents: ${agents2.join(", ")}
+`);
+  if (!options.yes) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+      throw new Error(
+        "CONFIRMATION_REQUIRED: Noninteractive capture on requires --yes after reading the disclosure above."
+      );
+    const confirmed = await confirm({
+      message: "Enable automatic session capture for these agents?",
+      initialValue: false
+    });
+    if (isCancel(confirmed) || !confirmed) {
+      console.log("Session capture was not enabled. No changes made.");
+      return;
+    }
+  }
+  await ensureCaptureConnection(apiBase, options.noBrowser);
+  const previous = readConsent();
+  const base = previous.kind === "ok" ? previous.consent : void 0;
+  const consent = {
+    schemaVersion: 1,
+    enabled: true,
+    enabledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    consentTextVersion: CONSENT_TEXT_VERSION,
+    apiBase,
+    agents: agents2,
+    crossAgentExtraction: options.allowCrossAgent,
+    includeHeadlessSessions: base?.includeHeadlessSessions ?? false,
+    maxItemsPerSession: base?.maxItemsPerSession ?? DEFAULT_MAX_ITEMS_PER_SESSION,
+    maxItemsPerDay: base?.maxItemsPerDay ?? DEFAULT_MAX_ITEMS_PER_DAY,
+    models: base?.models ?? { claude: null, codex: null, grok: null }
+  };
+  writeConsent(consent);
+  console.log(`Session capture enabled for ${agents2.join(", ")}.`);
+  if (agents2.includes("codex"))
+    console.log(
+      "Codex: open /hooks in Codex and trust the Memroot SessionStart and SessionEnd hooks; until then Codex skips them."
+    );
+  if (agents2.includes("claude"))
+    console.log(
+      "Claude Code: restart running sessions to load the SessionEnd hook."
+    );
+}
+function captureOff() {
+  const previous = readConsent();
+  if (previous.kind === "ok")
+    writeConsent({ ...previous.consent, enabled: false });
+  const purged = pathExists(stateDir()) ? purgeQueue() : 0;
+  console.log(
+    `Session capture disabled. Removed ${purged} queued job${purged === 1 ? "" : "s"} and pending candidates.`
+  );
+  console.log(
+    'The server-side "Memroot CLI" connection stays authorized until memroot logout or revocation in the console.'
+  );
+}
+async function captureStatus() {
+  for (const line of await captureReport({ probe: true })) console.log(line);
+}
+
+// src/claude-mcp.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+var claudeMcpUrl = "https://api.memroot.dev/mcp";
+function command3(path, args, allowFailure = false) {
+  const result = spawnSync5(path, ["mcp", ...args], {
+    shell: false,
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 1024 * 1024,
+    stdio: "pipe"
+  });
+  if (result.error || result.status !== 0 && !allowFailure)
+    throw new Error(
+      "MCP_COMMAND_FAILED: Claude Code MCP command did not complete. Your configuration is preserved; retry memroot setup --agent claude --yes."
+    );
+  return result.status === 0 ? result.stdout ?? "" : "";
+}
+function inspectClaudeMcp(path) {
+  const output = command3(path, ["get", "memroot"], true);
+  if (!output) return { configured: false, authorized: false, verified: false };
+  const field = (name) => output.match(new RegExp(`^\\s*${name}:\\s*(.+)$`, "mi"))?.[1]?.trim();
+  if (field("Type") !== "http" || field("URL") !== claudeMcpUrl)
+    throw new Error(
+      "MCP_CONFLICT: Existing memroot MCP configuration differs from production. Inspect it with claude mcp get memroot; setup preserves your settings."
+    );
+  const status2 = field("Status") ?? "";
+  if (/needs authentication/i.test(status2))
+    return { configured: true, authorized: false, verified: false };
+  if (/connected/i.test(status2))
+    return { configured: true, authorized: true, verified: false };
+  throw new Error(
+    "MCP_AUTH_UNKNOWN: Claude Code could not establish memroot MCP status. Resolve it with /mcp in Claude Code; no replacement grant was requested."
+  );
+}
+function claudeMcpPreflight(path) {
+  const help2 = command3(path, ["add", "--help"]);
+  if (!help2.includes("--transport") || !help2.includes("--scope"))
+    throw new Error(
+      "MCP_UNSUPPORTED: Update Claude Code to a version supporting remote HTTP MCP setup."
+    );
+}
+function ensureClaudeMcp(options) {
+  if (options.dryRun)
+    return { configured: false, authorized: false, verified: false };
+  const path = executable("claude");
+  if (!path)
+    throw new Error(
+      "AGENT_NOT_FOUND: Install Claude Code before linking Memroot."
+    );
+  claudeMcpPreflight(path);
+  let state = inspectClaudeMcp(path);
+  if (!state.configured) {
+    command3(path, [
+      "add",
+      "--scope",
+      "user",
+      "--transport",
+      "http",
+      "memroot",
+      claudeMcpUrl
+    ]);
+    state = inspectClaudeMcp(path);
   }
+  return state;
+}
+function describeClaudeMcp(state) {
+  const auth = state.authorized ? "OAuth: authorized" : "OAuth: not authorized. Run /mcp in Claude Code and authenticate memroot";
+  return `Claude Code MCP: ${state.configured ? "configured" : "not configured"}; ${auth}; memory verification: not verified. Ask Claude Code to save and retrieve a test memory.`;
+}
+
+// src/messages.ts
+function setupComplete(selected) {
+  const parts = [];
+  if (selected.includes("claude"))
+    parts.push("Claude Code authorizes its MCP server through /mcp");
+  if (selected.includes("codex")) parts.push("Codex uses native MCP OAuth");
+  if (selected.includes("grok"))
+    parts.push("Grok authorizes its MCP server through /mcps");
+  return `Plugins ready. ${parts.join("; ")}.`;
+}
+function cloudNote(selected) {
+  const parts = [];
+  if (selected.includes("claude"))
+    parts.push(
+      "Claude Code setup registers the production MCP server; authorize it with /mcp in Claude Code"
+    );
+  if (selected.includes("codex"))
+    parts.push("Codex setup links production MCP through its browser sign-in");
+  if (selected.includes("grok"))
+    parts.push(
+      "Grok setup registers the production MCP server; authorize it with /mcps in Grok"
+    );
+  return `Cloud memory: ${parts.join(". ")}. Session capture: opt-in (memroot capture on).`;
+}
+function installationSummary(selected, data) {
+  return `${selected.map((agent) => labels[agent]).join(", ")}
+User scope \xB7 ${data}
+${selected.includes("grok") ? "Grok: trust this local Memroot plugin using native --trust.\n" : ""}${cloudNote(selected)}`;
 }
+var codexHookTrustStep = "Next step for Codex: open /hooks in Codex and trust the Memroot SessionStart and SessionEnd hooks. Until you do, Codex skips them, so sessions get no Memroot reminder.";
+var grokMcpAuthStep = "Next step for Grok: open Grok, run /mcps, select memroot and press i to sign in in the browser. Until you do, Grok has no Memroot memory tools. Skip this if memroot already shows as connected there.";
 
 // src/index.ts
 var installationDocs = {
@@ -2508,15 +3800,16 @@ var installationDocs = {
   codex: "https://developers.openai.com/codex/cli",
   grok: "https://docs.x.ai/build/overview"
 };
-var setupComplete = "Plugins ready. Codex uses native MCP OAuth; other agent adapters use memroot login.";
-var cloudStatus = "Cloud memory: Codex setup links production MCP through its browser sign-in. Other adapters use memroot login. Automatic session upload is not available.";
-var help = `Memroot ${version} \u2014 native agent plugin installer and cloud sign-in
+var cloudStatus = cloudNote(["claude", "codex", "grok"]);
+var help = `Memroot ${version} \u2014 native agent plugin installer, cloud sign-in and opt-in session capture
 
 Usage:
   npx memroot setup
   memroot setup --agent codex --yes
   memroot setup --agent claude --agent grok --yes --dry-run
   memroot login
+  memroot capture on
+  memroot capture status
   memroot doctor
   memroot status
 
@@ -2524,16 +3817,21 @@ Commands:
   setup       Install native plugins for your user account
   doctor      Check installer receipts and plugin file integrity
   login       Connect your Memroot account via browser sign-in
-  logout      Remove stored cloud credentials
+  logout      Remove stored cloud and capture credentials
   whoami      Show the signed-in account identity
-  status      Show cloud auth and agent install state
+  status      Show cloud auth, capture and agent install state
   token       Print a fresh access token for agent adapters
+  capture     on | off | status \u2014 opt-in session-end memory capture
 
 Options:
-  --agent       claude, codex, or grok; repeat to select more than one (setup, doctor)
-  --yes         Use the explicitly selected agents without prompts (setup)
+  --agent       claude, codex, or grok; repeat to select more than one (setup, doctor, capture on)
+  --yes         Use the explicitly selected agents without prompts (setup, capture on)
   --dry-run     Show planned changes without running agent CLIs or writing files (setup)
-  --no-browser  Print the sign-in URL instead of opening a browser (login)
+  --capture     Enable session capture after setup (runs the capture on flow)
+  --no-capture  Disable session capture during setup
+  --allow-cross-agent-extraction
+                Let capture fall back to another installed agent CLI (capture on)
+  --no-browser  Print the sign-in URL instead of opening a browser (login, capture on)
   --force       Re-authenticate even if credentials are still valid (login)
   --env         prod or dev; dev targets a local API stub on localhost:8787
   --api-base    Override the API base URL (MEMROOT_API_BASE also works)
@@ -2541,6 +3839,8 @@ Options:
   --version     Show version
 
 ${cloudStatus}
+Session capture runs your own agent CLI locally without tools after a session ends,
+redacts locally and uploads only typed, session-extracted memories.
 Grok setup trusts the selected local plugin via its native --trust option.
 Hook execution trust remains controlled by each agent.
 `;
@@ -2551,7 +3851,8 @@ var commands = [
   "logout",
   "whoami",
   "status",
-  "token"
+  "token",
+  "capture"
 ];
 var authCommands = [
   "login",
@@ -2561,22 +3862,35 @@ var authCommands = [
   "token"
 ];
 function parse(args) {
-  const command2 = args.shift();
-  if (!command2 || !commands.includes(command2))
+  const command4 = args.shift();
+  if (!command4 || !commands.includes(command4))
     throw new Error(
-      "INVALID_ARGUMENT: Choose setup, doctor, login, logout, whoami, status, or token. Run memroot --help."
+      "INVALID_ARGUMENT: Choose setup, doctor, login, logout, whoami, status, token, or capture. Run memroot --help."
     );
   const options = {
-    command: command2,
+    command: command4,
+    allowCrossAgent: false,
     selected: [],
     yes: false,
     dryRun: false,
     noBrowser: false,
     force: false
   };
+  if (command4 === "capture") {
+    const action = args.shift();
+    if (action !== "on" && action !== "off" && action !== "status")
+      throw new Error(
+        "INVALID_ARGUMENT: Use memroot capture on, off, or status."
+      );
+    options.captureAction = action;
+  }
   while (args.length) {
     const flag = args.shift();
     if (flag === "--yes") options.yes = true;
+    else if (flag === "--capture") options.capture = true;
+    else if (flag === "--no-capture") options.capture = false;
+    else if (flag === "--allow-cross-agent-extraction")
+      options.allowCrossAgent = true;
     else if (flag === "--dry-run") options.dryRun = true;
     else if (flag === "--no-browser") options.noBrowser = true;
     else if (flag === "--force") options.force = true;
@@ -2605,20 +3919,37 @@ function parse(args) {
         `INVALID_ARGUMENT: Unknown option ${flag}. Run memroot --help.`
       );
   }
-  if (authCommands.includes(command2)) {
+  if (options.capture !== void 0 && command4 !== "setup")
+    throw new Error(
+      "INVALID_ARGUMENT: --capture and --no-capture apply to setup."
+    );
+  if (options.allowCrossAgent && !(command4 === "capture" && options.captureAction === "on"))
+    throw new Error(
+      "INVALID_ARGUMENT: --allow-cross-agent-extraction applies to capture on."
+    );
+  if (command4 === "capture") {
+    if (options.captureAction !== "on" && (options.selected.length || options.yes || options.noBrowser))
+      throw new Error(
+        `INVALID_ARGUMENT: capture ${options.captureAction} takes no --agent, --yes or --no-browser.`
+      );
+    if (options.dryRun || options.force)
+      throw new Error(
+        "INVALID_ARGUMENT: capture does not support --dry-run or --force."
+      );
+  } else if (authCommands.includes(command4)) {
     if (options.selected.length || options.yes || options.dryRun)
       throw new Error(
-        `INVALID_ARGUMENT: ${command2} does not support --agent, --yes, or --dry-run.`
+        `INVALID_ARGUMENT: ${command4} does not support --agent, --yes, or --dry-run.`
       );
-    if (command2 !== "login" && (options.noBrowser || options.force))
+    if (command4 !== "login" && (options.noBrowser || options.force))
       throw new Error(
-        `INVALID_ARGUMENT: ${command2} does not support --no-browser or --force.`
+        `INVALID_ARGUMENT: ${command4} does not support --no-browser or --force.`
       );
-  } else if (options.noBrowser || options.force || options.env || options.apiBase)
+  } else if (options.force || (options.noBrowser || options.env || options.apiBase) && !(command4 === "setup" && options.capture === true))
     throw new Error(
-      `INVALID_ARGUMENT: ${command2} does not support cloud sign-in options.`
+      `INVALID_ARGUMENT: ${command4} does not support cloud sign-in options.`
     );
-  if (command2 === "doctor" && (options.yes || options.dryRun))
+  if (command4 === "doctor" && (options.yes || options.dryRun))
     throw new Error("INVALID_ARGUMENT: doctor supports only --agent.");
   return options;
 }
@@ -2648,6 +3979,10 @@ async function doctor(selected) {
       );
       if (agent === "codex" && path)
         console.log(describeCodexMcp(inspectCodexMcp(path)));
+      if (agent === "claude" && path)
+        console.log(describeClaudeMcp(inspectClaudeMcp(path)));
+      if (agent === "grok" && path)
+        console.log(describeGrokMcp(inspectGrokMcp(path)));
       if (!path) failures++;
     } catch (error) {
       failures++;
@@ -2657,6 +3992,7 @@ async function doctor(selected) {
     }
   }
   console.log(cloudStatus);
+  for (const line of await captureReport({ probe: false })) console.log(line);
   if (failures) process.exitCode = 1;
 }
 async function setup(options) {
@@ -2671,7 +4007,7 @@ async function setup(options) {
   if (interactive) {
     intro(`Memroot ${version}`);
     note(
-      "Install Memroot plugins for your coding agents.\nCodex setup opens browser sign-in for production memory.",
+      "Install Memroot plugins for your coding agents.\nProduction memory is linked through each agent's native sign-in.",
       "Set up your agents"
     );
     if (!options.selected.length) {
@@ -2706,9 +4042,7 @@ async function setup(options) {
       "CONFIRMATION_REQUIRED: Noninteractive setup requires --yes with explicit --agent selections."
     );
   const data = dataDirectory();
-  const summary = `${options.selected.map((agent) => labels[agent]).join(", ")}
-User scope \xB7 ${data}
-${options.selected.includes("grok") ? "Grok: trust this local Memroot plugin using native --trust.\n" : ""}${cloudStatus}`;
+  const summary = installationSummary(options.selected, data);
   if (options.dryRun) {
     console.log(`Dry run \u2014 no changes
 ${summary}`);
@@ -2716,10 +4050,26 @@ ${summary}`);
       console.log(
         `${agent}: ${JSON.stringify(installCommands(agent, `${data}/releases/${version}/${agent}`))}`
       );
+    if (options.selected.includes("claude"))
+      console.log(
+        `claude: mcp add --scope user --transport http memroot ${claudeMcpUrl}; authorize with /mcp.`
+      );
     if (options.selected.includes("codex"))
       console.log(
         `codex: mcp add memroot --url ${codexMcpUrl} --oauth-resource ${codexMcpUrl}; reuse existing OAuth authorization.`
       );
+    if (options.selected.includes("grok"))
+      console.log(
+        `grok: mcp add --scope user --transport http memroot ${grokMcpUrl}; authorize with /mcps in Grok.`
+      );
+    if (options.selected.includes("codex")) console.log(codexHookTrustStep);
+    if (options.selected.includes("grok")) console.log(grokMcpAuthStep);
+    if (options.capture === true)
+      console.log(
+        `capture: enable session capture for ${options.selected.join(", ")} (browser authorization of the Memroot CLI capture connection).`
+      );
+    else if (options.capture === false)
+      console.log("capture: disable session capture.");
     return;
   }
   if (interactive) {
@@ -2753,7 +4103,27 @@ ${summary}`);
         );
         if (agent === "codex")
           console.log(
-            describeCodexMcp(await ensureCodexMcp({ dryRun: false }))
+            describeCodexMcp(
+              await recordMcp("codex", () => ensureCodexMcp({ dryRun: false }))
+            )
+          );
+        if (agent === "claude")
+          console.log(
+            describeClaudeMcp(
+              await recordMcp(
+                "claude",
+                async () => ensureClaudeMcp({ dryRun: false })
+              )
+            )
+          );
+        if (agent === "grok")
+          console.log(
+            describeGrokMcp(
+              await recordMcp(
+                "grok",
+                async () => ensureGrokMcp({ dryRun: false })
+              )
+            )
           );
         continue;
       }
@@ -2785,13 +4155,93 @@ ${summary}`);
         `${labels[agent]}: plugin installed. Restart the agent to load it.`
       );
       if (agent === "codex")
-        console.log(describeCodexMcp(await ensureCodexMcp({ dryRun: false })));
+        console.log(
+          describeCodexMcp(
+            await recordMcp("codex", () => ensureCodexMcp({ dryRun: false }))
+          )
+        );
+      if (agent === "claude")
+        console.log(
+          describeClaudeMcp(
+            await recordMcp(
+              "claude",
+              async () => ensureClaudeMcp({ dryRun: false })
+            )
+          )
+        );
+      if (agent === "grok")
+        console.log(
+          describeGrokMcp(
+            await recordMcp(
+              "grok",
+              async () => ensureGrokMcp({ dryRun: false })
+            )
+          )
+        );
     }
   } finally {
     await release();
   }
-  if (interactive) outro(setupComplete);
-  else console.log(setupComplete);
+  await setupCapture(options, interactive);
+  if (options.selected.includes("codex")) console.log(codexHookTrustStep);
+  if (options.selected.includes("grok")) console.log(grokMcpAuthStep);
+  if (interactive) outro(setupComplete(options.selected));
+  else console.log(setupComplete(options.selected));
+}
+async function setupCapture(options, interactive) {
+  const auth = authOptions(options);
+  if (options.capture === false) {
+    captureOff();
+    return;
+  }
+  if (options.capture === true) {
+    await captureOn({
+      agents: options.selected,
+      allowCrossAgent: false,
+      yes: true,
+      noBrowser: options.noBrowser,
+      auth
+    });
+    return;
+  }
+  if (!interactive) return;
+  note(CAPTURE_CONSENT_TEXT_V1, "Session capture");
+  const enable = await confirm({
+    message: "Enable automatic session capture? You can change this later with memroot capture on|off.",
+    initialValue: false
+  });
+  if (isCancel(enable) || !enable) return;
+  await captureOn({
+    agents: options.selected,
+    allowCrossAgent: false,
+    yes: true,
+    noBrowser: false,
+    auth
+  });
+}
+async function recordMcp(agent, ensure) {
+  let state;
+  try {
+    state = await ensure();
+    return state;
+  } finally {
+    const config = await readConfig();
+    const registered = { ...config.mcpRegistered };
+    if (state?.configured) registered[agent] = true;
+    else delete registered[agent];
+    if (registered.claude || registered.codex || registered.grok)
+      config.mcpRegistered = registered;
+    else delete config.mcpRegistered;
+    await writeConfig(config);
+  }
+}
+function authOptions(options) {
+  const auth = {};
+  if (options.env) auth.env = options.env;
+  if (options.apiBase) auth.apiBase = options.apiBase;
+  if (options.noBrowser) auth.noBrowser = true;
+  if (options.force) auth.force = true;
+  return auth;
 }
 async function main() {
   const args = process.argv.slice(2);
@@ -2804,11 +4254,20 @@ async function main() {
     return;
   }
   const options = parse(args);
-  const auth = {};
-  if (options.env) auth.env = options.env;
-  if (options.apiBase) auth.apiBase = options.apiBase;
-  if (options.noBrowser) auth.noBrowser = true;
-  if (options.force) auth.force = true;
+  const auth = authOptions(options);
+  if (options.command === "capture") {
+    if (options.captureAction === "on")
+      await captureOn({
+        agents: options.selected,
+        allowCrossAgent: options.allowCrossAgent,
+        yes: options.yes,
+        noBrowser: options.noBrowser,
+        auth
+      });
+    else if (options.captureAction === "off") captureOff();
+    else await captureStatus();
+    return;
+  }
   if (options.command === "setup") await setup(options);
   else if (options.command === "doctor") await doctor(options.selected);
   else if (options.command === "login") await login(auth);