forget-connect 0.5.2 → 0.6.1

package/src/cli.js

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import os from "node:os";
+import path from "node:path";
 import readline from "node:readline/promises";
 import { stdin, stdout, stderr } from "node:process";
 import {
@@ -20,12 +21,13 @@ import {
   validateScopeId,
   validateApiKey,
 } from "./core.js";
-import { doctorRemote } from "./doctor.js";
+import { CODEX_REQUIRED_TOOLS, doctorRemote } from "./doctor.js";
 import {
   commandsDirFor,
   connectHooksSettings,
   disconnectHooksSettings,
   hooksDirFor,
+  hooksInstalled,
   inspectHooks,
   installCommandAssets,
   installHookScripts,
@@ -33,6 +35,29 @@ import {
   removeHookScripts,
   settingsPathFor,
 } from "./hooks.js";
+import {
+  PROXY_BASE_URL,
+  PROXY_LABEL,
+  WATCHDOG_LABEL,
+  captureInfo,
+  legacyLine,
+  purgeCaptureBefore,
+  formatBytes,
+  purgeCapture,
+  findExecutable,
+  installProxyServices,
+  readWiringState,
+  removeProxyServices,
+  unwireProxyEnv,
+  wireProxyEnv,
+  writeWiringState,
+} from "./proxy.js";
+import {
+  inspectMemoryAgentSkill,
+  installMemoryAgentSkill,
+  removeMemoryAgentSkill,
+  skillDirFor,
+} from "./skills.js";
 
 const CLIENT_IDS = new Set(["claude-code", "codex", "claude-desktop"]);
 
@@ -44,6 +69,7 @@ Usage:
   forget-connect status [options]
   forget-connect doctor [options]
   forget-connect disconnect [options]
+  forget-connect capture purge --before <YYYY-MM-DD>   delete older capture day files (asks yes)
 
 Options:
   --client <ids>       Comma-separated: claude-code,codex,claude-desktop,all
@@ -55,13 +81,25 @@ Options:
 
 Scope:
   Local connections default to one canonical scoped endpoint (all clients share it):
-  /mcp/<client>/http/<os-username>. This keeps each user's and client's
-  memories isolated. Override with --user-id/--app-id, or opt out with
-  --no-scope. An explicit --url is installed verbatim.
+  /mcp/forget/http/<os-username>. This keeps each user's vault isolated while
+  Codex and Claude retain distinct provider profiles and provenance. Override
+  with --user-id/--app-id, or opt out with --no-scope. An explicit --url is
+  installed verbatim.
   --no-auth            Connect without a Bearer token
+  --local-auth         Send FORGET_API_KEY to an explicit loopback server
+                       (required by credential-bound Memory Agent tools)
   --no-rules           Do not manage CLAUDE.md or AGENTS.md instruction blocks
-  --no-hooks           Do not install Claude Code memory hooks (session capsule,
-                       per-turn recall, conflict alerts, session capture)
+  --no-skill           Do not install the shared Memory Agent skill
+  --no-hooks           Do not install Codex/Claude Code memory hooks (session
+                       capsule, per-turn recall, session capture)
+  --proxy              OPT-IN (macOS only): wire the local capture proxy (launchd
+                       service + ANTHROPIC_BASE_URL override + health watchdog).
+                       It records every Claude Code request and response
+                       (secret-scrubbed) in ~/.forget/proxy/stream/, kept 7 days,
+                       max 2 GB. Off unless you pass --proxy.
+  --no-proxy           Accepted for compatibility; the proxy is already off by default
+  --purge-capture      With disconnect: also delete ~/.forget/proxy/stream
+                       (otherwise only its size is reported and it is kept)
   --no-migrate-enacta  Keep matching legacy config and rules blocks
   --dry-run            Show the files that would change without writing them
   --timeout <seconds>  Doctor network timeout (default: 10)
@@ -73,6 +111,7 @@ Scope:
 Authentication:
   The default local server needs no token. For --hosted (legacy) set
   FORGET_API_KEY, or run interactively and paste the key when prompted.
+  Credential-bound local tools require FORGET_API_KEY plus --local-auth.
   Keys are intentionally not accepted as command-line arguments.
 
 Examples:
@@ -125,8 +164,12 @@ export function parseArgs(argv, env = process.env) {
     scope: null,
     defaultScope: null,
     auth: true,
+    localAuth: false,
     rules: true,
+    skills: true,
     hooks: true,
+    proxy: false,
+    purgeCapture: false,
     migrateLegacy: true,
     dryRun: false,
     yes: false,
@@ -139,9 +182,16 @@ export function parseArgs(argv, env = process.env) {
   let actionSeen = false;
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (["connect", "disconnect", "status", "doctor"].includes(arg) && !actionSeen) {
+    if (["connect", "disconnect", "status", "doctor", "capture"].includes(arg) && !actionSeen) {
       options.action = arg;
       actionSeen = true;
+    } else if (options.action === "capture" && arg === "purge") {
+      options.captureSub = "purge";
+    } else if (arg === "--before") {
+      options.before = requireValue(argv, index, arg);
+      index += 1;
+    } else if (arg.startsWith("--before=")) {
+      options.before = arg.slice("--before=".length);
     } else if (arg === "--client") {
       options.clientValues.push(requireValue(argv, index, arg));
       index += 1;
@@ -170,10 +220,20 @@ export function parseArgs(argv, env = process.env) {
       options.noScope = true;
     } else if (arg === "--no-auth") {
       options.auth = false;
+    } else if (arg === "--local-auth") {
+      options.localAuth = true;
     } else if (arg === "--no-rules") {
       options.rules = false;
+    } else if (arg === "--no-skill") {
+      options.skills = false;
     } else if (arg === "--no-hooks") {
       options.hooks = false;
+    } else if (arg === "--proxy") {
+      options.proxy = true;
+    } else if (arg === "--no-proxy") {
+      options.proxy = false;
+    } else if (arg === "--purge-capture") {
+      options.purgeCapture = true;
     } else if (arg === "--no-migrate-enacta") {
       options.migrateLegacy = false;
     } else if (arg === "--dry-run") {
@@ -211,6 +271,12 @@ export function parseArgs(argv, env = process.env) {
   }
   options.baseUrl = normalizeUrl(options.url);
   options.hosted = isHostedBaseUrl(options.baseUrl);
+  if (options.localAuth && !options.auth) {
+    throw new ConfigError("--local-auth and --no-auth are mutually exclusive.");
+  }
+  if (options.localAuth && !isLoopbackUrl(options.baseUrl)) {
+    throw new ConfigError("--local-auth is only allowed for a loopback MCP URL.");
+  }
   if (Boolean(options.userId) !== Boolean(options.appId)) {
     throw new ConfigError("--user-id and --app-id must be provided together.");
   }
@@ -226,12 +292,10 @@ export function parseArgs(argv, env = process.env) {
   options.url = options.scope
     ? scopedMcpUrl(options.baseUrl, options.scope)
     : options.baseUrl;
-  // Cold-install default: scope each client into its own memory pool at
-  // /mcp/<client>/http/<os-username>. The unscoped /mcp endpoint pools every
-  // client's memories into the server's fallback scope (cold-install audit
-  // 2026-07-29), so plain /mcp is now the opt-in (--no-scope), not the
-  // default. An explicit --url stays verbatim, and hosted keeps requiring an
-  // explicit account identity — the OS username is not a hosted account.
+  // Cold-install default: all providers use one personal vault at
+  // /mcp/forget/http/<os-username>; the query profile keeps their tool surface
+  // and provenance separate. The unscoped /mcp endpoint pools data into the
+  // server fallback, so it remains an explicit opt-in (--no-scope).
   options.defaultScope = null;
   if (!options.scope && !options.noScope && !options.hosted && !options.urlExplicit) {
     const osUser = defaultScopeUserId(env);
@@ -259,17 +323,23 @@ function defaultScopeUserId(env) {
 }
 
 export function urlForClient(options, client) {
-  if (options.scope) return options.url;
+  let resolved = options.url;
+  if (options.scope) resolved = options.url;
   if (options.defaultScope && client) {
     // Every client shares the canonical pool; which tool wrote a memory is
     // provenance, not a scope boundary (issue #27). A per-client pool made
     // Codex writes invisible to Claude and vice versa.
-    return scopedMcpUrl(options.baseUrl, {
+    resolved = scopedMcpUrl(options.baseUrl, {
       userId: options.defaultScope.userId,
       appId: CANONICAL_APP_ID,
     });
   }
-  return options.url;
+  if (client?.id === "codex" || client?.id === "claude-code") {
+    const parsed = new URL(normalizeUrl(resolved));
+    parsed.searchParams.set("profile", client.id === "codex" ? "codex" : "claude");
+    return parsed.toString().replace(/\/$/, "");
+  }
+  return resolved;
 }
 
 function requestedClientIds(values) {
@@ -379,6 +449,16 @@ function isLoopbackUrl(value) {
   return LOOPBACK_HOSTS.has(new URL(value).hostname.toLowerCase());
 }
 
+export async function readLocalApiKey(env = process.env) {
+  // $FORGET_HOME/api-key is written (0600) by `forget install-service`.
+  const home = env.FORGET_HOME || path.join(env.HOME ?? env.USERPROFILE ?? os.homedir(), ".forget");
+  try {
+    return (await readFile(path.join(home, "api-key"), "utf8")).trim();
+  } catch {
+    return "";
+  }
+}
+
 async function apiKeyFor(options, env) {
   if (!["connect", "doctor"].includes(options.action) || !options.auth || options.dryRun) return "";
   const fromEnv = env.FORGET_API_KEY?.trim();
@@ -389,12 +469,23 @@ async function apiKeyFor(options, env) {
         "Bearer authentication requires HTTPS. Use --no-auth for a local HTTP server.",
       );
     }
-    // A leftover hosted key must not block the local-first default flow, and
-    // a loopback target never puts the secret on the wire anyway.
+    if (options.localAuth) return validateApiKey(fromEnv);
+    // A leftover hosted key must not silently become a local credential.
+    // Credential-bound local features opt in with --local-auth.
     stderr.write(
       "Note: FORGET_API_KEY is set but the target is a loopback HTTP server; connecting without a token.\n",
     );
   }
+  // Local server: send the install's own key. Harmless while the server does
+  // not require auth, and required once it does (phase 2). Not used by doctor,
+  // which checks it separately and only warns.
+  if (!options.hosted && isLoopbackUrl(options.url) && options.action === "connect") {
+    const localKey = await readLocalApiKey(env);
+    if (localKey) return validateApiKey(localKey);
+  }
+  if (options.localAuth) {
+    throw new ConfigError("Set FORGET_API_KEY when using --local-auth.");
+  }
   if (!options.hosted) return "";
   const prompted = (await promptHidden("Paste your Forget API key: ")).trim();
   if (!prompted) {
@@ -445,7 +536,13 @@ function printDoctor(result) {
     const hooksDetail = result.hooks.registered
       ? `registered, scripts ${result.hooks.scripts_present ? "present" : "missing"}, python3 ${result.hooks.python3 ? "ok" : "missing"}`
       : "not installed (use connect without --no-hooks)";
-    stdout.write(`${result.hooks.ok ? "✓" : "✗"} Hooks: ${hooksDetail}\n`);
+    stdout.write(`${result.hooks.ok ? "✓" : "✗"} Claude Code hooks: ${hooksDetail}\n`);
+  }
+  if (result.codex_hooks) {
+    const hooksDetail = result.codex_hooks.registered
+      ? `registered, scripts ${result.codex_hooks.scripts_present ? "present" : "missing"}, python3 ${result.codex_hooks.python3 ? "ok" : "missing"}`
+      : "not installed (use connect without --no-hooks)";
+    stdout.write(`${result.codex_hooks.ok ? "✓" : "✗"} Codex hooks: ${hooksDetail}\n`);
   }
   for (const client of result.clients) {
     const details = [
@@ -465,6 +562,30 @@ function printDoctor(result) {
     }
     stdout.write(`${client.ok ? "✓" : "✗"} ${client.name}: ${details.join(", ")}\n`);
   }
+  if (result.capture) {
+    const c = result.capture;
+    const state = c.service_wired ? (c.capture_env ? "ON" : "passthrough (capture off)") : "off (proxy not installed)";
+    stdout.write(`${c.service_wired ? "!" : "○"} Capture proxy: ${state}\n`);
+    if (c.exists) {
+      stdout.write(`  folder ${c.dir}: ${formatBytes(c.bytes)} in ${c.files} day file(s), oldest ${c.oldest ?? "-"}, retention ${c.retention_days} days, cap ${formatBytes(c.max_bytes)}\n`);
+      const legacy = legacyLine(c);
+      if (legacy) stdout.write(`  ${legacy}\n`);
+      if (!c.service_wired && c.files) {
+        stdout.write("  not being written to now; delete with: forget-connect disconnect --purge-capture\n");
+      }
+    } else {
+      stdout.write("  no capture folder\n");
+    }
+  }
+  const aw = result.auth_warnings;
+  if (aw?.server_has_key && (aw.clients_without_key.length || aw.hooks_without_key)) {
+    const who = [...aw.clients_without_key, ...(aw.hooks_without_key ? ["hooks"] : [])].join(", ");
+    stdout.write(
+      `! Local API key: the server has a key ($FORGET_HOME/api-key) but ${who} do not send it.\n`
+      + "  Auth is not required yet, so nothing is broken. It will be required in a later release;\n"
+      + "  run `npx forget-connect` (connect) again to update clients and hooks.\n",
+    );
+  }
   if (result.remote.skipped) {
     stdout.write("○ MCP: not checked until local configuration is fixed\n");
     return;
@@ -483,6 +604,67 @@ function printDoctor(result) {
   }
 }
 
+async function confirmYes(question) {
+  if (!(stdin.isTTY && stdout.isTTY)) return false;
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function runCapturePurge(options, env) {
+  if (options.captureSub !== "purge" || !options.before) {
+    throw new ConfigError("Usage: forget-connect capture purge --before <YYYY-MM-DD>");
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(options.before)) {
+    throw new ConfigError("--before needs a date like 2026-10-01");
+  }
+  const info = await captureInfo({ env });
+  if (!info.exists || !info.files) {
+    stdout.write("No capture files.\n");
+    return;
+  }
+  stdout.write(`Capture folder ${info.dir}: ${formatBytes(info.bytes)}, ${info.files} day file(s), ${info.oldest}~${info.newest}\n`);
+  stdout.write(`Will delete every day file dated before ${options.before}.\n`);
+  if (!(await confirmYes("Delete them? [y/N] "))) {
+    stdout.write("Nothing deleted (an interactive yes is required).\n");
+    return;
+  }
+  const removed = await purgeCaptureBefore({ env }, options.before);
+  stdout.write(`Deleted ${removed.length} file(s).\n`);
+}
+
+// Disconnect never deletes captured conversations silently: it reports the
+// size, and deletes only with --purge-capture or an interactive "yes".
+async function reportCapture(options, env) {
+  const info = await captureInfo({ env });
+  if (!info.exists || !info.files) return;
+  stdout.write(
+    `  capture folder kept: ${info.dir} (${formatBytes(info.bytes)}, ${info.files} day file(s), oldest ${info.oldest})\n`,
+  );
+  const legacy = legacyLine(info);
+  if (legacy) stdout.write(`  ${legacy}\n`);
+  let purge = options.purgeCapture;
+  if (!purge && stdin.isTTY && stdout.isTTY) {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+      const answer = (await rl.question("Delete these captured conversations now? [y/N] ")).trim().toLowerCase();
+      purge = answer === "y" || answer === "yes";
+    } finally {
+      rl.close();
+    }
+  }
+  if (purge) {
+    await purgeCapture({ env });
+    stdout.write(`  deleted ${info.dir}\n`);
+  } else {
+    stdout.write("  to delete it: forget-connect disconnect --purge-capture\n");
+  }
+}
+
 async function version() {
   const raw = await readFile(new URL("../package.json", import.meta.url), "utf8");
   return JSON.parse(raw).version;
@@ -499,6 +681,11 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
     return;
   }
 
+  if (options.action === "capture") {
+    await runCapturePurge(options, env);
+    return;
+  }
+
   const allClients = getClients({ env });
   const clients = await selectClients(options, allClients);
   if (options.action === "status") {
@@ -524,7 +711,13 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
       }
       const installed = scopeFromUrl(configuredServerUrl(client, raw));
       if (!installed) continue;
-      urlOverrides.set(client.id, scopedMcpUrl(installed.baseUrl, installed));
+      const installedScopedUrl = scopedMcpUrl(installed.baseUrl, installed);
+      urlOverrides.set(client.id, urlForClient({
+        ...options,
+        url: installedScopedUrl,
+        scope: installed,
+        defaultScope: null,
+      }, client));
       if (!first) first = installed;
     }
     if (first) {
@@ -543,8 +736,19 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
   if (options.action === "doctor") {
     const probeUrl = clients.length ? urlFor(clients[0]) : options.url;
     const probeScope = options.scope ?? scopeFromUrl(probeUrl);
+    // The server may hold a key (install-service wrote one). Clients that
+    // already send it are fine; clients that don't only get a warning.
+    const localKey = isLoopbackUrl(probeUrl) && !options.hosted ? await readLocalApiKey(env) : "";
+    const plainStatuses = await inspectClients(clients, { url: options.url, apiKey, urlFor });
+    const withKey = localKey
+      ? await inspectClients(clients, { url: options.url, apiKey: localKey, urlFor })
+      : [];
     const local = localDoctorResults(
-      await inspectClients(clients, { url: options.url, apiKey, urlFor }),
+      plainStatuses.map((s, i) => (
+        localKey && withKey[i]?.authMatches && !s.authMatches
+          ? { ...s, authMatches: true, transportValid: s.transportValid || withKey[i].transportValid }
+          : s
+      )),
       { requireRules: options.rules },
     );
     const remote = local.every((client) => client.ok)
@@ -555,6 +759,7 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
         clientVersion: await version(),
         expectedScope: probeScope,
         requireScope: options.hosted,
+        ...(clients[0]?.id === "codex" ? { requiredTools: CODEX_REQUIRED_TOOLS } : {}),
       })
       : {
         ok: false,
@@ -574,16 +779,40 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
           skipped: true,
         },
       };
+    const keyWarnings = [];
+    if (localKey) {
+      withKey.forEach((item) => {
+        if (item.config && !item.authMatches) keyWarnings.push(item.client.name);
+      });
+    }
     const hooksStatus = clients.some((client) => client.id === "claude-code")
-      ? await inspectHooks({ env })
+      ? await inspectHooks({ env, clientId: "claude-code" })
+      : null;
+    const codexHooksStatus = clients.some((client) => client.id === "codex")
+      ? await inspectHooks({ env, clientId: "codex" })
       : null;
+    const skillStatus = await Promise.all(
+      clients
+        .filter((client) => ["claude-code", "codex"].includes(client.id))
+        .map(async (client) => ({ client: client.id, ...await inspectMemoryAgentSkill(client.id, { env }) })),
+    );
     const result = {
-      ok: local.every((client) => client.ok) && remote.ok && (hooksStatus?.ok ?? true),
+      ok: local.every((client) => client.ok) && remote.ok
+        && (hooksStatus?.ok ?? true) && (codexHooksStatus?.ok ?? true)
+        && (!options.skills || skillStatus.every((skill) => skill.installed && skill.current)),
       url: redactUrlForDisplay(probeUrl),
       scope: { configured: Boolean(probeScope) },
       clients: local,
+      auth_warnings: {
+        server_has_key: Boolean(localKey),
+        clients_without_key: keyWarnings,
+        hooks_without_key: [hooksStatus, codexHooksStatus].some((h) => h && h.sends_key === false),
+      },
       hooks: hooksStatus,
+      codex_hooks: codexHooksStatus,
+      skills: skillStatus,
       remote,
+      capture: await captureInfo({ env }),
     };
     if (options.json) stdout.write(`${JSON.stringify(result)}\n`);
     else printDoctor(result);
@@ -598,12 +827,15 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
     migrateLegacy: options.migrateLegacy,
     legacyUrls: [...new Set([options.url, options.baseUrl, HOSTED_MCP_URL])],
   });
+  const skillClients = clients.filter((client) => ["claude-code", "codex"].includes(client.id));
+  const manageSkills = skillClients.length > 0
+    && (options.action === "disconnect" || options.skills);
 
-  // Claude Code is the only client with a hook system today; the hooks are
-  // what make memory arrive without being asked. Disconnect always cleans
-  // them up, even when the install used --no-hooks.
+  // Codex and Claude Code use different lifecycle event sets but share the
+  // same fail-open scripts. Disconnect removes only our entries.
   const claudeCode = clients.find((client) => client.id === "claude-code");
-  let manageHooks = Boolean(claudeCode)
+  const hookClients = clients.filter((client) => ["claude-code", "codex"].includes(client.id));
+  let manageHooks = hookClients.length > 0
     && (options.action === "disconnect" || options.hooks);
   if (manageHooks && process.platform === "win32" && options.action === "connect") {
     // The hook commands are POSIX shell strings and the scripts need
@@ -611,33 +843,112 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
     stderr.write("Note: memory hooks are not yet supported on Windows; skipping hook install.\n");
     manageHooks = false;
   }
+  // The capture proxy (zero-config memory capture) rides the same
+  // settings.json: env.ANTHROPIC_BASE_URL points Claude Code at the local
+  // forget-proxy. launchd-only for now, so connect wires it on macOS;
+  // disconnect always unwires — a no-op wherever connect never ran.
+  let manageProxy = Boolean(claudeCode)
+    && (options.action === "disconnect" || options.proxy);
+  if (manageProxy && options.action === "connect" && process.platform !== "darwin") {
+    stderr.write("Note: the capture proxy service requires launchd (macOS); skipping proxy wiring.\n");
+    manageProxy = false;
+  }
+  if (manageProxy && options.action === "connect" && !options.dryRun
+    && !(await findExecutable("forget-proxy", { env }))) {
+    // Checked before any file changes: an env override pointing at a proxy
+    // that cannot start would break the user's Claude, not just capture.
+    stderr.write("Note: forget-proxy not found on PATH; skipping proxy wiring (pip install 'forget-ai[server]').\n");
+    manageProxy = false;
+  }
+
   const hooksDir = manageHooks ? hooksDirFor({ env }) : "";
+  const hookSettings = new Map();
+  let proxyPlan = null;
   if (manageHooks) {
-    const settingsPath = settingsPathFor({ env });
-    let settingsRaw = "";
-    try {
-      settingsRaw = await readFile(settingsPath, "utf8");
-    } catch (error) {
-      if (!error || error.code !== "ENOENT") throw error;
-    }
-    const settingsNext = options.action === "connect"
-      ? connectHooksSettings(settingsRaw, { hooksDir, url: urlFor(claudeCode) })
-      : disconnectHooksSettings(settingsRaw);
-    if (settingsRaw !== settingsNext) {
+    for (const client of hookClients) {
+      const settingsPath = settingsPathFor({ env, clientId: client.id });
+      let settingsRaw = "";
+      try {
+        settingsRaw = await readFile(settingsPath, "utf8");
+      } catch (error) {
+        if (!error || error.code !== "ENOENT") throw error;
+      }
+      const settingsNext = options.action === "connect"
+        ? connectHooksSettings(settingsRaw, {
+          hooksDir,
+          url: urlFor(client),
+          clientId: client.id,
+        })
+        : disconnectHooksSettings(settingsRaw, { clientId: client.id });
+      hookSettings.set(client.id, { client, settingsPath, settingsRaw, settingsNext });
+    }
+  }
+  if (manageProxy) {
+    const settingsPath = settingsPathFor({ env, clientId: "claude-code" });
+    let record = hookSettings.get("claude-code");
+    if (!record) {
+      let settingsRaw = "";
+      try {
+        settingsRaw = await readFile(settingsPath, "utf8");
+      } catch (error) {
+        if (!error || error.code !== "ENOENT") throw error;
+      }
+      record = { client: claudeCode, settingsPath, settingsRaw, settingsNext: settingsRaw };
+    }
+    let settingsNext = record.settingsNext;
+    if (manageProxy && options.action === "connect") {
+      proxyPlan = wireProxyEnv(settingsNext);
+      if (proxyPlan.status === "skip") {
+        // (c) an odd configuration skips the whole wiring, loudly — being
+        // invisible must never mean silently breaking the user's setup.
+        stderr.write(`Warning: ${proxyPlan.reason}; skipping proxy wiring. Nothing was changed.\n`);
+        manageProxy = false;
+        proxyPlan = null;
+      } else {
+        settingsNext = proxyPlan.next;
+      }
+    }
+    if (manageProxy && options.action === "disconnect") {
+      const wiring = await readWiringState({ env });
+      settingsNext = unwireProxyEnv(settingsNext, {
+        original: wiring?.original_base_url ?? null,
+      }).next;
+    }
+    hookSettings.set("claude-code", { ...record, settingsNext });
+  }
+  for (const record of hookSettings.values()) {
+    if (record.settingsRaw !== record.settingsNext) {
       changes.push({
-        client: claudeCode,
-        filePath: settingsPath,
-        before: settingsRaw,
-        after: settingsNext,
-        kind: "hooks",
+        client: record.client,
+        filePath: record.settingsPath,
+        before: record.settingsRaw,
+        after: record.settingsNext,
+        kind: "settings",
         sensitive: false,
         backup: options.action === "connect",
       });
     }
   }
+  let removeSharedHookScripts = false;
+  if (manageHooks && options.action === "disconnect") {
+    let anyRegistered = false;
+    for (const clientId of ["claude-code", "codex"]) {
+      const staged = hookSettings.get(clientId);
+      let raw = staged?.settingsNext ?? "";
+      if (!staged) {
+        try {
+          raw = await readFile(settingsPathFor({ env, clientId }), "utf8");
+        } catch (error) {
+          if (!error || error.code !== "ENOENT") throw error;
+        }
+      }
+      if (hooksInstalled(raw, { hooksDir, clientId })) anyRegistered = true;
+    }
+    removeSharedHookScripts = !anyRegistered;
+  }
 
   if (options.dryRun) {
-    if (!changes.length && !manageHooks) {
+    if (!changes.length && !manageHooks && !manageProxy && !manageSkills) {
       stdout.write("No changes needed.\n");
       return;
     }
@@ -646,29 +957,91 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
     }
     if (manageHooks && options.action === "connect") {
       stdout.write(`Would install hook scripts into ${hooksDir}\n`);
-      stdout.write(`Would install slash commands (/forget, /forget-settings) into ${commandsDirFor({ env })}\n`);
+      if (claudeCode) {
+        stdout.write(`Would install slash commands (/forget, /forget-settings) into ${commandsDirFor({ env })}\n`);
+      }
     }
     if (manageHooks && options.action === "disconnect") {
-      stdout.write(`Would remove hook scripts from ${hooksDir}\n`);
-      stdout.write(`Would remove our slash commands from ${commandsDirFor({ env })} (user-edited files are kept)\n`);
+      if (removeSharedHookScripts) stdout.write(`Would remove hook scripts from ${hooksDir}\n`);
+      if (claudeCode) {
+        stdout.write(`Would remove our slash commands from ${commandsDirFor({ env })} (user-edited files are kept)\n`);
+      }
+    }
+    if (manageProxy && options.action === "connect") {
+      stdout.write(`Would register launchd services ${PROXY_LABEL} + ${WATCHDOG_LABEL} (capture proxy at ${PROXY_BASE_URL})\n`);
+      if (proxyPlan?.upstream) {
+        stdout.write(`Would chain the existing ANTHROPIC_BASE_URL as the proxy upstream: ${proxyPlan.upstream}\n`);
+      }
+    }
+    if (manageProxy && options.action === "disconnect") {
+      stdout.write(`Would remove launchd services ${PROXY_LABEL} + ${WATCHDOG_LABEL} and restore ANTHROPIC_BASE_URL\n`);
+    }
+    if (manageSkills) {
+      for (const client of skillClients) {
+        const verb = options.action === "connect" ? "install" : "remove";
+        stdout.write(`Would ${verb} the Memory Agent skill at ${skillDirFor(client.id, { env })}\n`);
+      }
     }
     return;
   }
 
   const result = await applyPlan(changes);
+  let skillPaths = [];
+  if (manageSkills) {
+    for (const client of skillClients) {
+      const skillResult = options.action === "connect"
+        ? await installMemoryAgentSkill(client.id, { env })
+        : await removeMemoryAgentSkill(client.id, { env });
+      skillPaths = skillPaths.concat(skillResult.written ?? skillResult.removed ?? []);
+      if ((skillResult.skipped ?? skillResult.kept ?? []).length) {
+        stderr.write(`Note: kept an existing unowned Memory Agent skill for ${client.name}.\n`);
+      }
+    }
+  }
   let hookScriptPaths = [];
   if (manageHooks) {
-    hookScriptPaths = options.action === "connect"
-      ? await installHookScripts(hooksDir)
-      : await removeHookScripts(hooksDir);
-    const commandsDir = commandsDirFor({ env });
-    const commandPaths = options.action === "connect"
-      ? await installCommandAssets(commandsDir)
-      : await removeCommandAssets(commandsDir);
-    hookScriptPaths = hookScriptPaths.concat(commandPaths);
+    if (options.action === "connect") hookScriptPaths = await installHookScripts(hooksDir);
+    else if (removeSharedHookScripts) hookScriptPaths = await removeHookScripts(hooksDir);
+    if (claudeCode) {
+      const commandsDir = commandsDirFor({ env });
+      const commandPaths = options.action === "connect"
+        ? await installCommandAssets(commandsDir)
+        : await removeCommandAssets(commandsDir);
+      hookScriptPaths = hookScriptPaths.concat(commandPaths);
+    }
+  }
+  let proxyPaths = [];
+  let proxyUpstream = null;
+  if (manageProxy) {
+    if (options.action === "connect") {
+      // State first: the watchdog and a future disconnect must know the
+      // user's original base URL before either could ever act on it. A
+      // no-op re-connect keeps the existing record (it holds the original).
+      let wiring = await readWiringState({ env });
+      if (proxyPlan.status === "wire" || !wiring) {
+        wiring = await writeWiringState({ env }, {
+          upstream: proxyPlan.upstream,
+          original: proxyPlan.original,
+        });
+      }
+      proxyUpstream = wiring.upstream ?? null;
+      const service = await installProxyServices({ env }, { upstream: proxyUpstream });
+      proxyPaths = service.written;
+      if (!service.installed) {
+        stderr.write(
+          `Warning: capture proxy service not fully registered — ${service.reason}\n`
+          + "  If Claude Code cannot reach the API, run: forget-connect disconnect --client claude-code\n",
+        );
+      }
+    } else {
+      proxyPaths = await removeProxyServices({ env });
+    }
+  }
+  if (options.action === "disconnect" && !options.dryRun) {
+    await reportCapture(options, env);
   }
   const verb = options.action === "connect" ? "Connected" : "Disconnected";
-  if (!result.changed.length && !hookScriptPaths.length) {
+  if (!result.changed.length && !hookScriptPaths.length && !proxyPaths.length && !skillPaths.length) {
     stdout.write("No changes needed.\n");
   } else {
     stdout.write(`${verb} ${clients.map((client) => client.name).join(", ")}.\n`);
@@ -676,6 +1049,8 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
     for (const filePath of result.backups) stdout.write(`  backup  ${filePath}\n`);
     const hookVerb = options.action === "connect" ? "installed" : "removed";
     for (const filePath of hookScriptPaths) stdout.write(`  ${hookVerb} ${filePath}\n`);
+    for (const filePath of proxyPaths) stdout.write(`  ${hookVerb} ${filePath}\n`);
+    for (const filePath of skillPaths) stdout.write(`  ${hookVerb} ${filePath}\n`);
   }
   if (options.action === "connect") {
     if (options.scope) {
@@ -686,8 +1061,22 @@ export async function run(argv = process.argv.slice(2), env = process.env) {
       );
     }
     if (manageHooks) {
-      stdout.write("  hooks: session capsule, per-turn recall, conflict alerts, session capture (needs python3 on PATH)\n");
-      stdout.write("  commands: /forget (the recall dial) · /forget-settings (status, doctor, cloud usage)\n");
+      stdout.write("  hooks: shared capsule, per-turn recall, and session capture (needs python3 on PATH)\n");
+      if (claudeCode) {
+        stdout.write("  commands: /forget (the recall dial) · /forget-settings (status, doctor, cloud usage)\n");
+      }
+    }
+    if (manageProxy) {
+      stdout.write(`  proxy: capture proxy at ${PROXY_BASE_URL} (launchd ${PROXY_LABEL}, watchdog ${WATCHDOG_LABEL})\n`);
+      stdout.write("  proxy RECORDS every Claude Code request and response (secrets scrubbed, owner-only 0600) in ~/.forget/proxy/stream/; kept 7 days, max 2 GB. Turn off: forget-connect disconnect (add --purge-capture to delete the files)\n");
+      const legacyNote = legacyLine(await captureInfo({ env }));
+      if (legacyNote) stdout.write(`  ${legacyNote}\n`);
+      if (proxyUpstream) {
+        stdout.write(`  proxy upstream: ${proxyUpstream} (your previous ANTHROPIC_BASE_URL, chained)\n`);
+      }
+    }
+    if (manageSkills) {
+      stdout.write("  skill: shared Memory Agent quote, approval, receipt, and revoke contract\n");
     }
     if (options.hosted && !options.scope) {
       stdout.write(