memroot 0.1.0-alpha.0 → 0.1.0-alpha.3

package/dist/index.js

@@ -1127,160 +1127,183 @@ var SELECT_INSTRUCTIONS = [
 ];
 var i = `${styleText("gray", S_BAR)}  `;
 
-// src/native.ts
+// src/auth.ts
+import { spawn } from "node:child_process";
+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/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/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"
-};
-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 {
-      }
-    }
+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;
   }
-  return void 0;
 }
-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.`
-    );
+
+// 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;
   }
-  return result.stdout;
+  code;
+};
+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 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 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 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 stateDir() {
+  return stateBoundary().dir;
 }
-function rows(output, field) {
-  let value;
+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);
+  }
+  const info = lstatSync(target);
+  if ((info.mode & 511) !== 448) chmodSync(target, 448);
+}
+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 {
-    value = JSON.parse(output);
-  } catch {
-    throw new Error(
-      "NATIVE_STATUS_UNSUPPORTED: Agent plugin status is not valid JSON. Update the agent CLI and retry."
-    );
+    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);
   }
-  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 readPrivateFileIfExists(path, maxBytes) {
   try {
-    return realpathSync(left) === realpathSync(right);
-  } catch {
-    return left === right;
+    return readPrivateFile(path, maxBytes);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    if (error.code === "ELOOP")
+      throw new UnsafePathError();
+    throw error;
   }
 }
-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, installed: matching.length > 0 };
+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 });
   }
-  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");
-  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."
-      );
+}
+function removeFile(path) {
+  rmSync(path, { force: true });
+}
+function listFiles(path) {
+  try {
+    assertRealDirectory(path);
+    return readdirSync(path).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
   }
-  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."
-      );
+}
+function pathExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
   }
-  return {
-    registered: matchingMarkets.length > 0,
-    installed: matchingPlugins.length > 0
-  };
 }
 
 // src/storage.ts
@@ -1295,12 +1318,12 @@ import {
   rm,
   writeFile
 } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+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.0";
+var version = "0.1.0-alpha.3";
 function dataDirectory() {
-  const base = process.platform === "win32" ? process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local") : process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share");
+  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(
       "INVALID_DATA_DIRECTORY: XDG_DATA_HOME or LOCALAPPDATA must be absolute."
@@ -1319,7 +1342,7 @@ async function exists(path) {
 async function safeDirectory(path) {
   const boundary = dataDirectory();
   if (path !== boundary && path.startsWith(`${boundary}/`))
-    await safeDirectory(dirname(path));
+    await safeDirectory(dirname2(path));
   await mkdir(path, { recursive: true, mode: 448 });
   const info = await lstat(path);
   if (!info.isDirectory() || info.isSymbolicLink())
@@ -1436,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)}
@@ -1483,111 +1506,2508 @@ async function acquireLock(data) {
   };
 }
 
-// src/index.ts
-var installationDocs = {
-  claude: "https://code.claude.com/docs/en/quickstart",
-  codex: "https://developers.openai.com/codex/cli",
-  grok: "https://docs.x.ai/build/overview"
-};
-var setupComplete = "Plugins ready. Cloud memory is not connected.";
-var cloudStatus = "Cloud memory: not connected. This installer alpha does not provide cloud authentication, memory retrieval, or session upload.";
-var help = `Memroot ${version} \u2014 native agent plugin installer
-
-Usage:
-  npx memroot setup
-  memroot setup --agent codex --yes
-  memroot setup --agent claude --agent grok --yes --dry-run
-  memroot doctor
-
-Commands:
-  setup       Install native plugins for your user account
-  doctor      Check installer receipts and plugin file integrity
-
-Options:
-  --agent     claude, codex, or grok; repeat to select more than one
-  --yes       Use the explicitly selected agents without interactive prompts
-  --dry-run   Show planned changes without running agent CLIs or writing files
-  --help      Show help
-  --version   Show version
-
-${cloudStatus}
-Grok setup trusts the selected local plugin via its native --trust option.
-Hook execution trust remains controlled by each agent.
-`;
-function parse(args) {
-  const command = args.shift();
-  if (command !== "setup" && command !== "doctor")
+// src/config.ts
+function configDirectory() {
+  return memrootConfigDir();
+}
+function configPath() {
+  return join3(configDirectory(), "config.json");
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function containsCredential(value) {
+  if (!value || typeof value !== "object") return false;
+  return Object.entries(value).some(
+    ([key, entry]) => /token|secret|password|credential|api[_-]?key/i.test(key) || containsCredential(entry)
+  );
+}
+async function migrateLegacy(record, raw) {
+  if (!(typeof record.user_id === "string" || typeof record.email === "string") || containsCredential(record) || record.apiBase !== void 0 && (typeof record.apiBase !== "string" || !isAllowedApiBase(record.apiBase)))
     throw new Error(
-      "INVALID_ARGUMENT: Choose setup or doctor. Run memroot --help."
+      "INVALID_CONFIG: Legacy config cannot be safely migrated. No credentials were imported."
     );
-  const options = { command, selected: [], yes: false, dryRun: false };
-  while (args.length) {
-    const flag = args.shift();
-    if (flag === "--yes") options.yes = true;
-    else if (flag === "--dry-run") options.dryRun = true;
-    else if (flag === "--agent") {
-      const value = args.shift();
-      if (!agents.includes(value))
-        throw new Error("INVALID_AGENT: Use claude, codex, or grok.");
-      if (!options.selected.includes(value))
-        options.selected.push(value);
-    } else
+  await safeDirectory(configDirectory());
+  const backup = `${configPath()}.legacy-backup`;
+  try {
+    await writeFile2(backup, raw, { flag: "wx", mode: 384 });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const info = await lstat2(backup);
+    if (!info.isFile() || info.isSymbolicLink() || await readFile2(backup, "utf8") !== raw)
       throw new Error(
-        `INVALID_ARGUMENT: Unknown option ${flag}. Run memroot --help.`
+        "INVALID_CONFIG: Legacy backup differs or is unsafe. Original config was preserved."
       );
+    await chmod(backup, 384);
   }
-  if (command === "doctor" && (options.yes || options.dryRun))
-    throw new Error("INVALID_ARGUMENT: doctor supports only --agent.");
-  return options;
+  const config = { schemaVersion: 1 };
+  await writeConfig(config);
+  return config;
 }
-async function doctor(selected) {
-  const data = dataDirectory();
-  let failures = 0;
-  for (const agent of selected.length ? selected : agents) {
-    const path = executable(agent);
-    try {
-      const receipt = await readReceipt(data, agent);
-      if (!receipt) {
-        console.log(
-          `${labels[agent]}: no installation receipt; CLI ${path ? "detected" : "not found"}.`
-        );
-        continue;
-      }
-      await verifyReceipt(receipt);
-      if (path) {
-        const state = inspectNative(path, agent, receipt.marketplace);
-        if (!state.installed)
-          throw new Error(
-            "PLUGIN_MISSING: Native plugin installation is absent. Run memroot setup again."
-          );
-      }
-      console.log(
-        `${labels[agent]}: plugin files verified (${receipt.version}); CLI ${path ? "detected" : "not found"}. ${path ? "Native plugin present" : "Native presence not verified"}; hook execution trust remains controlled by the agent.`
-      );
-      if (!path) failures++;
-    } catch (error) {
-      failures++;
-      console.error(
-        `${labels[agent]}: ${error instanceof Error ? error.message : "check failed"}`
-      );
-    }
+async function readConfig() {
+  const path = configPath();
+  let raw;
+  try {
+    const info = await lstat2(path);
+    if (!info.isFile() || info.isSymbolicLink())
+      throw new Error("INVALID_CONFIG: Expected a regular config file.");
+    raw = await readFile2(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { schemaVersion: 1 };
+    throw error;
   }
-  console.log(cloudStatus);
-  if (failures) process.exitCode = 1;
-}
-async function setup(options) {
-  if (process.platform !== "darwin" && process.platform !== "linux")
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
     throw new Error(
-      "UNSUPPORTED_PLATFORM: This installer alpha supports macOS and Linux. Windows support is not available yet."
+      "INVALID_CONFIG: ~/.memroot/config.json is not valid JSON. Fix or remove it."
     );
-  const found = new Map(agents.map((agent) => [agent, executable(agent)]));
-  const interactive = Boolean(
-    process.stdin.isTTY && process.stdout.isTTY && !options.yes && !options.dryRun
-  );
-  if (interactive) {
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("INVALID_CONFIG: Cannot safely read CLI config.");
+  const record = value;
+  if (record.schemaVersion === void 0) return migrateLegacy(record, raw);
+  const apiBase = optionalString(record.apiBase);
+  if (record.schemaVersion !== 1 || apiBase && !isAllowedApiBase(apiBase))
+    throw new Error("INVALID_CONFIG: Cannot safely read CLI config.");
+  const config = { schemaVersion: 1 };
+  if (apiBase) config.apiBase = apiBase;
+  const clientId = optionalString(record.clientId);
+  if (clientId) config.clientId = clientId;
+  const clientIdApiBase = optionalString(record.clientIdApiBase);
+  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) {
+  const directory = configDirectory();
+  await safeDirectory(directory);
+  const path = configPath();
+  const temporary = `${path}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile2(temporary, `${JSON.stringify(config, null, 2)}
+`, {
+      flag: "wx",
+      mode: 384
+    });
+    await rename2(temporary, path);
+    await chmod(path, 384);
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+}
+
+// src/credentials.ts
+var SERVICE = "memroot";
+var TOOL_TIMEOUT_MS = 15e3;
+function credentialStoreKind() {
+  const override = process.env.MEMROOT_TEST_CREDENTIAL_STORE;
+  if (override === "file" && process.env.NODE_ENV === "test")
+    return "test-file";
+  if (override)
+    throw new Error(
+      "INVALID_CREDENTIAL_STORE: MEMROOT_TEST_CREDENTIAL_STORE=file is honored only when NODE_ENV=test; refusing to file-back credentials."
+    );
+  return process.platform === "darwin" ? "macos-keychain" : "libsecret";
+}
+function unavailable(tool) {
+  return new Error(
+    `AUTH_KEYCHAIN_UNAVAILABLE: ${tool} is not installed, so there is no OS credential store for the Memroot refresh token. Tokens are never written to files; install ${tool === "security" ? "the macOS security tool" : "libsecret's secret-tool"} or sign in on a supported system.`
+  );
+}
+function run(tool, args, input, allowNotFound = false) {
+  const result = spawnSync(tool, args, {
+    encoding: "utf8",
+    input,
+    timeout: TOOL_TIMEOUT_MS,
+    shell: false,
+    maxBuffer: 1024 * 1024
+  });
+  if (result.error) {
+    if (result.error.code === "ENOENT")
+      throw unavailable(tool);
+    throw new Error(
+      `AUTH_KEYCHAIN_FAILED: ${tool} could not run (${result.error.code ?? "error"}).`
+    );
+  }
+  if (allowNotFound) return result;
+  if (result.status !== 0)
+    throw new Error(
+      `AUTH_KEYCHAIN_FAILED: ${tool} ${args[0] ?? ""} failed (${result.status ?? "signal"}). No credential was read or written.`
+    );
+  return result;
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+function testStorePath() {
+  return join4(configDirectory(), "test-credentials.json");
+}
+async function readTestStore() {
+  try {
+    const info = await lstat3(testStorePath());
+    if (!info.isFile() || info.isSymbolicLink())
+      throw new Error("INVALID_CREDENTIAL_STORE: Expected a regular file.");
+    const value = JSON.parse(await readFile3(testStorePath(), "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeTestStore(entries) {
+  const directory = configDirectory();
+  await safeDirectory(directory);
+  const path = testStorePath();
+  const temporary = `${path}.${process.pid}.tmp`;
+  try {
+    await writeFile3(temporary, `${JSON.stringify(entries, null, 2)}
+`, {
+      flag: "wx",
+      mode: 384
+    });
+    await rename3(temporary, path);
+    await chmod2(path, 384);
+  } finally {
+    await rm3(temporary, { force: true });
+  }
+}
+function assertCredentialStoreAvailable() {
+  const kind = credentialStoreKind();
+  if (kind === "test-file") return;
+  if (kind === "macos-keychain")
+    run(
+      "security",
+      ["find-generic-password", "-s", SERVICE, "-a", "memroot:probe"],
+      void 0,
+      true
+    );
+  else
+    run(
+      "secret-tool",
+      ["lookup", "service", SERVICE, "account", "memroot:probe"],
+      void 0,
+      true
+    );
+}
+async function storeSecret(account, secret) {
+  const kind = credentialStoreKind();
+  if (kind === "test-file") {
+    const entries = await readTestStore();
+    entries[account] = secret;
+    await writeTestStore(entries);
+    return;
+  }
+  if (kind === "macos-keychain") {
+    run(
+      "security",
+      ["-i"],
+      `add-generic-password -U -s ${quote(SERVICE)} -a ${quote(account)} -w ${quote(secret)}
+`
+    );
+    return;
+  }
+  run(
+    "secret-tool",
+    ["store", "--label", "Memroot CLI", "service", SERVICE, "account", account],
+    secret
+  );
+}
+async function readSecret(account) {
+  const kind = credentialStoreKind();
+  if (kind === "test-file") return (await readTestStore())[account];
+  if (kind === "macos-keychain") {
+    const result2 = run(
+      "security",
+      ["find-generic-password", "-s", SERVICE, "-a", account, "-w"],
+      void 0,
+      true
+    );
+    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(
+        "MCP_UNSUPPORTED: Update Grok to a version supporting remote HTTP MCP setup."
+      );
+  }
+}
+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."
+      );
+    }
+    if (!state.configured)
+      throw new Error(
+        "MCP_COMMAND_FAILED: Grok did not record the memroot MCP server. Retry memroot setup --agent grok --yes."
+      );
+  }
+  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
+var PROD_API_BASE = "https://api.memroot.dev";
+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_MS2 = 3e4;
+var REQUESTED_SCOPE = "memory.read memory.write";
+var OAuthError = class extends Error {
+  constructor(oauth, message) {
+    super(message);
+    this.oauth = oauth;
+  }
+  oauth;
+};
+function resolveApiBase(options, config) {
+  const base = options.apiBase ?? process.env.MEMROOT_API_BASE ?? (options.env ? options.env === "dev" ? DEV_API_BASE : PROD_API_BASE : void 0) ?? config.apiBase ?? PROD_API_BASE;
+  const normalized = base.replace(/\/+$/, "");
+  if (!isAllowedApiBase(normalized))
+    throw new Error(
+      "INSECURE_API_BASE: The API base must use https, or http only on a loopback address for local development."
+    );
+  return normalized;
+}
+function decodeClaims(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const claims = JSON.parse(
+      Buffer.from(parts[1] ?? "", "base64url").toString("utf8")
+    );
+    if (!claims || typeof claims !== "object" || Array.isArray(claims))
+      return void 0;
+    return claims;
+  } catch {
+    return void 0;
+  }
+}
+function claimsExpiry(claims) {
+  return typeof claims?.exp === "number" ? claims.exp * 1e3 : 0;
+}
+function parseTokenSet(body) {
+  if (typeof body.access_token !== "string" || !body.access_token)
+    throw new Error(
+      "AUTH_RESPONSE_INVALID: The token endpoint returned no access token."
+    );
+  const tokens = { accessToken: body.access_token };
+  if (typeof body.refresh_token === "string" && body.refresh_token)
+    tokens.refreshToken = body.refresh_token;
+  if (typeof body.expires_in === "number") tokens.expiresIn = body.expires_in;
+  return tokens;
+}
+var REQUEST_TIMEOUT_MS = 3e4;
+function request(target, method, contentType, payload) {
+  const transport = target.protocol === "https:" ? httpsRequest2 : httpRequest2;
+  const headers = {
+    accept: "application/json"
+  };
+  if (contentType) headers["content-type"] = contentType;
+  if (payload !== void 0)
+    headers["content-length"] = Buffer.byteLength(payload);
+  return new Promise((resolve, reject) => {
+    const request2 = transport(
+      target,
+      {
+        method,
+        agent: false,
+        timeout: REQUEST_TIMEOUT_MS,
+        headers
+      },
+      (response) => {
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          body += chunk;
+        });
+        response.on(
+          "end",
+          () => resolve({ status: response.statusCode ?? 0, body })
+        );
+      }
+    );
+    request2.on("timeout", () => request2.destroy(new Error("request timeout")));
+    request2.on(
+      "error",
+      () => reject(
+        new Error(
+          `AUTH_UNREACHABLE: Cannot reach ${target.origin}. Check the network connection and API base URL.`
+        )
+      )
+    );
+    request2.end(payload);
+  });
+}
+async function getJson(url) {
+  const response = await request(new URL(url), "GET");
+  if (response.status >= 400)
+    throw new Error(
+      `AUTH_METADATA_FAILED: ${url} returned ${response.status}.`
+    );
+  return parseJsonBody(response.body);
+}
+function parseJsonBody(text) {
+  let body;
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    body = void 0;
+  }
+  if (!body || typeof body !== "object" || Array.isArray(body))
+    throw new Error(
+      "AUTH_RESPONSE_INVALID: The server returned a malformed response."
+    );
+  return body;
+}
+function oauthFailure(record, status2) {
+  const code = typeof record.error === "string" ? record.error : `http_${status2}`;
+  const description = typeof record.error_description === "string" ? ` ${record.error_description}` : "";
+  return new OAuthError(code, `AUTH_TOKEN_REJECTED: ${code}.${description}`);
+}
+async function postForm(apiBase, path, params) {
+  const response = await request(
+    new URL(`${apiBase}${path}`),
+    "POST",
+    "application/x-www-form-urlencoded",
+    new URLSearchParams(params).toString()
+  );
+  let record = {};
+  try {
+    record = response.body ? parseJsonBody(response.body) : {};
+  } catch (error) {
+    if (response.status < 400) throw error;
+  }
+  if (response.status >= 400) throw oauthFailure(record, response.status);
+  return parseJsonBody(response.body);
+}
+async function registerClient(apiBase, redirectUri) {
+  const response = await request(
+    new URL(`${apiBase}/oauth/register`),
+    "POST",
+    "application/json",
+    JSON.stringify({
+      client_name: "Memroot CLI",
+      redirect_uris: [redirectUri],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      scope: REQUESTED_SCOPE
+    })
+  );
+  if (response.status === 404 || response.status === 405 || response.status === 501)
+    return void 0;
+  let record = {};
+  try {
+    record = parseJsonBody(response.body);
+  } catch {
+    record = {};
+  }
+  if (response.status >= 400) {
+    const code = typeof record.error === "string" ? record.error : `http_${response.status}`;
+    throw new OAuthError(
+      code,
+      `AUTH_REGISTRATION_FAILED: Client registration failed (${code}).`
+    );
+  }
+  if (typeof record.client_id !== "string" || !record.client_id)
+    throw new Error(
+      "AUTH_RESPONSE_INVALID: Client registration returned no client_id."
+    );
+  return record.client_id;
+}
+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,
+      ...resource ? { resource } : {}
+    })
+  );
+}
+async function revokeRefreshToken(apiBase, refreshToken, clientId) {
+  const metadata = await getJson(
+    `${apiBase}/.well-known/oauth-authorization-server`
+  );
+  const endpoint = metadata.revocation_endpoint;
+  if (typeof endpoint !== "string" || !endpoint || !isAllowedApiBase(endpoint))
+    throw new Error(
+      "AUTH_REVOKE_UNSUPPORTED: The server does not advertise a usable revocation endpoint."
+    );
+  const response = await request(
+    new URL(endpoint),
+    "POST",
+    "application/x-www-form-urlencoded",
+    new URLSearchParams({
+      token: refreshToken,
+      token_type_hint: "refresh_token",
+      client_id: clientId
+    }).toString()
+  );
+  if (response.status >= 400)
+    throw new Error(
+      `AUTH_REVOKE_FAILED: Revocation returned ${response.status}.`
+    );
+}
+async function refreshTokens(apiBase, refreshToken, clientId) {
+  try {
+    return parseTokenSet(
+      await postForm(apiBase, "/oauth/token", {
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: clientId
+      })
+    );
+  } catch (error) {
+    if (error instanceof OAuthError && error.oauth === "invalid_grant")
+      throw new OAuthError(
+        "invalid_grant",
+        "AUTH_EXPIRED: Stored credentials were rejected or expired. Run memroot login."
+      );
+    if (error instanceof OAuthError && error.oauth === "invalid_client")
+      throw new OAuthError(
+        "invalid_client",
+        "AUTH_INVALID_CLIENT: The stored client registration was rejected. Run memroot login."
+      );
+    throw error;
+  }
+}
+function page(title, detail) {
+  return `<!doctype html><html><head><meta charset="utf-8"><title>Memroot \u2014 ${title}</title></head><body><h1>${title}</h1><p>${detail}</p></body></html>`;
+}
+function startCallbackServer(expectedState, apiBase) {
+  let failure;
+  let timer;
+  const pending = [];
+  const waiters = [];
+  const deliver = (result) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter.resolve(result);
+    else pending.push(result);
+  };
+  const server = createServer((request2, response) => {
+    const url = new URL(request2.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== CALLBACK_PATH) {
+      response.writeHead(404).end("Not found");
+      return;
+    }
+    const errorParam = url.searchParams.get("error");
+    if (errorParam) {
+      const description = url.searchParams.get("error_description");
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(page("Sign-in failed", "Return to the terminal for details."));
+      deliver({
+        kind: "error",
+        error: errorParam,
+        ...typeof description === "string" ? { description } : {}
+      });
+      return;
+    }
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (!code || !state) {
+      response.writeHead(400).end("Missing code or state.");
+      return;
+    }
+    if (state !== expectedState) {
+      response.writeHead(400).end("State mismatch; rejected.");
+      return;
+    }
+    const issuer = url.searchParams.get("iss");
+    const issuerOrigin = (() => {
+      try {
+        return issuer ? new URL(issuer).origin : void 0;
+      } catch {
+        return void 0;
+      }
+    })();
+    if (!issuer || !issuerOrigin) {
+      response.writeHead(400).end("Missing or malformed issuer; rejected.");
+      deliver({ kind: "error", error: "iss_missing" });
+      return;
+    }
+    if (issuerOrigin !== new URL(apiBase).origin) {
+      response.writeHead(400).end("Issuer mismatch; rejected.");
+      deliver({ kind: "error", error: "iss_mismatch" });
+      return;
+    }
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(
+      page(
+        "Sign-in complete",
+        "You can close this tab and return to the terminal."
+      )
+    );
+    deliver({ kind: "code", code });
+  });
+  const fail = (error) => {
+    if (failure) return;
+    failure = error;
+    if (timer) clearTimeout(timer);
+    server.close();
+    server.closeAllConnections();
+    for (const waiter of waiters.splice(0)) waiter.reject(error);
+  };
+  timer = setTimeout(
+    () => fail(
+      new Error(
+        "AUTH_TIMEOUT: Timed out waiting for the browser sign-in callback. Retry memroot login."
+      )
+    ),
+    LOGIN_TIMEOUT_MS
+  );
+  return new Promise((resolve, reject) => {
+    server.once("error", (error) => {
+      fail(error);
+      reject(error);
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      resolve({
+        port: address.port,
+        next: () => {
+          if (failure) return Promise.reject(failure);
+          const queued = pending.shift();
+          if (queued) return Promise.resolve(queued);
+          const result = new Promise(
+            (resolve2, rejectPromise) => waiters.push({ resolve: resolve2, reject: rejectPromise })
+          );
+          result.catch(() => {
+          });
+          return result;
+        },
+        close: () => fail(new Error("AUTH_ABORTED: Sign-in was aborted."))
+      });
+    });
+  });
+}
+function openBrowser(url) {
+  const tool = process.platform === "darwin" ? "open" : "xdg-open";
+  try {
+    const child = spawn(tool, [url], {
+      detached: true,
+      stdio: "ignore",
+      shell: false
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+var cachedAccessToken;
+async function getAccessToken(options = {}) {
+  if (cachedAccessToken && cachedAccessToken.expiresAt - Date.now() > REFRESH_SKEW_MS2)
+    return cachedAccessToken.token;
+  const config = await readConfig();
+  const apiBase = resolveApiBase(options, config);
+  const stored = await readSecret(apiBase);
+  if (!stored)
+    throw new Error(
+      "AUTH_REQUIRED: Not signed in. Run memroot login to connect your account."
+    );
+  const clientId = config.clientId && config.clientIdApiBase === apiBase ? config.clientId : STATIC_CLIENT_ID;
+  const tokens = await refreshTokens(apiBase, stored, clientId);
+  if (tokens.refreshToken && tokens.refreshToken !== stored)
+    await storeSecret(apiBase, tokens.refreshToken);
+  const claims = decodeClaims(tokens.accessToken);
+  cachedAccessToken = {
+    token: tokens.accessToken,
+    expiresAt: claimsExpiry(claims) || Date.now() + (tokens.expiresIn ?? 0) * 1e3
+  };
+  if (typeof claims?.sub === "string" && claims.sub !== config.userId) {
+    config.userId = claims.sub;
+    await writeConfig(config);
+  }
+  return tokens.accessToken;
+}
+async function tryExistingSession(apiBase, config) {
+  const stored = await readSecret(apiBase);
+  if (!stored) return false;
+  const clientId = config.clientId && config.clientIdApiBase === apiBase ? config.clientId : STATIC_CLIENT_ID;
+  try {
+    const tokens = await refreshTokens(apiBase, stored, clientId);
+    if (tokens.refreshToken && tokens.refreshToken !== stored)
+      await storeSecret(apiBase, tokens.refreshToken);
+    const sub = decodeClaims(tokens.accessToken)?.sub;
+    console.log(
+      `Already signed in to ${apiBase}${typeof sub === "string" ? ` as ${sub}` : ""}. Use --force to re-authenticate.`
+    );
+    return true;
+  } catch (error) {
+    if (error instanceof OAuthError && (error.oauth === "invalid_grant" || error.oauth === "invalid_client")) {
+      await deleteSecret(apiBase).catch(() => {
+      });
+      return false;
+    }
+    throw error;
+  }
+}
+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 = requestOptions.clientId;
+    let retriedWithRegistration = false;
+    for (; ; ) {
+      const authorize = new URL(`${apiBase}/authorize`);
+      authorize.searchParams.set("response_type", "code");
+      authorize.searchParams.set("client_id", clientId);
+      authorize.searchParams.set("redirect_uri", redirectUri);
+      authorize.searchParams.set("state", state);
+      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 (requestOptions.noBrowser)
+        console.log(`Open this URL to sign in:
+${url}`);
+      else {
+        openBrowser(url);
+        console.log(
+          `Opening ${apiBase} for sign-in. If the browser did not open, visit:
+${url}`
+        );
+      }
+      console.log("Waiting for the browser sign-in callback\u2026");
+      const result = await waiter.next();
+      if (result.kind === "code") {
+        const tokens = await exchangeCode(
+          apiBase,
+          clientId,
+          redirectUri,
+          result.code,
+          verifier,
+          resource
+        );
+        if (!tokens.refreshToken)
+          throw new Error(
+            "AUTH_RESPONSE_INVALID: The token endpoint returned no refresh token."
+          );
+        return { tokens, clientId };
+      }
+      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) {
+          clientId = registered;
+          console.log(
+            "Client was not recognized; registered a fresh client and retrying sign-in."
+          );
+          continue;
+        }
+      }
+      if (result.error === "iss_missing" || result.error === "iss_mismatch")
+        throw new Error(
+          "AUTH_ISS_MISMATCH: The callback issuer is missing or does not match the API base. Retry memroot login."
+        );
+      throw new OAuthError(
+        result.error,
+        `AUTH_AUTHORIZATION_FAILED: ${result.error}${result.description ? ` \u2014 ${result.description}` : ""}`
+      );
+    }
+  } finally {
+    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);
+  const stored = await readSecret(apiBase).catch(() => void 0);
+  if (stored) {
+    const clientId = config.clientId && config.clientIdApiBase === apiBase ? config.clientId : STATIC_CLIENT_ID;
+    try {
+      await revokeRefreshToken(apiBase, stored, clientId);
+    } catch (error) {
+      console.error(
+        `AUTH_REVOKE_FAILED: ${error instanceof Error ? error.message : "revocation failed"} Removing local credentials anyway.`
+      );
+    }
+  }
+  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.");
+}
+async function whoami(options) {
+  const config = await readConfig();
+  const apiBase = resolveApiBase(options, config);
+  const token = await getAccessToken({ ...options, apiBase });
+  const claims = decodeClaims(token);
+  if (!claims)
+    throw new Error(
+      "AUTH_RESPONSE_INVALID: Could not decode the access token claims."
+    );
+  console.log(`Signed in to ${apiBase}`);
+  console.log(
+    `  sub: ${typeof claims.sub === "string" ? claims.sub : "unknown"}`
+  );
+  console.log(
+    `  iss: ${typeof claims.iss === "string" ? claims.iss : "unknown"}`
+  );
+  console.log(
+    `  exp: ${claimsExpiry(claims) ? new Date(claimsExpiry(claims)).toISOString() : "unknown"}`
+  );
+}
+async function printAccessToken(options) {
+  console.log(await getAccessToken(options));
+}
+async function status(options) {
+  const config = await readConfig();
+  const apiBase = resolveApiBase(options, config);
+  console.log(`API base: ${apiBase}`);
+  console.log(`Credential store: ${credentialStoreKind()}`);
+  try {
+    const token = await getAccessToken({ ...options, apiBase });
+    const claims = decodeClaims(token);
+    const subject = typeof claims?.sub === "string" ? claims.sub : config.userId ?? "unknown";
+    const expiry = claimsExpiry(claims) ? `; access token valid until ${new Date(claimsExpiry(claims)).toISOString()}` : "";
+    console.log(`Cloud auth: signed in as ${subject}${expiry}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("AUTH_REQUIRED"))
+      console.log("Cloud auth: not signed in. Run memroot login.");
+    else if (message.startsWith("AUTH_EXPIRED"))
+      console.log(
+        "Cloud auth: stored credentials were rejected. Run memroot login."
+      );
+    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) {
+    const path = executable(agent);
+    let detail = "no plugin receipt";
+    try {
+      const receipt = await readReceipt(data, agent);
+      if (receipt) detail = `plugin installed (${receipt.version})`;
+    } catch {
+      detail = "plugin receipt unreadable";
+    }
+    console.log(
+      `  ${labels[agent]}: ${path ? "CLI detected" : "CLI not found"}; ${detail}`
+    );
+    if (agent === "codex" && path) {
+      try {
+        console.log(`  ${describeCodexMcp(inspectCodexMcp(path))}`);
+      } catch {
+        console.log(
+          "  Codex MCP: status unavailable; memory verification: not verified."
+        );
+      }
+    }
+    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 = {
+  claude: "https://code.claude.com/docs/en/quickstart",
+  codex: "https://developers.openai.com/codex/cli",
+  grok: "https://docs.x.ai/build/overview"
+};
+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
+
+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 and capture credentials
+  whoami      Show the signed-in account identity
+  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, 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)
+  --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)
+  --help        Show help
+  --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.
+`;
+var commands = [
+  "setup",
+  "doctor",
+  "login",
+  "logout",
+  "whoami",
+  "status",
+  "token",
+  "capture"
+];
+var authCommands = [
+  "login",
+  "logout",
+  "whoami",
+  "status",
+  "token"
+];
+function parse(args) {
+  const command4 = args.shift();
+  if (!command4 || !commands.includes(command4))
+    throw new Error(
+      "INVALID_ARGUMENT: Choose setup, doctor, login, logout, whoami, status, token, or capture. Run memroot --help."
+    );
+  const options = {
+    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;
+    else if (flag === "--env") {
+      const value = args.shift();
+      if (value !== "prod" && value !== "dev")
+        throw new Error("INVALID_ARGUMENT: --env must be prod or dev.");
+      options.env = value;
+    } else if (flag === "--api-base") {
+      const value = args.shift();
+      try {
+        if (!value) throw new Error("missing");
+        new URL(value);
+      } catch {
+        throw new Error("INVALID_ARGUMENT: --api-base needs a valid URL.");
+      }
+      options.apiBase = value;
+    } else if (flag === "--agent") {
+      const value = args.shift();
+      if (!agents.includes(value))
+        throw new Error("INVALID_AGENT: Use claude, codex, or grok.");
+      if (!options.selected.includes(value))
+        options.selected.push(value);
+    } else
+      throw new Error(
+        `INVALID_ARGUMENT: Unknown option ${flag}. Run memroot --help.`
+      );
+  }
+  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: ${command4} does not support --agent, --yes, or --dry-run.`
+      );
+    if (command4 !== "login" && (options.noBrowser || options.force))
+      throw new Error(
+        `INVALID_ARGUMENT: ${command4} does not support --no-browser or --force.`
+      );
+  } else if (options.force || (options.noBrowser || options.env || options.apiBase) && !(command4 === "setup" && options.capture === true))
+    throw new Error(
+      `INVALID_ARGUMENT: ${command4} does not support cloud sign-in options.`
+    );
+  if (command4 === "doctor" && (options.yes || options.dryRun))
+    throw new Error("INVALID_ARGUMENT: doctor supports only --agent.");
+  return options;
+}
+async function doctor(selected) {
+  const data = dataDirectory();
+  let failures = 0;
+  for (const agent of selected.length ? selected : agents) {
+    const path = executable(agent);
+    try {
+      const receipt = await readReceipt(data, agent);
+      if (!receipt) {
+        console.log(
+          `${labels[agent]}: no installation receipt; CLI ${path ? "detected" : "not found"}.`
+        );
+        continue;
+      }
+      await verifyReceipt(receipt);
+      if (path) {
+        const state = inspectNative(path, agent, receipt.marketplace);
+        if (!state.installed)
+          throw new Error(
+            "PLUGIN_MISSING: Native plugin installation is absent. Run memroot setup again."
+          );
+      }
+      console.log(
+        `${labels[agent]}: plugin files verified (${receipt.version}); CLI ${path ? "detected" : "not found"}. ${path ? "Native plugin present" : "Native presence not verified"}; hook execution trust remains controlled by the agent.`
+      );
+      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++;
+      console.error(
+        `${labels[agent]}: ${error instanceof Error ? error.message : "check failed"}`
+      );
+    }
+  }
+  console.log(cloudStatus);
+  for (const line of await captureReport({ probe: false })) console.log(line);
+  if (failures) process.exitCode = 1;
+}
+async function setup(options) {
+  if (process.platform !== "darwin" && process.platform !== "linux")
+    throw new Error(
+      "UNSUPPORTED_PLATFORM: This installer alpha supports macOS and Linux. Windows support is not available yet."
+    );
+  const found = new Map(agents.map((agent) => [agent, executable(agent)]));
+  const interactive = Boolean(
+    process.stdin.isTTY && process.stdout.isTTY && !options.yes && !options.dryRun
+  );
+  if (interactive) {
     intro(`Memroot ${version}`);
     note(
-      "Install Memroot plugins for your coding agents.\nCloud memory connection is not available in this alpha.",
+      "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) {
@@ -1622,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}`);
@@ -1632,6 +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) {
@@ -1663,23 +4101,147 @@ ${summary}`);
         console.log(
           `${labels[agent]}: already installed; plugin files verified. Check native enablement in the agent.`
         );
+        if (agent === "codex")
+          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 })
+              )
+            )
+          );
         continue;
       }
-      const commands = installCommands(agent, candidate.marketplace);
-      if (state.registered && (!receipt || receipt.marketplace === candidate.marketplace))
-        commands.shift();
-      for (const args of commands)
+      const commands2 = installCommands(agent, candidate.marketplace);
+      if (agent === "codex" && receipt && state.registered && !state.currentMarketplace) {
+        const removeHelp = native(found.get(agent), agent, [
+          "plugin",
+          "marketplace",
+          "remove",
+          "--help"
+        ]);
+        if (!removeHelp.includes("--json"))
+          throw new Error(
+            "NATIVE_COMMAND_UNSUPPORTED: Update Codex to support marketplace remove --json before upgrading Memroot. The previous installation is preserved."
+          );
+        native(found.get(agent), agent, [
+          "plugin",
+          "marketplace",
+          "remove",
+          "memroot",
+          "--json"
+        ]);
+      }
+      if (state.currentMarketplace) commands2.shift();
+      for (const args of commands2)
         native(found.get(agent), agent, args);
       await writeReceipt(data, candidate);
       console.log(
         `${labels[agent]}: plugin installed. Restart the agent to load it.`
       );
+      if (agent === "codex")
+        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);
@@ -1692,12 +4254,31 @@ async function main() {
     return;
   }
   const options = parse(args);
-  if (options.command === "doctor") await doctor(options.selected);
-  else await setup(options);
+  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);
+  else if (options.command === "logout") await logout(auth);
+  else if (options.command === "whoami") await whoami(auth);
+  else if (options.command === "status") await status(auth);
+  else await printAccessToken(auth);
 }
 main().catch((error) => {
   console.error(
-    error instanceof Error ? error.message : "SETUP_FAILED: Unexpected installer failure."
+    error instanceof Error ? error.message : "MEMROOT_FAILED: Unexpected CLI failure."
   );
   process.exitCode = 1;
 });