@mnemom/mnemom 0.17.0-next.6 → 0.17.0-next.8

package/dist/rc-proxy.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-// mnemom-code-rc-proxy — the local proxy behind ``mnemom code … --remote-control``.
+// mnemom-code-rc-proxy — the local proxy behind ``mnemom agent … --remote-control``.
 //
 // WHY THIS EXISTS
 // Claude Code's `remote-control` subcommand (drive a local session from claude.ai / the
 // mobile app) is gated: it refuses to start unless the CLI believes it talks to
 // api.anthropic.com with a claude.ai (OAuth) login — no ANTHROPIC_BASE_URL, no
 // ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN, no ANTHROPIC_UNIX_SOCKET. Every knob the
-// normal `mnemom code` launch uses to reach the Mnemom gateway trips that gate.
+// normal `mnemom agent` launch uses to reach the Mnemom gateway trips that gate.
 // HTTPS_PROXY + NODE_EXTRA_CA_CERTS are honoured and NOT gated (measured 2026-09-13,
 // Claude Code 2.1.269). So `--remote-control` runs Claude Code untouched — OAuth login,
 // first-party base URL — and puts this proxy in front of it.
@@ -19,7 +19,7 @@
 //   * Inside api.anthropic.com, only `POST /v1/messages[?…]` is rewritten to the Mnemom
 //     gateway door: the real Anthropic key rides as `x-api-key` (API-key billing), plus
 //     `x-mnemom-agent`, `x-mnemom-conversation-id`, and optionally `x-mnemom-api-key`,
-//     `x-mnemom-provider`, `x-mnemom-egress-key`, `x-mnemom-contract` — the exact header set
+//     `x-mnemom-provider`, `x-mnemom-egress-key`, `x-mnemom-contract` / `x-mnemom-goal-mode` — the exact header set
 //     the non-RC launch sends via ANTHROPIC_CUSTOM_HEADERS. The OAuth `authorization` bearer
 //     is STRIPPED on that leg (it never leaves the machine) and `oauth-*` tokens are removed
 //     from `anthropic-beta`. Everything else under api.anthropic.com (OAuth refresh, the
@@ -28,7 +28,7 @@
 //   * Serves BOTH request forms: CONNECT tunnels and absolute-form plaintext requests to the
 //     proxy port. Remote Control registration and the environment work-poll loop use the
 //     latter for https URLs; a CONNECT-only proxy answers 405 and registration fails.
-//   * Body handling on the gateway leg (see the mnemom code docs (Remote Control)):
+//   * Body handling on the gateway leg (see the mnemom agent docs (Remote Control)):
 //       - deletes every `cache_control.ttl` — Claude Code on claude.ai auth marks blocks
 //         `ttl:"1h"`; the gateway prepends its own 5m-cached system block and Anthropic
 //         rejects a 1h block that follows a 5m one (400). Forwarded bodies only.
@@ -46,105 +46,193 @@
 //         one more local 400: typically one or two `-> local 400` lines early in the
 //         session, each an instant local round trip, and zero gateway 400s. A `thread: null`
 //         is not a thread — the key is deleted and the body forwarded.
-//         MNEMOM_CODE_RC_THREAD_MODE=strip restores the legacy delete-and-forward behaviour
+//         MNEMOM_AGENT_RC_THREAD_MODE=strip restores the legacy delete-and-forward behaviour
 //         (diagnostic only: it forwards continue-deltas the API rejects).
 //
 // SECRETS
 // Arrive on stdin as three newline-terminated lines: Anthropic key, Mnemom key (may be
 // empty), OpenAI egress key (may be empty). Never argv, never env, never disk, never logged.
-// The log (MNEMOM_CODE_RC_PROXY_LOG, else stderr) carries method/path/status/latency and the
+// The log (MNEMOM_AGENT_RC_PROXY_LOG, else stderr) carries method/path/status/latency and the
 // gateway's `x-mnemom-agent` / `x-mnemom-goal-verdict` response headers only. Gateway error
 // bodies (status ≥ 400) are logged truncated so a 4xx is diagnosable (compressed ones as
 // `body=<encoding> <N> bytes`). Locally answered thread 400s log the thread type only.
 //
 // CONFIG (env, none secret)
-//   MNEMOM_CODE_RC_DOOR              gateway door URL (required), e.g. https://gateway.mnemom.ai/anthropic
-//   MNEMOM_CODE_RC_AGENT             x-mnemom-agent value (required)
-//   MNEMOM_CODE_RC_CONVERSATION_ID   x-mnemom-conversation-id value (required)
-//   MNEMOM_CODE_RC_CONTRACT_B64      base64 contract for x-mnemom-contract (optional)
-//   MNEMOM_CODE_RC_PROVIDER          x-mnemom-provider directive JSON (optional; router door)
-//   MNEMOM_CODE_RC_THREAD_MODE       `reject` (default: answer thread-bearing requests locally,
+//   MNEMOM_AGENT_RC_DOOR              gateway door URL (required), e.g. https://gateway.mnemom.ai/anthropic
+//   MNEMOM_AGENT_RC_AGENT             x-mnemom-agent value (required)
+//   MNEMOM_AGENT_RC_CONVERSATION_ID   x-mnemom-conversation-id value (required)
+//   MNEMOM_AGENT_RC_CONTRACT_B64      base64 contract for x-mnemom-contract (optional)
+//   MNEMOM_AGENT_RC_GOAL_MODE         x-mnemom-goal-mode value (optional; `--implicit` — no contract,
+//                                  the gateway infers the goal from the user's messages)
+//   MNEMOM_AGENT_RC_PROVIDER          x-mnemom-provider directive JSON (optional; router door)
+//   MNEMOM_AGENT_RC_THREAD_MODE       `reject` (default: answer thread-bearing requests locally,
 //                                  see above) | `strip` (legacy: delete `thread`, forward)
-//   MNEMOM_CODE_RC_PROXY_LOG         append log lines to this file instead of stderr (optional)
-//   MNEMOM_CODE_RC_PARENT_PID        exit when this pid is gone, so no orphan holds the keys
-//   MNEMOM_CODE_RC_PORT              listen port (default 0 = ephemeral)
+//   MNEMOM_AGENT_RC_PROXY_LOG         append log lines to this file instead of stderr (optional)
+//   MNEMOM_AGENT_RC_PARENT_PID        exit when this pid is gone, so no orphan holds the keys
+//   MNEMOM_AGENT_RC_PORT              listen port (default 0 = ephemeral)
 //
 // stdout: exactly one line, `READY <port> <ca.pem path>`, once listening. Node ≥ 18, no deps.
-import http from 'node:http';
-import https from 'node:https';
-import net from 'node:net';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
+import http from "node:http";
+import https from "node:https";
+import net from "node:net";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
 
-const MITM_HOST = 'api.anthropic.com';
+const MITM_HOST = "api.anthropic.com";
 const env = process.env;
 
-function die(msg) { process.stderr.write(`mnemom-code-rc-proxy: ${msg}\n`); process.exit(2); }
+function die(msg) {
+  process.stderr.write(`mnemom-code-rc-proxy: ${msg}\n`);
+  process.exit(2);
+}
 
-if (!env.MNEMOM_CODE_RC_DOOR) die('MNEMOM_CODE_RC_DOOR is required');
+if (!env.MNEMOM_AGENT_RC_DOOR) die("MNEMOM_AGENT_RC_DOOR is required");
 let GATEWAY;
-try { GATEWAY = new URL(env.MNEMOM_CODE_RC_DOOR); } catch { die(`MNEMOM_CODE_RC_DOOR is not a URL: ${env.MNEMOM_CODE_RC_DOOR}`); }
-if (GATEWAY.protocol !== 'https:') die('MNEMOM_CODE_RC_DOOR must be https');
-const AGENT = env.MNEMOM_CODE_RC_AGENT || die('MNEMOM_CODE_RC_AGENT is required');
-const CONV = env.MNEMOM_CODE_RC_CONVERSATION_ID || die('MNEMOM_CODE_RC_CONVERSATION_ID is required');
-const CONTRACT_B64 = env.MNEMOM_CODE_RC_CONTRACT_B64 || '';
-const PROVIDER = env.MNEMOM_CODE_RC_PROVIDER || '';
-const THREAD_MODE = env.MNEMOM_CODE_RC_THREAD_MODE || 'reject';
-if (THREAD_MODE !== 'reject' && THREAD_MODE !== 'strip') die(`MNEMOM_CODE_RC_THREAD_MODE must be 'reject' or 'strip', got '${THREAD_MODE}'`);
-const LOGFILE = env.MNEMOM_CODE_RC_PROXY_LOG || '';
-const PARENT = Number(env.MNEMOM_CODE_RC_PARENT_PID || 0);
-const PORT = Number(env.MNEMOM_CODE_RC_PORT || 0);
+try {
+  GATEWAY = new URL(env.MNEMOM_AGENT_RC_DOOR);
+} catch {
+  die(`MNEMOM_AGENT_RC_DOOR is not a URL: ${env.MNEMOM_AGENT_RC_DOOR}`);
+}
+if (GATEWAY.protocol !== "https:") die("MNEMOM_AGENT_RC_DOOR must be https");
+const AGENT = env.MNEMOM_AGENT_RC_AGENT || die("MNEMOM_AGENT_RC_AGENT is required");
+const CONV =
+  env.MNEMOM_AGENT_RC_CONVERSATION_ID || die("MNEMOM_AGENT_RC_CONVERSATION_ID is required");
+const CONTRACT_B64 = env.MNEMOM_AGENT_RC_CONTRACT_B64 || "";
+const GOAL_MODE = env.MNEMOM_AGENT_RC_GOAL_MODE || "";
+const PROVIDER = env.MNEMOM_AGENT_RC_PROVIDER || "";
+const THREAD_MODE = env.MNEMOM_AGENT_RC_THREAD_MODE || "reject";
+if (THREAD_MODE !== "reject" && THREAD_MODE !== "strip")
+  die(`MNEMOM_AGENT_RC_THREAD_MODE must be 'reject' or 'strip', got '${THREAD_MODE}'`);
+const LOGFILE = env.MNEMOM_AGENT_RC_PROXY_LOG || "";
+const PARENT = Number(env.MNEMOM_AGENT_RC_PARENT_PID || 0);
+const PORT = Number(env.MNEMOM_AGENT_RC_PORT || 0);
 
 const log = (line) => {
-  const s = `${new Date().toISOString()} ${line}\n`;
-  if (LOGFILE) { try { fs.appendFileSync(LOGFILE, s); return; } catch { /* fall through */ } }
+  // One record per line: gateway header values and error bodies are spliced into log lines, so a
+  // CR/LF inside them must not fabricate extra records (log injection).
+  const s = `${new Date().toISOString()} ${String(line).replace(/[\r\n]+/g, " ")}\n`;
+  if (LOGFILE) {
+    try {
+      fs.appendFileSync(LOGFILE, s);
+      return;
+    } catch {
+      /* fall through */
+    }
+  }
   process.stderr.write(s);
 };
 
 // --- secrets: three lines on stdin ------------------------------------------------------
 let secrets;
 try {
-  const lines = fs.readFileSync(0, 'utf8').split('\n');
-  secrets = { anthropic: (lines[0] || '').trim(), mnemom: (lines[1] || '').trim(), openai: (lines[2] || '').trim() };
+  const lines = fs.readFileSync(0, "utf8").split("\n");
+  secrets = {
+    anthropic: (lines[0] || "").trim(),
+    mnemom: (lines[1] || "").trim(),
+    openai: (lines[2] || "").trim(),
+  };
 } catch {
-  die('expected three lines of secrets on stdin (anthropic, mnemom, openai)');
+  die("expected three lines of secrets on stdin (anthropic, mnemom, openai)");
 }
-if (!secrets.anthropic) die('the Anthropic key (stdin line 1) is empty');
+if (!secrets.anthropic) die("the Anthropic key (stdin line 1) is empty");
 
 // --- ephemeral CA + leaf for api.anthropic.com ------------------------------------------
 // Private 0700 dir under the OS tmpdir; the CA key is deleted as soon as the leaf is signed
 // (only the leaf key is needed to serve sessions) and the whole dir goes on exit. Works with
 // macOS's system LibreSSL (3.3+) and OpenSSL 1.1.1+ (`-addext`).
-const caDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mnemom-code-rc-ca-'));
+const caDir = fs.mkdtempSync(path.join(os.tmpdir(), "mnemom-code-rc-ca-"));
 fs.chmodSync(caDir, 0o700);
 const p = (f) => path.join(caDir, f);
-const cleanup = () => { try { fs.rmSync(caDir, { recursive: true, force: true }); } catch { /* best effort */ } };
-process.on('exit', cleanup);
-for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(sig, () => process.exit(0));
+const cleanup = () => {
+  try {
+    fs.rmSync(caDir, { recursive: true, force: true });
+  } catch {
+    /* best effort */
+  }
+};
+process.on("exit", cleanup);
+for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(sig, () => process.exit(0));
 try {
-  const ossl = (...a) => execFileSync('openssl', a, { stdio: ['ignore', 'ignore', 'pipe'] });
-  ossl('req', '-x509', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:prime256v1', '-nodes',
-    '-keyout', p('ca.key'), '-out', p('ca.pem'), '-days', '2', '-subj', '/CN=mnemom code local CA (ephemeral)',
-    '-addext', 'basicConstraints=critical,CA:TRUE', '-addext', 'keyUsage=critical,keyCertSign,cRLSign');
-  ossl('req', '-newkey', 'ec', '-pkeyopt', 'ec_paramgen_curve:prime256v1', '-nodes',
-    '-keyout', p('leaf.key'), '-out', p('leaf.csr'), '-subj', `/CN=${MITM_HOST}`);
-  fs.writeFileSync(p('leaf.ext'),
-    `subjectAltName=DNS:${MITM_HOST}\nbasicConstraints=CA:FALSE\nkeyUsage=digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n`);
-  ossl('x509', '-req', '-in', p('leaf.csr'), '-CA', p('ca.pem'), '-CAkey', p('ca.key'), '-CAcreateserial',
-    '-out', p('leaf.pem'), '-days', '2', '-extfile', p('leaf.ext'));
-  fs.rmSync(p('ca.key'));
+  const ossl = (...a) => execFileSync("openssl", a, { stdio: ["ignore", "ignore", "pipe"] });
+  ossl(
+    "req",
+    "-x509",
+    "-newkey",
+    "ec",
+    "-pkeyopt",
+    "ec_paramgen_curve:prime256v1",
+    "-nodes",
+    "-keyout",
+    p("ca.key"),
+    "-out",
+    p("ca.pem"),
+    "-days",
+    "2",
+    "-subj",
+    "/CN=mnemom agent local CA (ephemeral)",
+    "-addext",
+    "basicConstraints=critical,CA:TRUE",
+    "-addext",
+    "keyUsage=critical,keyCertSign,cRLSign",
+  );
+  ossl(
+    "req",
+    "-newkey",
+    "ec",
+    "-pkeyopt",
+    "ec_paramgen_curve:prime256v1",
+    "-nodes",
+    "-keyout",
+    p("leaf.key"),
+    "-out",
+    p("leaf.csr"),
+    "-subj",
+    `/CN=${MITM_HOST}`,
+  );
+  fs.writeFileSync(
+    p("leaf.ext"),
+    `subjectAltName=DNS:${MITM_HOST}\nbasicConstraints=CA:FALSE\nkeyUsage=digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n`,
+  );
+  ossl(
+    "x509",
+    "-req",
+    "-in",
+    p("leaf.csr"),
+    "-CA",
+    p("ca.pem"),
+    "-CAkey",
+    p("ca.key"),
+    "-CAcreateserial",
+    "-out",
+    p("leaf.pem"),
+    "-days",
+    "2",
+    "-extfile",
+    p("leaf.ext"),
+  );
+  fs.rmSync(p("ca.key"));
 } catch (e) {
-  die(`could not mint the ephemeral CA with openssl: ${e.stderr ? e.stderr.toString() : e.message}`);
+  die(
+    `could not mint the ephemeral CA with openssl: ${e.stderr ? e.stderr.toString() : e.message}`,
+  );
 }
 
 // --- request handling ---------------------------------------------------------------------
 const gatewayAgent = new https.Agent({ keepAlive: false }); // a reused socket to the gateway gave ECONNRESET on retry
 const upstreamAgent = new https.Agent({ keepAlive: true, maxSockets: 32 });
-const HOP = new Set(['connection', 'proxy-connection', 'keep-alive', 'upgrade', 'host', 'te', 'trailer']);
+const HOP = new Set([
+  "connection",
+  "proxy-connection",
+  "keep-alive",
+  "upgrade",
+  "host",
+  "te",
+  "trailer",
+]);
 
-const isMessagesPath = (u) => u === '/v1/messages' || u.startsWith('/v1/messages?');
+const isMessagesPath = (u) => u === "/v1/messages" || u.startsWith("/v1/messages?");
 
 // Inspect + normalise a /v1/messages body for the gateway leg. Returns
 //   { body: <possibly rewritten Buffer>, thread: null | 'create' | 'continue' | 'other' }
@@ -157,24 +245,34 @@ const isMessagesPath = (u) => u === '/v1/messages' || u.startsWith('/v1/messages
 // unchanged apart from `cache_control.ttl`, because the caller will not forward it.
 function normalizeBody(body) {
   try {
-    const j = JSON.parse(body.toString('utf8'));
+    const j = JSON.parse(body.toString("utf8"));
     let n = 0;
     const walk = (o) => {
-      if (Array.isArray(o)) { for (const x of o) walk(x); return; }
-      if (o && typeof o === 'object') {
-        if (o.cache_control && typeof o.cache_control === 'object' && 'ttl' in o.cache_control) { delete o.cache_control.ttl; n++; }
+      if (Array.isArray(o)) {
+        for (const x of o) walk(x);
+        return;
+      }
+      if (o && typeof o === "object") {
+        if (o.cache_control && typeof o.cache_control === "object" && "ttl" in o.cache_control) {
+          delete o.cache_control.ttl;
+          n++;
+        }
         for (const v of Object.values(o)) walk(v);
       }
     };
     walk(j);
     let thread = null;
-    if (j && typeof j === 'object' && !Array.isArray(j) && 'thread' in j) {
+    if (j && typeof j === "object" && !Array.isArray(j) && "thread" in j) {
       if (j.thread === null || j.thread === undefined) {
-        delete j.thread; n++;                             // not a thread: forward the rest
+        delete j.thread;
+        n++; // not a thread: forward the rest
       } else {
-        const t = typeof j.thread === 'object' ? j.thread.type : undefined;
-        thread = t === 'create' || t === 'continue' ? t : 'other';
-        if (THREAD_MODE === 'strip') { delete j.thread; n++; }
+        const t = typeof j.thread === "object" ? j.thread.type : undefined;
+        thread = t === "create" || t === "continue" ? t : "other";
+        if (THREAD_MODE === "strip") {
+          delete j.thread;
+          n++;
+        }
       }
     }
     return { body: n ? Buffer.from(JSON.stringify(j)) : body, thread };
@@ -187,36 +285,50 @@ function normalizeBody(body) {
 // classifier must land on "unsupported_request": `details.error_code` is the primary
 // signal, and the message names the beta, the `thread` param and `previous_message_id`
 // so the fallback regexes agree even if the details path were ever ignored.
-const THREAD_400 = Buffer.from(JSON.stringify({
-  type: 'error',
-  error: {
-    type: 'invalid_request_error',
-    message: 'message threads (beta message-threads-2026-08-12: top-level thread param / previous_message_id) are not supported on the mnemom gateway leg; resend the full transcript without a thread',
-    details: { error_code: 'thread_unsupported_request' },
-  },
-}));
+const THREAD_400 = Buffer.from(
+  JSON.stringify({
+    type: "error",
+    error: {
+      type: "invalid_request_error",
+      message:
+        "message threads (beta message-threads-2026-08-12: top-level thread param / previous_message_id) are not supported on the mnemom gateway leg; resend the full transcript without a thread",
+      details: { error_code: "thread_unsupported_request" },
+    },
+  }),
+);
 let localSeq = 0;
 function rejectThread(res, tag, thread) {
   res.writeHead(400, {
-    'content-type': 'application/json',
-    'content-length': String(THREAD_400.length),
-    'request-id': `mnemom-code-rc-proxy-${++localSeq}`,
+    "content-type": "application/json",
+    "content-length": String(THREAD_400.length),
+    "request-id": `mnemom-code-rc-proxy-${++localSeq}`,
   });
   res.end(THREAD_400);
-  log(`${tag} -> local 400 thread=${thread} (thread_unsupported_request; Claude Code resends this turn stateless and stops threading for this agent+model for the rest of the session — a subagent or model switch takes one more local 400)`);
+  log(
+    `${tag} -> local 400 thread=${thread} (thread_unsupported_request; Claude Code resends this turn stateless and stops threading for this agent+model for the rest of the session — a subagent or model switch takes one more local 400)`,
+  );
 }
 
 // One handler serves both the MITM'd TLS stream (origin-form URLs, host = api.anthropic.com)
 // and absolute-form plaintext requests sent straight to the proxy port.
 function handle(req, res, viaPlain) {
-  let host = MITM_HOST, port = 443, urlPath = req.url, proto = https;
+  let host = MITM_HOST,
+    port = 443,
+    urlPath = req.url,
+    proto = https;
   if (viaPlain) {
     let u;
-    try { u = new URL(req.url); } catch { res.writeHead(400); res.end('mnemom-code-rc-proxy: absolute-form URL required\n'); return; }
+    try {
+      u = new URL(req.url);
+    } catch {
+      res.writeHead(400);
+      res.end("mnemom-code-rc-proxy: absolute-form URL required\n");
+      return;
+    }
     host = u.hostname;
-    port = Number(u.port || (u.protocol === 'http:' ? 80 : 443));
+    port = Number(u.port || (u.protocol === "http:" ? 80 : 443));
     urlPath = u.pathname + u.search;
-    proto = u.protocol === 'http:' ? http : https;
+    proto = u.protocol === "http:" ? http : https;
   }
   const headers = {};
   for (const [k, v] of Object.entries(req.headers)) if (!HOP.has(k)) headers[k] = v;
@@ -224,27 +336,42 @@ function handle(req, res, viaPlain) {
   const toGateway = host === MITM_HOST && isMessagesPath(urlPath);
   let target;
   if (toGateway) {
-    target = { hostname: GATEWAY.hostname, port: GATEWAY.port || 443,
-      path: GATEWAY.pathname.replace(/\/$/, '') + urlPath, agent: gatewayAgent };
-    delete headers.authorization;                       // the OAuth bearer stays local
-    headers['x-api-key'] = secrets.anthropic;
-    headers['x-mnemom-agent'] = AGENT;
-    headers['x-mnemom-conversation-id'] = CONV;
-    if (secrets.mnemom) headers['x-mnemom-api-key'] = secrets.mnemom;
-    if (PROVIDER) headers['x-mnemom-provider'] = PROVIDER;
-    if (secrets.openai) headers['x-mnemom-egress-key'] = secrets.openai;
-    if (CONTRACT_B64) headers['x-mnemom-contract'] = CONTRACT_B64;
-    if (headers['anthropic-beta']) {                    // drop the OAuth-only beta tokens
-      const b = String(headers['anthropic-beta']).split(',').map((s) => s.trim()).filter((s) => s && !s.startsWith('oauth-'));
-      if (b.length) headers['anthropic-beta'] = b.join(','); else delete headers['anthropic-beta'];
+    target = {
+      hostname: GATEWAY.hostname,
+      port: GATEWAY.port || 443,
+      path: GATEWAY.pathname.replace(/\/$/, "") + urlPath,
+      agent: gatewayAgent,
+    };
+    delete headers.authorization; // the OAuth bearer stays local
+    headers["x-api-key"] = secrets.anthropic;
+    headers["x-mnemom-agent"] = AGENT;
+    headers["x-mnemom-conversation-id"] = CONV;
+    if (secrets.mnemom) headers["x-mnemom-api-key"] = secrets.mnemom;
+    if (PROVIDER) headers["x-mnemom-provider"] = PROVIDER;
+    if (secrets.openai) headers["x-mnemom-egress-key"] = secrets.openai;
+    if (CONTRACT_B64) headers["x-mnemom-contract"] = CONTRACT_B64;
+    if (GOAL_MODE) headers["x-mnemom-goal-mode"] = GOAL_MODE;
+    if (headers["anthropic-beta"]) {
+      // drop the OAuth-only beta tokens
+      const b = String(headers["anthropic-beta"])
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s && !s.startsWith("oauth-"));
+      if (b.length) headers["anthropic-beta"] = b.join(",");
+      else delete headers["anthropic-beta"];
     }
   } else {
-    target = { hostname: host, port, path: urlPath, agent: proto === https ? upstreamAgent : undefined };
+    target = {
+      hostname: host,
+      port,
+      path: urlPath,
+      agent: proto === https ? upstreamAgent : undefined,
+    };
   }
 
   const started = Date.now();
-  const tag = `${req.method} ${viaPlain ? host : ''}${urlPath}`;
-  const leg = toGateway ? 'gateway' : 'upstream';
+  const tag = `${req.method} ${viaPlain ? host : ""}${urlPath}`;
+  const leg = toGateway ? "gateway" : "upstream";
 
   // Open the upstream request only once we know we are forwarding. `body` is the fully
   // buffered (normalised) gateway body; undefined means stream the client request through.
@@ -256,45 +383,72 @@ function handle(req, res, viaPlain) {
       // Gateway error bodies are logged (truncated) so a 4xx is diagnosable — unless the
       // body is compressed, in which case only its encoding + size is useful
       // (`identity` is not a compression).
-      let errBody = '', errBytes = 0;
-      const enc = ur.headers['content-encoding'];
-      const errEnc = enc && enc !== 'identity' ? enc : '';
+      let errBody = "",
+        errBytes = 0;
+      const enc = ur.headers["content-encoding"];
+      const errEnc = enc && enc !== "identity" ? enc : "";
       if (toGateway && ur.statusCode >= 400) {
-        ur.on('data', (c) => { errBytes += c.length; if (!errEnc && errBody.length < 1500) errBody += c.toString('utf8'); });
+        ur.on("data", (c) => {
+          errBytes += c.length;
+          if (!errEnc && errBody.length < 1500) errBody += c.toString("utf8");
+        });
       }
       ur.pipe(res);
-      const ident = toGateway ? ` agent=${ur.headers['x-mnemom-agent'] || '-'} verdict=${ur.headers['x-mnemom-goal-verdict'] || '-'}` : '';
-      ur.on('end', () => {
-        let bodyNote = '';
+      const goalRev = ur.headers["x-mnemom-goal-revision"];
+      const steer = ur.headers["x-mnemom-goal-steer"];
+      const ident = toGateway
+        ? ` agent=${ur.headers["x-mnemom-agent"] || "-"} verdict=${ur.headers["x-mnemom-goal-verdict"] || "-"}` +
+          (goalRev ? ` goal-rev=${goalRev}` : "") +
+          (steer ? ` steer=${steer}` : "")
+        : "";
+      ur.on("end", () => {
+        let bodyNote = "";
         if (toGateway && ur.statusCode >= 400) {
-          bodyNote = errEnc ? ` body=${errEnc} ${errBytes} bytes` : (errBody ? ' body=' + errBody.slice(0, 1500).replace(/\s+/g, ' ') : '');
+          bodyNote = errEnc
+            ? ` body=${errEnc} ${errBytes} bytes`
+            : errBody
+              ? " body=" + errBody.slice(0, 1500).replace(/\s+/g, " ")
+              : "";
         }
         log(`${tag} -> ${leg} ${ur.statusCode} ${Date.now() - started}ms${ident}${bodyNote}`);
       });
     });
-    up.on('error', (e) => {
+    up.on("error", (e) => {
       log(`${tag} -> ${leg} ERROR ${e.code || e.message}`);
-      if (!res.headersSent) res.writeHead(502, { 'content-type': 'application/json' });
-      res.end(JSON.stringify({ type: 'error', error: { type: 'proxy_error', message: `mnemom-code-rc-proxy upstream: ${e.code || e.message}` } }));
+      if (!res.headersSent) res.writeHead(502, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          type: "error",
+          error: {
+            type: "proxy_error",
+            message: `mnemom-code-rc-proxy upstream: ${e.code || e.message}`,
+          },
+        }),
+      );
+    });
+    res.on("close", () => {
+      if (!up.destroyed) up.destroy();
     });
-    res.on('close', () => { if (!up.destroyed) up.destroy(); });
     if (body !== undefined) {
-      up.removeHeader('transfer-encoding');
-      up.setHeader('content-length', String(body.length));
+      up.removeHeader("transfer-encoding");
+      up.setHeader("content-length", String(body.length));
       up.end(body);
     } else {
       req.pipe(up);
     }
   };
 
-  if (toGateway && req.method === 'POST') {
+  if (toGateway && req.method === "POST") {
     // Buffer the body first: a thread-bearing request is answered here and nothing may be
     // sent to (or left half-open toward) the gateway for it.
     const chunks = [];
-    req.on('data', (c) => chunks.push(c));
-    req.on('end', () => {
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
       const { body, thread } = normalizeBody(Buffer.concat(chunks));
-      if (thread !== null && THREAD_MODE === 'reject') { rejectThread(res, tag, thread); return; }
+      if (thread !== null && THREAD_MODE === "reject") {
+        rejectThread(res, tag, thread);
+        return;
+      }
       forward(body);
     });
   } else {
@@ -303,39 +457,58 @@ function handle(req, res, viaPlain) {
 }
 
 const tlsServer = https.createServer(
-  { key: fs.readFileSync(p('leaf.key')), cert: fs.readFileSync(p('leaf.pem')) },
+  { key: fs.readFileSync(p("leaf.key")), cert: fs.readFileSync(p("leaf.pem")) },
   (req, res) => handle(req, res, false),
 );
-tlsServer.on('tlsClientError', (e) => log(`tls client error: ${e.code || e.message}`));
+tlsServer.on("tlsClientError", (e) => log(`tls client error: ${e.code || e.message}`));
 
 const proxy = http.createServer((req, res) => handle(req, res, true));
-proxy.on('connect', (req, sock, head) => {
-  const [host, portStr] = req.url.split(':');
+proxy.on("connect", (req, sock, head) => {
+  const [host, portStr] = req.url.split(":");
   const port = Number(portStr || 443);
-  sock.on('error', () => {});
+  sock.on("error", () => {});
   if (host === MITM_HOST && port === 443) {
-    sock.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+    sock.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     if (head && head.length) sock.unshift(head);
-    tlsServer.emit('connection', sock);
+    tlsServer.emit("connection", sock);
     return;
   }
   const up = net.connect(port, host, () => {
-    sock.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+    sock.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     if (head && head.length) up.write(head);
-    up.pipe(sock); sock.pipe(up);
+    up.pipe(sock);
+    sock.pipe(up);
   });
-  up.on('error', (e) => { log(`CONNECT ${req.url} tunnel ERROR ${e.code || e.message}`); sock.destroy(); });
-  sock.on('close', () => up.destroy());
-  up.on('close', () => sock.destroy());
+  up.on("error", (e) => {
+    log(`CONNECT ${req.url} tunnel ERROR ${e.code || e.message}`);
+    sock.destroy();
+  });
+  sock.on("close", () => up.destroy());
+  up.on("close", () => sock.destroy());
   log(`CONNECT ${req.url} tunnel`);
 });
-proxy.on('clientError', (e, sock) => { try { sock.destroy(); } catch { /* already gone */ } });
+proxy.on("clientError", (e, sock) => {
+  try {
+    sock.destroy();
+  } catch {
+    /* already gone */
+  }
+});
 
-proxy.listen(PORT, '127.0.0.1', () => {
+proxy.listen(PORT, "127.0.0.1", () => {
   const { port } = proxy.address();
-  log(`listening 127.0.0.1:${port} agent=${AGENT} conv=${CONV} door=${GATEWAY.href} contract=${CONTRACT_B64 ? 'yes' : 'no'} provider=${PROVIDER || '-'} thread=${THREAD_MODE}`);
-  process.stdout.write(`READY ${port} ${p('ca.pem')}\n`);
+  log(
+    `listening 127.0.0.1:${port} agent=${AGENT} conv=${CONV} door=${GATEWAY.href} contract=${CONTRACT_B64 ? "yes" : "no"} goal_mode=${GOAL_MODE || "-"} provider=${PROVIDER || "-"} thread=${THREAD_MODE}`,
+  );
+  process.stdout.write(`READY ${port} ${p("ca.pem")}\n`);
 });
 
 // Die with the launcher so no orphan keeps the secrets in memory.
-if (PARENT) setInterval(() => { try { process.kill(PARENT, 0); } catch { process.exit(0); } }, 2000).unref();
+if (PARENT)
+  setInterval(() => {
+    try {
+      process.kill(PARENT, 0);
+    } catch {
+      process.exit(0);
+    }
+  }, 2000).unref();