@mnemom/mnemom 0.17.22 → 0.17.24

package/README.md

@@ -193,22 +193,33 @@ which request is a compaction (a gateway that does not read them ignores them).
 never sets or changes your own auto-compaction settings (`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`,
 `CLAUDE_CODE_AUTO_COMPACT_WINDOW`, or `autoCompactWindow` in settings.json).
 
-**Experimental, off by default.** `--compaction-intercept` (after `mnemom experimental enable
-compaction-intercept`; standing default `mnemom agent config set compaction_intercept on`, or
-`MNEMOM_AGENT_COMPACTION_INTERCEPT=1`) sends `GATEWAY_USAGE_REAL_SIZE=on` and
-`GATEWAY_COMPACTION_INTERCEPT=on` in the per-session config header, asking the gateway to report
-the real context size (so Claude Code compacts at its own threshold) and to answer that
-compaction at once from its fold instead of a blocking model call. This needs the companion
-gateway support: a gateway without it drops both keys (they are echoed back in
-`x-mnemom-session-config-dropped`) and the session behaves exactly as with the setting off. `--no-compaction-intercept` turns it off for
-one launch.
+**Compaction intercept: on by default (since 0.17.23).** Every launch sends
+`GATEWAY_USAGE_REAL_SIZE=on` and `GATEWAY_COMPACTION_INTERCEPT=on` in the per-session config
+header, asking the gateway to report the real context size (so Claude Code compacts at its own
+threshold) and to answer that compaction at once from its fold instead of a blocking model call.
+This matches the production gateway cell's own default, so the header mainly makes the setting
+explicit and keeps every cell consistent; the launch banner shows it as
+`compaction: intercept on (gateway)`. A gateway without the companion support drops both keys
+(they are echoed back in `x-mnemom-session-config-dropped`) and the session behaves as before.
+
+It used to be experimental (`mnemom experimental enable compaction-intercept`); that command is
+now a harmless no-op that says so. To turn it off, use any of:
+
+```bash
+mnemom agent my-task --no-compaction-intercept          # this launch only
+mnemom agent config set compaction_intercept false      # persists in ~/.mnemom/launcher.toml
+export MNEMOM_AGENT_COMPACTION_INTERCEPT=0              # for every launch in this shell
+```
+
+An opt-out sends both keys as `off` by name, so it also turns the intercept off on a cell whose
+own default is on (sending nothing would leave that cell intercepting).
 
 #### Compaction target (`--compact-at`)
 
 `--compact-at <n|200k|1m|off>` lets you play with WHEN the gateway pulls this session's own
 compaction point forward, instead of leaving it entirely to Claude Code's normal 1M-window
 schedule. **Unset, `1m`, or `off` all mean no target** — Claude Code runs its normal 1M window
-and the launcher sends nothing new (byte-identical to a launch without this setting at all). A
+and the launcher sends no target key (only the default intercept keys above). A
 token count below 1M (k/m suffixes OK, e.g. `200k` or `350000`, from 50k up to just under 1M)
 arms a gateway-side target for this session: the per-session config header carries
 `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` (the two keys a target needs to
@@ -223,10 +234,10 @@ nothing back, so the launcher prints a warning at launch (and in `--dry-run`) wh
 the target will be ignored, and a note when it can't tell the window (a passthrough `-- --model`,
 a resume, or a CLI other than Claude Code).
 
-**Arming a target needs the same opt-in as `--compaction-intercept`** (`mnemom experimental
-enable compaction-intercept`) — a target arms the identical pair of gateway keys, so it needs
-the identical gate; the flag itself stays visible in `--help` (it's the knob you asked for), only
-actually _arming_ a target is gated. Passing `--no-compaction-intercept` together with an armed
+**Arming a target needs no opt-in** (since 0.17.23 it rides on the default-on intercept). A
+target arms the intercept's two keys even when a standing `compaction_intercept = false` or
+`MNEMOM_AGENT_COMPACTION_INTERCEPT=0` turned it off, since the target cannot work without them.
+Passing `--no-compaction-intercept` together with an armed
 `--compact-at` is refused outright (they contradict: the target cannot arm without the intercept
 you just turned off). So is an armed `--compact-at` (or `--compaction-intercept`) with context
 profile `off`: with the fold off there is no fold to answer the compaction from.
@@ -235,7 +246,6 @@ Set it per launch, as a standing default, or in the environment (flag > env > `l
 default):
 
 ```bash
-mnemom experimental enable compaction-intercept # one-time opt-in
 mnemom agent my-task --compact-at 200k          # this launch only
 mnemom agent config set compact_at 200k         # persists in ~/.mnemom/launcher.toml
 export MNEMOM_COMPACT_AT=200k                   # for every launch in this shell

package/dist/commands/agent.d.ts

@@ -94,10 +94,11 @@ export interface AgentOptions {
      */
     contextHandoff?: boolean;
     /**
-     * EXPERIMENTAL, off by default (payload-bound fix): tells the gateway
-     * `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` for this session only (real
-     * context size in usage, so Claude Code compacts at its OWN threshold; the compaction request
-     * answered at once from the gateway's fold). Absent/false ⇒ no header key.
+     * ON by default since 0.17.23 (payload-bound fix; graduated from experimental): tells the
+     * gateway `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` for this session
+     * (real context size in usage, so Claude Code compacts at its OWN threshold; the compaction
+     * request answered at once from the gateway's fold). `false` (--no-compaction-intercept) sends
+     * both `"off"`; absent ⇒ MNEMOM_AGENT_COMPACTION_INTERCEPT / launcher.toml, else on.
      */
     compactionIntercept?: boolean;
     /**
@@ -135,6 +136,12 @@ export interface AgentOptions {
     /** Print the resolved launch plan and exit — no key read, no spawn. */
     dryRun?: boolean;
 }
+/**
+ * The intercept state as the launch banner and the dry-run plan print it. Context profile `off`
+ * sends the intercept off (`buildSessionConfig`), so it reads off there whatever the setting; an
+ * armed `--compact-at` target turns it on even over a standing opt-out.
+ */
+export declare function describeCompactionIntercept(profile: ContextProfile | null, compactionIntercept: boolean, compactAt: number | null): string;
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export declare function agentCommand(scenarioArg: string | undefined, options?: AgentOptions): Promise<void>;
 /** The Claude Code session id a passthrough `--resume <id>` / `-r <id>` / `--resume=<id>` names. */
@@ -399,6 +406,8 @@ export declare function printPlan(ctx: {
     contextProfile: ContextProfile | null;
     /** The resolved compaction target (`resolveCompactAt`); `null` = no target (default). */
     compactAt: number | null;
+    /** The resolved compaction intercept (`resolveCompactionIntercept`); on by default. */
+    compactionIntercept?: boolean;
     /** The decoded `x-mnemom-session-config` overlay (`buildSessionConfig`); empty ⇒ no header. */
     sessionConfig: Record<string, string>;
     /** The experimental features on for this launch (the header's `experimental` array). */

package/dist/commands/agent.js

@@ -53,21 +53,30 @@ import { CLI_VERSION } from "../version.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
 const CODE_STORE = LAUNCHER_STORE_PATH;
 const say = (line = "") => console.error(line);
-/** The one-line launch note when the compaction intercept is ON. */
-const COMPACTION_INTERCEPT_NOTE = "mnemom agent: compaction intercept ON (experimental) — requested from the gateway (GATEWAY_USAGE_REAL_SIZE, GATEWAY_COMPACTION_INTERCEPT); a gateway without the companion support drops both keys and the session runs as before.";
-const OFF_DROPS_COMPACTION_NOTE = "mnemom agent: compaction intercept off for this session — context profile off leaves compaction to the coding agent, so the standing compaction_intercept / compact_at setting is not sent.";
 /**
- * The compaction notes for a resolved launch. Context profile `off` sends the intercept off and
- * no target (`buildSessionConfig`), so a standing intercept or target is reported as dropped
- * rather than as ON.
+ * The intercept state as the launch banner and the dry-run plan print it. Context profile `off`
+ * sends the intercept off (`buildSessionConfig`), so it reads off there whatever the setting; an
+ * armed `--compact-at` target turns it on even over a standing opt-out.
+ */
+export function describeCompactionIntercept(profile, compactionIntercept, compactAt) {
+    if (profile === "off")
+        return "intercept off (context profile off)";
+    if (compactionIntercept || compactAt !== null)
+        return "intercept on (gateway)";
+    return "intercept off (opted out)";
+}
+/** Context profile off drops a standing compaction target: say so rather than show it as set. */
+const OFF_DROPS_TARGET_NOTE = "mnemom agent: context profile off leaves compaction to the coding agent, so the standing compact_at target is not sent.";
+/**
+ * The compaction lines for a resolved launch: the intercept (on by default since 0.17.23 — no
+ * longer an experimental line) and the compaction target.
  */
 function sayCompaction(profile, compactionIntercept, compactAt, window) {
     const off = profile === "off";
+    say(`mnemom agent: compaction: ${describeCompactionIntercept(profile, compactionIntercept, compactAt)}`);
     sayCompactAt(off ? null : compactAt, window);
-    if (off && (compactionIntercept || compactAt !== null))
-        say(OFF_DROPS_COMPACTION_NOTE);
-    else if (compactionIntercept)
-        say(COMPACTION_INTERCEPT_NOTE);
+    if (off && compactAt !== null)
+        say(OFF_DROPS_TARGET_NOTE);
 }
 /**
  * The one-line launch note for the context profile: `null` (none chosen — nothing is sent) names
@@ -310,6 +319,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             cli: planCli,
             contextProfile,
             compactAt,
+            compactionIntercept,
             sessionConfig,
             experimental,
             plugin: pluginFor(planCli.name).line,
@@ -1766,6 +1776,9 @@ export function printPlan(ctx) {
     L.push(`  yolo:          ${ctx.yolo ? "on (--dangerously-skip-permissions)" : "off"}`);
     L.push(`  context:       ${ctx.contextProfile ?? "cell default"}`);
     L.push(`  compaction:    ${describeCompactAt(ctx.compactAt)}`);
+    if (ctx.compactionIntercept !== undefined) {
+        L.push(`  intercept:     ${describeCompactionIntercept(ctx.contextProfile, ctx.compactionIntercept, ctx.compactAt).replace(/^intercept /, "")}`);
+    }
     const overlay = Object.entries(ctx.sessionConfig);
     if (overlay.length > 0) {
         L.push(`  session config (${SESSION_CONFIG_HEADER}):`);

package/dist/commands/experimental.js

@@ -3,7 +3,7 @@
  * features on and off (registry: lib/experimental.ts; stored in ~/.mnemom/config.json).
  */
 import { existsSync, readdirSync } from "node:fs";
-import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
+import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, graduatedNote, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
 import { loadCliConfig, setExperimentalEnabled } from "../lib/cli-config.js";
 import { MNEMOM_DIR } from "../lib/config.js";
 import { launcherEntries, loadLauncherConfig } from "../lib/launcher-config.js";
@@ -50,6 +50,13 @@ export function experimentalListCommand(opts = {}, deps = defaultDeps()) {
     deps.log("Turn one on with `mnemom experimental enable <id>`.");
 }
 function toggle(verb, rawId, deps) {
+    // A feature that graduated to on-by-default: accept its old id as a no-op with a note, so
+    // a script or an old README that still runs `mnemom experimental enable <id>` keeps working.
+    const note = graduatedNote((rawId ?? "").trim().toLowerCase());
+    if (note) {
+        deps.log(note);
+        return;
+    }
     const id = requireId(rawId, verb);
     const current = new Set(resolveExperimental({ stored: deps.stored(), env: {} }).enabled);
     if (verb === "enable")

package/dist/index.js

@@ -204,7 +204,7 @@ const agentCmd = program
         throw new InvalidArgumentError(e.message);
     }
 }))
-    .addOption(new Option("--compact-at <n|200k|1m|off>", 'Play with WHEN the gateway pulls this session\'s own compaction point forward, instead of leaving it to Claude Code\'s normal 1M-window schedule. A token count below 1M (k/m suffix OK, e.g. "200k") arms the gateway\'s compaction target for this session; unset, "1m" or "off" all mean no target — Claude Code runs its normal 1M window and nothing new is sent. Arming a target needs `mnemom experimental enable compaction-intercept` (the same opt-in --compaction-intercept uses — a target arms the identical gateway keys) and is refused if you also pass --no-compaction-intercept. Never touches Claude Code\'s own autocompact env/window. Also: config key compact_at, env MNEMOM_COMPACT_AT.').argParser((v) => {
+    .addOption(new Option("--compact-at <n|200k|1m|off>", 'Play with WHEN the gateway pulls this session\'s own compaction point forward, instead of leaving it to Claude Code\'s normal 1M-window schedule. A token count below 1M (k/m suffix OK, e.g. "200k") arms the gateway\'s compaction target for this session; unset, "1m" or "off" all mean no target — Claude Code runs its normal 1M window and nothing new is sent. A target rides on the compaction intercept (on by default) and is refused if you also pass --no-compaction-intercept. Never touches Claude Code\'s own autocompact env/window. Also: config key compact_at, env MNEMOM_COMPACT_AT.').argParser((v) => {
     // Validate with the same parser the other two surfaces (MNEMOM_COMPACT_AT, launcher.toml
     // compact_at) use, but return the validated RAW string rather than parseCompactAt's
     // `number | null` — commander's own option-value handling coerces a parseArg return of
@@ -222,8 +222,8 @@ const agentCmd = program
 }))
     .addOption(new Option("--context-handoff", "EXPERIMENTAL (`mnemom experimental enable context-handoff`): register the `handoff(note)` MCP tool and tell the gateway to turn on the context-handoff capability for this session").hideHelp(hiddenUnless("context-handoff")))
     .option("--no-context-handoff", "Keep context handoff off for this launch even when launcher.toml (context_handoff = true) or MNEMOM_AGENT_CONTEXT_HANDOFF turns it on")
-    .addOption(new Option("--compaction-intercept", "EXPERIMENTAL (`mnemom experimental enable compaction-intercept`): tell the gateway to report the real context size (Claude Code compacts at its own threshold) and answer the compaction at once from its fold, for this session").hideHelp(hiddenUnless("compaction-intercept")))
-    .option("--no-compaction-intercept", "Keep the compaction intercept off for this launch even when launcher.toml (compaction_intercept = true) or MNEMOM_AGENT_COMPACTION_INTERCEPT turns it on")
+    .option("--compaction-intercept", "Turn the compaction intercept on for this launch even when launcher.toml (compaction_intercept = false) or MNEMOM_AGENT_COMPACTION_INTERCEPT=0 turns it off. On by default: the gateway reports the real context size (so Claude Code compacts at its own threshold) and answers the compaction at once from its fold")
+    .option("--no-compaction-intercept", "Turn the compaction intercept off for this launch (it is on by default) — Claude Code's compaction goes to the model as usual. To turn it off for every launch: config key compaction_intercept = false, or env MNEMOM_AGENT_COMPACTION_INTERCEPT=0")
     .option("--dry-run", "Print the resolved launch plan and exit — no key read, no spawn")
     .option("--first-run", "Show the first-run look again: what Mnemom would have saved on your last 30 days of Claude Code (runs on this machine, read-only, nothing uploaded) — then exit")
     .action(async (scenario, passthrough, opts) => {
@@ -278,19 +278,6 @@ const agentCmd = program
                 used: opts.contextHandoff === true,
             },
             { what: "--implicit", id: "implicit", used: opts.implicit === true },
-            {
-                what: "--compaction-intercept",
-                id: "compaction-intercept",
-                used: opts.compactionIntercept === true,
-            },
-            // --compact-at arms the SAME two gateway keys --compaction-intercept does
-            // (buildSessionConfig ORs them) — it needs the identical opt-in, not a free pass
-            // around it. `null`/unset ("1m"/"off"/no flag) is not a target, so it never gates.
-            {
-                what: "--compact-at",
-                id: "compaction-intercept",
-                used: typeof compactAtFlag === "number",
-            },
         ], experimental);
         if (opts.gateway)
             process.env.MNEMOM_AGENT_GATEWAY = opts.gateway;
@@ -379,16 +366,13 @@ const agentCmd = program
             slack: opts.slack ?? cfg.slackListen,
             context: opts.context,
             contextProfile: opts.contextProfile,
-            // Same gate: off ⇒ an explicit null (no target), so MNEMOM_COMPACT_AT cannot arm it —
-            // an armed --compact-at was already refused above, and ignoredSettingLines told the
-            // user the env value is ignored, so this is what makes that true.
-            compactAt: experimental.includes("compaction-intercept") ? compactAtFlag : null,
+            // undefined ⇒ MNEMOM_COMPACT_AT / launcher.toml compact_at (resolveCompactAt).
+            compactAt: compactAtFlag,
             // Off ⇒ an explicit false, so MNEMOM_AGENT_CONTEXT_HANDOFF cannot turn it on.
             contextHandoff: experimental.includes("context-handoff") ? opts.contextHandoff : false,
-            // Same gate: off ⇒ an explicit false, so MNEMOM_AGENT_COMPACTION_INTERCEPT cannot turn it on.
-            compactionIntercept: experimental.includes("compaction-intercept")
-                ? opts.compactionIntercept
-                : false,
+            // On by default (since 0.17.23, no longer experimental): undefined ⇒
+            // MNEMOM_AGENT_COMPACTION_INTERCEPT / launcher.toml compaction_intercept, else ON.
+            compactionIntercept: opts.compactionIntercept,
             experimental,
             setup: opts.setup,
             governance,

package/dist/lib/agent.d.ts

@@ -342,16 +342,24 @@ export declare const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT
 export declare const CONTEXT_SIZE_POLICY_KEY = "CONTEXT_RUNTIME_SIZE_POLICY";
 /**
  * The two gateway env keys the `compaction_intercept` setting turns on for a single session
- * (payload-bound fix; both default OFF on the gateway, both read from the per-session overlay):
+ * (payload-bound fix; both read from the per-session overlay). The us-2 prod cell runs both on in
+ * its own cell env; the test and us-1 preview cells leave them at the gateway default (off). Since
+ * 0.17.23 the CLI asks for them on every launch — a deliberate, authorized rollout decision
+ * (MNE-8532, CTO 2026-10-12): every cell a `mnemom agent` session runs on then behaves like
+ * prod, rather than the CLI deferring to a non-prod cell's off default. The keys are TUNE-tier
+ * (gateway session-config allowlist, honored for any authenticated agent), so a cell without
+ * the companion support drops them and the session behaves as before.
  *   - `GATEWAY_USAGE_REAL_SIZE` — report the size of the body the client actually sent (the
  *     REAL, unfolded context) in the last `usage.iterations` entry, so Claude Code's own
  *     auto-compact threshold (its 1M default, or the user's `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` /
  *     `CLAUDE_CODE_AUTO_COMPACT_WINDOW` / `autoCompactWindow`) fires as it would without the fold;
  *   - `GATEWAY_COMPACTION_INTERCEPT` — answer the client's compaction request at once from the
  *     gateway's own fold digest (no model call), so the compaction never blocks the user.
- * Sent together, value `"on"`, when the `compaction_intercept` setting is on
- * (`resolveCompactionIntercept`) OR when `--compact-at` arms a target below 1M (below) — a
- * target cannot be honored without both. The `off` context profile sends both as `"off"`.
+ * Sent together, value `"on"`, when the `compaction_intercept` setting is on — the DEFAULT since
+ * 0.17.23 (`resolveCompactionIntercept`) — OR when `--compact-at` arms a target below 1M (below):
+ * a target cannot be honored without both. An opt-out (`--no-compaction-intercept`,
+ * `compaction_intercept = false`, `MNEMOM_AGENT_COMPACTION_INTERCEPT=0`) and the `off` context
+ * profile send both as `"off"`, so the opt-out holds on a cell whose own default is on.
  */
 export declare const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
 export declare const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
@@ -461,8 +469,7 @@ export declare function resolveCompactAt(opts: {
  * (either silently re-arming the intercept the user just turned off, or silently sending an
  * inert upload-target the gateway can never act on). `compactionIntercept` here is the raw,
  * pre-`resolveCompactionIntercept` flag value: `false` only when `--no-compaction-intercept`
- * was explicitly passed (or the experimental gate forced it, which `compactAt` cannot reach
- * past either — see index.ts's `assertEnabled`), never the mere absence of `--compaction-intercept`.
+ * was explicitly passed, never the mere absence of `--compaction-intercept`.
  */
 export declare function assertCompactAtCompatible(opts: {
     compactionIntercept?: boolean;
@@ -648,18 +655,23 @@ export declare function resolveContextProfile(opts: {
  * no profile was chosen), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
  * `GATEWAY_USAGE_SAVINGS: "on"` when measured savings is ON (under every profile), then
  * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when EITHER the
- * `compaction_intercept` setting is ON OR `--compact-at` arms a target below 1M (the target
- * cannot be honored without the intercept), then `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`
- * when a target is set. The `off` profile wins over the intercept and the target: a session with
+ * `compaction_intercept` setting is ON (the default) OR `--compact-at` arms a target below 1M (the
+ * target cannot be honored without the intercept) — or both as `"off"` when the setting is
+ * explicitly `false` (an opt-out) and no target is armed, so the opt-out holds on a cell whose own
+ * env turns them on — then `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"` when a target is set. The `off` profile wins over the intercept and the target: a session with
  * no fold never has its compaction intercepted (`assertOffProfileCompatible` refuses the explicit
  * flag pair; a standing intercept or target from the environment or launcher.toml is dropped).
- * Empty with no profile chosen and everything off — the common case, where
- * no header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
+ * Empty with no profile chosen, everything else off and `compactionIntercept` absent (callers
+ * that do not resolve it) — then no header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
  */
 export declare function buildSessionConfig(opts: {
     /** `resolveContextProfile` output: `null` ⇒ no profile chosen, no fold key sent. */
     profile: ContextProfile | null;
     contextHandoff: boolean;
+    /**
+     * `resolveCompactionIntercept` output: `true` (the default) ⇒ both keys `"on"`; `false` (an
+     * opt-out) ⇒ both `"off"`; absent ⇒ neither key is sent (the cell's own default stands).
+     */
     compactionIntercept?: boolean;
     /** `resolveCompactAt` output: `null` (or absent) ⇒ no target, send nothing new. */
     compactAt?: number | null;
@@ -691,8 +703,8 @@ export declare function buildSessionConfigPayload(opts: {
  *     `aggressive` → the three fold-tuning keys + `CONTEXT_RUNTIME_SIZE_POLICY: "off"`,
  *     `balanced` → `CONTEXT_RUNTIME_SIZE_POLICY: "off"`, `adaptive` →
  *     `CONTEXT_RUNTIME_SIZE_POLICY: "banded"`, none chosen → nothing;
- *   - `compactionIntercept: true` → `GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT`
- *     `"on"` (the `compaction_intercept` setting);
+ *   - `compactionIntercept: true` (the default) → `GATEWAY_USAGE_REAL_SIZE` +
+ *     `GATEWAY_COMPACTION_INTERCEPT` `"on"`; `false` (an opt-out) → both `"off"`;
  *   - `compactAt: <N>` (`--compact-at`, below 1M) → the SAME two intercept keys plus
  *     `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`; unset, `1m` or `off` → nothing beyond
  *     what `compactionIntercept` already sent (Claude Code's own 1M window, untouched);
@@ -725,10 +737,11 @@ export declare function resolveContextHandoff(opts: {
 }): boolean;
 /**
  * Is the compaction intercept (`GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT` in the
- * session-config header) ON for this launch? OFF by default, same shape as
- * `resolveContextHandoff`: an explicit `--compaction-intercept` / `--no-compaction-intercept`
- * wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which `applyConfigToEnv` sets from the
- * `compaction_intercept` config key), else OFF.
+ * session-config header) ON for this launch? ON by default since 0.17.23 (it graduated from the
+ * `compaction-intercept` experimental feature). An explicit `--compaction-intercept` /
+ * `--no-compaction-intercept` wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which
+ * `applyConfigToEnv` sets from the `compaction_intercept` config key: `0`/`false`/`off`/`no`
+ * opt out), else ON.
  */
 export declare function resolveCompactionIntercept(opts: {
     compactionIntercept?: boolean;

package/dist/lib/agent.js

@@ -503,16 +503,24 @@ export const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT_RECLAIM
 export const CONTEXT_SIZE_POLICY_KEY = "CONTEXT_RUNTIME_SIZE_POLICY";
 /**
  * The two gateway env keys the `compaction_intercept` setting turns on for a single session
- * (payload-bound fix; both default OFF on the gateway, both read from the per-session overlay):
+ * (payload-bound fix; both read from the per-session overlay). The us-2 prod cell runs both on in
+ * its own cell env; the test and us-1 preview cells leave them at the gateway default (off). Since
+ * 0.17.23 the CLI asks for them on every launch — a deliberate, authorized rollout decision
+ * (MNE-8532, CTO 2026-10-12): every cell a `mnemom agent` session runs on then behaves like
+ * prod, rather than the CLI deferring to a non-prod cell's off default. The keys are TUNE-tier
+ * (gateway session-config allowlist, honored for any authenticated agent), so a cell without
+ * the companion support drops them and the session behaves as before.
  *   - `GATEWAY_USAGE_REAL_SIZE` — report the size of the body the client actually sent (the
  *     REAL, unfolded context) in the last `usage.iterations` entry, so Claude Code's own
  *     auto-compact threshold (its 1M default, or the user's `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` /
  *     `CLAUDE_CODE_AUTO_COMPACT_WINDOW` / `autoCompactWindow`) fires as it would without the fold;
  *   - `GATEWAY_COMPACTION_INTERCEPT` — answer the client's compaction request at once from the
  *     gateway's own fold digest (no model call), so the compaction never blocks the user.
- * Sent together, value `"on"`, when the `compaction_intercept` setting is on
- * (`resolveCompactionIntercept`) OR when `--compact-at` arms a target below 1M (below) — a
- * target cannot be honored without both. The `off` context profile sends both as `"off"`.
+ * Sent together, value `"on"`, when the `compaction_intercept` setting is on — the DEFAULT since
+ * 0.17.23 (`resolveCompactionIntercept`) — OR when `--compact-at` arms a target below 1M (below):
+ * a target cannot be honored without both. An opt-out (`--no-compaction-intercept`,
+ * `compaction_intercept = false`, `MNEMOM_AGENT_COMPACTION_INTERCEPT=0`) and the `off` context
+ * profile send both as `"off"`, so the opt-out holds on a cell whose own default is on.
  */
 export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
 export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
@@ -576,12 +584,12 @@ export const CONTEXT_HANDOFF_KEY = "CONTEXT_HANDOFF_ENABLED";
 // Lets an operator play with WHEN the gateway pulls this session's own client-visible
 // compaction point forward (GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS, #2251), instead of
 // leaving Claude Code to compact on its own 1M-window schedule. Unset / `1m` / `off` all
-// mean the SAME thing — no target — so a launch with nothing else configured sends no new
-// header keys at all and behaves exactly as it did before this setting existed: Claude
-// Code's own 1M window, no gateway-triggered compaction. A value strictly below 1,000,000
-// arms the compaction intercept (USAGE_REAL_SIZE_KEY + COMPACTION_INTERCEPT_KEY, above — the
-// same two keys `--compaction-intercept` arms, #2216, both required for the upload pull to be
-// honored instead of silently inert) plus the target itself. Refold (GATEWAY_COMPACTION_REFOLD)
+// mean the SAME thing — no target — so no target key is sent: Claude Code's own 1M window, no
+// gateway-triggered compaction. A value strictly below 1,000,000 sends the target itself and
+// arms the compaction intercept (USAGE_REAL_SIZE_KEY + COMPACTION_INTERCEPT_KEY, above — on by
+// default since 0.17.23; #2216: both are required for the upload pull to be honored instead of
+// silently inert), even over a standing opt-out in launcher.toml or the environment; only an
+// explicit --no-compaction-intercept in the same launch is refused (assertCompactAtCompatible). Refold (GATEWAY_COMPACTION_REFOLD)
 // is a SEPARATE, costlier opt-in (+9.5pts measured) — this setting never touches it. This never
 // sets a Claude Code autocompact env/window: Claude Code's own compaction math is untouched;
 // only what the GATEWAY reports back changes.
@@ -704,15 +712,13 @@ export function resolveCompactAt(opts) {
  * (either silently re-arming the intercept the user just turned off, or silently sending an
  * inert upload-target the gateway can never act on). `compactionIntercept` here is the raw,
  * pre-`resolveCompactionIntercept` flag value: `false` only when `--no-compaction-intercept`
- * was explicitly passed (or the experimental gate forced it, which `compactAt` cannot reach
- * past either — see index.ts's `assertEnabled`), never the mere absence of `--compaction-intercept`.
+ * was explicitly passed, never the mere absence of `--compaction-intercept`.
  */
 export function assertCompactAtCompatible(opts) {
     if (opts.compactionIntercept === false && opts.compactAt !== null) {
-        throw new Error("mnemom agent: --compact-at needs the compaction intercept to arm, but it is off for " +
-            "this launch (--no-compaction-intercept, or the compaction-intercept experimental " +
-            "feature is disabled). Drop --no-compaction-intercept (and run `mnemom experimental " +
-            "enable compaction-intercept`), or pass --compact-at off.");
+        throw new Error("mnemom agent: --compact-at needs the compaction intercept to arm, but " +
+            "--no-compaction-intercept turns it off for this launch. Drop --no-compaction-intercept, " +
+            "or pass --compact-at off.");
     }
 }
 /**
@@ -1039,13 +1045,14 @@ export function resolveContextProfile(opts) {
  * no profile was chosen), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
  * `GATEWAY_USAGE_SAVINGS: "on"` when measured savings is ON (under every profile), then
  * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when EITHER the
- * `compaction_intercept` setting is ON OR `--compact-at` arms a target below 1M (the target
- * cannot be honored without the intercept), then `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`
- * when a target is set. The `off` profile wins over the intercept and the target: a session with
+ * `compaction_intercept` setting is ON (the default) OR `--compact-at` arms a target below 1M (the
+ * target cannot be honored without the intercept) — or both as `"off"` when the setting is
+ * explicitly `false` (an opt-out) and no target is armed, so the opt-out holds on a cell whose own
+ * env turns them on — then `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"` when a target is set. The `off` profile wins over the intercept and the target: a session with
  * no fold never has its compaction intercepted (`assertOffProfileCompatible` refuses the explicit
  * flag pair; a standing intercept or target from the environment or launcher.toml is dropped).
- * Empty with no profile chosen and everything off — the common case, where
- * no header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
+ * Empty with no profile chosen, everything else off and `compactionIntercept` absent (callers
+ * that do not resolve it) — then no header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
  */
 export function buildSessionConfig(opts) {
     const config = {};
@@ -1068,6 +1075,12 @@ export function buildSessionConfig(opts) {
         config[USAGE_REAL_SIZE_KEY] = "on";
         config[COMPACTION_INTERCEPT_KEY] = "on";
     }
+    else if (opts.compactionIntercept === false) {
+        // An opt-out says "off" by name: sending nothing would leave a cell whose own env turns the
+        // intercept on (us-2) intercepting anyway.
+        config[USAGE_REAL_SIZE_KEY] = "off";
+        config[COMPACTION_INTERCEPT_KEY] = "off";
+    }
     if (hasCompactionTarget) {
         config[GATEWAY_COMPACTION_UPLOAD_TARGET_KEY] = String(opts.compactAt);
     }
@@ -1095,8 +1108,8 @@ export function buildSessionConfigPayload(opts) {
  *     `aggressive` → the three fold-tuning keys + `CONTEXT_RUNTIME_SIZE_POLICY: "off"`,
  *     `balanced` → `CONTEXT_RUNTIME_SIZE_POLICY: "off"`, `adaptive` →
  *     `CONTEXT_RUNTIME_SIZE_POLICY: "banded"`, none chosen → nothing;
- *   - `compactionIntercept: true` → `GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT`
- *     `"on"` (the `compaction_intercept` setting);
+ *   - `compactionIntercept: true` (the default) → `GATEWAY_USAGE_REAL_SIZE` +
+ *     `GATEWAY_COMPACTION_INTERCEPT` `"on"`; `false` (an opt-out) → both `"off"`;
  *   - `compactAt: <N>` (`--compact-at`, below 1M) → the SAME two intercept keys plus
  *     `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`; unset, `1m` or `off` → nothing beyond
  *     what `compactionIntercept` already sent (Claude Code's own 1M window, untouched);
@@ -1131,18 +1144,17 @@ export function resolveContextHandoff(opts) {
 }
 /**
  * Is the compaction intercept (`GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT` in the
- * session-config header) ON for this launch? OFF by default, same shape as
- * `resolveContextHandoff`: an explicit `--compaction-intercept` / `--no-compaction-intercept`
- * wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which `applyConfigToEnv` sets from the
- * `compaction_intercept` config key), else OFF.
+ * session-config header) ON for this launch? ON by default since 0.17.23 (it graduated from the
+ * `compaction-intercept` experimental feature). An explicit `--compaction-intercept` /
+ * `--no-compaction-intercept` wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which
+ * `applyConfigToEnv` sets from the `compaction_intercept` config key: `0`/`false`/`off`/`no`
+ * opt out), else ON.
  */
 export function resolveCompactionIntercept(opts) {
     if (opts.compactionIntercept !== undefined)
         return opts.compactionIntercept;
     const raw = (opts.env?.MNEMOM_AGENT_COMPACTION_INTERCEPT ?? "").trim().toLowerCase();
-    if (raw === "")
-        return false;
-    return raw === "1" || raw === "true" || raw === "on" || raw === "yes";
+    return !(raw === "0" || raw === "false" || raw === "off" || raw === "no");
 }
 /**
  * Does the gateway measure this launch's saving (`GATEWAY_USAGE_SAVINGS` in the header, and the

package/dist/lib/experimental.d.ts

@@ -12,16 +12,20 @@
  * Everything here is pure or dependency-injected; index.ts and the command
  * modules are the thin drivers.
  */
-export type ExperimentalId = "context-handoff" | "slack" | "implicit" | "compaction-intercept" | "measured-savings";
+export type ExperimentalId = "context-handoff" | "slack" | "implicit" | "measured-savings";
 /**
- * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
- * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
- * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
- * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
- * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
- * admitting a value the real parser would reject anyway.
+ * Features that used to be experimental and are now on by default for everyone. Their ids are
+ * no longer in the registry, but `mnemom experimental enable|disable <id>` still accepts them
+ * as a no-op (with a one-line note naming the release and the real opt-out) instead of failing
+ * on an id a user, a script or an old README still names. Value: the release that graduated it
+ * and how to turn it off now.
  */
-export declare function compactAtArmed(raw: string | undefined): boolean;
+export declare const GRADUATED_FEATURES: Readonly<Record<string, {
+    since: string;
+    optOut: string;
+}>>;
+/** The one-line note for `mnemom experimental enable|disable <graduated id>`; null otherwise. */
+export declare function graduatedNote(id: string): string | null;
 export interface ExperimentalFeature {
     id: ExperimentalId;
     summary: string;
@@ -82,8 +86,7 @@ export declare function assertEnabled(uses: ReadonlyArray<{
 export declare function experimentalIdForConfigKey(key: string, value: string): ExperimentalId | undefined;
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
- * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
+ * is off: launcher.toml keys (`entries` as `[key, value]`) and MNEMOM_AGENT_CONTEXT_HANDOFF.
  */
 export declare function ignoredSettingLines(opts: {
     entries: ReadonlyArray<[string, string]>;

package/dist/lib/experimental.js

@@ -13,16 +13,24 @@
  * modules are the thin drivers.
  */
 /**
- * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
- * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
- * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
- * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
- * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
- * admitting a value the real parser would reject anyway.
+ * Features that used to be experimental and are now on by default for everyone. Their ids are
+ * no longer in the registry, but `mnemom experimental enable|disable <id>` still accepts them
+ * as a no-op (with a one-line note naming the release and the real opt-out) instead of failing
+ * on an id a user, a script or an old README still names. Value: the release that graduated it
+ * and how to turn it off now.
  */
-export function compactAtArmed(raw) {
-    const v = (raw ?? "").trim().toLowerCase();
-    return v !== "" && v !== "1m" && v !== "off";
+export const GRADUATED_FEATURES = {
+    "compaction-intercept": {
+        since: "0.17.23",
+        optOut: "--no-compaction-intercept, `compaction_intercept = false` in launcher.toml, or MNEMOM_AGENT_COMPACTION_INTERCEPT=0",
+    },
+};
+/** The one-line note for `mnemom experimental enable|disable <graduated id>`; null otherwise. */
+export function graduatedNote(id) {
+    const g = GRADUATED_FEATURES[id];
+    if (!g)
+        return null;
+    return `${id} is no longer experimental: it is on by default since ${g.since}, so this changes nothing. To turn it off: ${g.optOut}.`;
 }
 export const EXPERIMENTAL_FEATURES = [
     {
@@ -58,17 +66,6 @@ export const EXPERIMENTAL_FEATURES = [
             env: [],
         },
     },
-    {
-        id: "compaction-intercept",
-        summary: "Have the gateway report the real context size (so Claude Code compacts at its own threshold) and answer the compaction at once from its fold",
-        since: "0.17.4",
-        gates: {
-            flags: ["--compaction-intercept"],
-            configKeys: ["compaction_intercept"],
-            commands: [],
-            env: ["MNEMOM_AGENT_COMPACTION_INTERCEPT"],
-        },
-    },
     {
         // No flag, launcher.toml key or env of its own: `mnemom experimental enable` is the switch.
         id: "measured-savings",
@@ -162,25 +159,19 @@ export function experimentalIdForConfigKey(key, value) {
             return value === "true" ? "slack" : undefined;
         case "context_handoff":
             return value === "true" ? "context-handoff" : undefined;
-        case "compaction_intercept":
-            return value === "true" ? "compaction-intercept" : undefined;
-        case "compact_at":
-            // Arms the SAME gateway keys compaction_intercept does — same gate.
-            return compactAtArmed(value) ? "compaction-intercept" : undefined;
         case "goal_mode":
             return value === "implicit" ? "implicit" : undefined;
         default:
             return undefined;
     }
 }
-/** Is an env value one of the truthy spellings resolveContextHandoff / resolveCompactionIntercept accept? */
+/** Is an env value one of the truthy spellings resolveContextHandoff accepts? */
 function truthy(raw) {
     return ["1", "true", "on", "yes"].includes((raw ?? "").trim().toLowerCase());
 }
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
- * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
+ * is off: launcher.toml keys (`entries` as `[key, value]`) and MNEMOM_AGENT_CONTEXT_HANDOFF.
  */
 export function ignoredSettingLines(opts) {
     const lines = [];
@@ -193,14 +184,6 @@ export function ignoredSettingLines(opts) {
     if (truthy(opts.env.MNEMOM_AGENT_CONTEXT_HANDOFF) && !opts.enabled.includes("context-handoff")) {
         lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_CONTEXT_HANDOFF", "context-handoff")}`);
     }
-    if (truthy(opts.env.MNEMOM_AGENT_COMPACTION_INTERCEPT) &&
-        !opts.enabled.includes("compaction-intercept")) {
-        lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_COMPACTION_INTERCEPT", "compaction-intercept")}`);
-    }
-    if (compactAtArmed(opts.env.MNEMOM_COMPACT_AT) &&
-        !opts.enabled.includes("compaction-intercept")) {
-        lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_COMPACT_AT", "compaction-intercept")}`);
-    }
     return lines;
 }
 /** The features an existing launcher.toml already uses (the one-time migration). */
@@ -250,8 +233,6 @@ export function configKeyFeature(key) {
         return "slack";
     if (key === "context_handoff")
         return "context-handoff";
-    if (key === "compaction_intercept")
-        return "compaction-intercept";
     if (key === "goal_mode")
         return "implicit";
     return undefined;

package/dist/lib/launcher-config.d.ts

@@ -50,9 +50,9 @@ export interface LauncherConfig {
      */
     contextHandoff?: boolean;
     /**
-     * Compaction-intercept default (EXPERIMENTAL, off when unset): `true` sends
+     * Compaction-intercept default (ON when unset, since 0.17.23): `true` sends
      * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` in the per-session
-     * config header for every launch. Off means no header key at all.
+     * config header for every launch; `false` opts out and sends both as `"off"`.
      */
     compactionIntercept?: boolean;
     /**
@@ -121,9 +121,8 @@ export declare function launcherEntries(cfg: LauncherConfig): Array<[string, str
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, `compaction_intercept` (and an ARMED `compact_at` — it arms the same two gateway keys,
- * so it needs the same opt-in; `compact_at = "off"`/`"1m"` carries no gated behaviour and is
- * kept) while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is
- * off (`goal_mode = off` is kept).
+ * off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * `compaction_intercept` / `compact_at` are not experimental (on by default since 0.17.23) and
+ * always pass through.
  */
 export declare function withoutDisabledExperimental(cfg: LauncherConfig, enabled: readonly ExperimentalId[]): LauncherConfig;

package/dist/lib/launcher-config.js

@@ -20,7 +20,6 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { dirname, join } from "node:path";
 import { parse as parseToml, stringify as stringifyToml, TomlError } from "smol-toml";
 import { MNEMOM_DIR } from "./config.js";
-import { compactAtArmed } from "./experimental.js";
 import { CONTEXT_PROFILES, isPositiveInt, isPositiveNumber, parseCompactAt, parseContextProfile, } from "./agent.js";
 /** The human-editable settings file. Secret key lives elsewhere (launcher.json). */
 export const LAUNCHER_CONFIG_PATH = join(MNEMOM_DIR, "launcher.toml");
@@ -207,7 +206,7 @@ export const CONFIG_KEYS = [
     },
     {
         key: "compaction_intercept",
-        describe: "EXPERIMENTAL: tell the gateway GATEWAY_USAGE_REAL_SIZE=on + GATEWAY_COMPACTION_INTERCEPT=on (off by default)",
+        describe: "Compaction intercept: the gateway reports the real context size and answers Claude Code's compaction from its fold (GATEWAY_USAGE_REAL_SIZE + GATEWAY_COMPACTION_INTERCEPT; on by default, false opts out)",
         get: (c) => c.compactionIntercept,
         set: (c, v) => {
             c.compactionIntercept = coerceBool("compaction_intercept", v);
@@ -467,10 +466,9 @@ export function launcherEntries(cfg) {
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, `compaction_intercept` (and an ARMED `compact_at` — it arms the same two gateway keys,
- * so it needs the same opt-in; `compact_at = "off"`/`"1m"` carries no gated behaviour and is
- * kept) while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is
- * off (`goal_mode = off` is kept).
+ * off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * `compaction_intercept` / `compact_at` are not experimental (on by default since 0.17.23) and
+ * always pass through.
  */
 export function withoutDisabledExperimental(cfg, enabled) {
     const out = { ...cfg };
@@ -481,11 +479,6 @@ export function withoutDisabledExperimental(cfg, enabled) {
     }
     if (!enabled.includes("context-handoff"))
         delete out.contextHandoff;
-    if (!enabled.includes("compaction-intercept")) {
-        delete out.compactionIntercept;
-        if (compactAtArmed(out.compactAt))
-            delete out.compactAt;
-    }
     if (!enabled.includes("implicit") && out.goalMode === "implicit")
         delete out.goalMode;
     return out;

package/dist/rc-certs.mjs

@@ -0,0 +1,186 @@
+// Certificate checks and leaf rotation for the Remote Control MITM proxy (rc-proxy.mjs).
+//
+// The proxy mints its CA and leaf by shelling out to whatever `openssl` is first on PATH. On macOS
+// that is often /usr/bin/openssl (LibreSSL), whose defaults differ from OpenSSL 3's: `x509 -req`
+// signs with SHA-1, and EC keys come out with explicit curve parameters. Node (OpenSSL 3) refuses
+// both — a SHA-1 leaf at https.createServer (ERR_SSL_CA_MD_TOO_WEAK), an explicit-parameter key at
+// the client's chain verification. rc-proxy.mjs pins `-sha256` and `ec_param_enc:named_curve`;
+// this module is the fail-closed check behind that pin, so an openssl that still mints something
+// Node cannot use stops the proxy with a message naming the binary, not a raw Node stack trace.
+//
+// Node 22's X509Certificate has no signatureAlgorithm getter, and it reports `namedCurve` even for
+// an explicit-parameter key, so the two properties are read from the certificate's DER directly.
+
+import fs from "node:fs";
+import path from "node:path";
+import tls from "node:tls";
+import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
+
+const SIG_ALGS = {
+  "2a8648ce3d0401": "ecdsa-with-SHA1",
+  "2a8648ce3d040301": "ecdsa-with-SHA224",
+  "2a8648ce3d040302": "ecdsa-with-SHA256",
+  "2a8648ce3d040303": "ecdsa-with-SHA384",
+  "2a8648ce3d040304": "ecdsa-with-SHA512",
+  "2a864886f70d010104": "md5WithRSAEncryption",
+  "2a864886f70d010105": "sha1WithRSAEncryption",
+  "2a864886f70d01010b": "sha256WithRSAEncryption",
+  "2a864886f70d01010c": "sha384WithRSAEncryption",
+  "2a864886f70d01010d": "sha512WithRSAEncryption",
+};
+const STRONG_SIG_ALGS = new Set([
+  "ecdsa-with-SHA256",
+  "ecdsa-with-SHA384",
+  "ecdsa-with-SHA512",
+  "sha256WithRSAEncryption",
+  "sha384WithRSAEncryption",
+  "sha512WithRSAEncryption",
+]);
+const OID_EC_PUBLIC_KEY = "2a8648ce3d0201";
+
+// One DER TLV at `off`: { tag, start (of the value), end }.
+function tlv(buf, off) {
+  if (off + 2 > buf.length) throw new Error("truncated DER");
+  const tag = buf[off];
+  let len = buf[off + 1];
+  let start = off + 2;
+  if (len & 0x80) {
+    const n = len & 0x7f;
+    if (n < 1 || n > 4 || start + n > buf.length) throw new Error("bad DER length");
+    len = 0;
+    for (let i = 0; i < n; i++) len = len * 256 + buf[start + i];
+    start += n;
+  }
+  const end = start + len;
+  if (end > buf.length) throw new Error("truncated DER");
+  return { tag, start, end };
+}
+
+function children(buf, node) {
+  const out = [];
+  for (let o = node.start; o < node.end; ) {
+    const c = tlv(buf, o);
+    out.push(c);
+    o = c.end;
+  }
+  return out;
+}
+
+const hex = (buf, node) => buf.subarray(node.start, node.end).toString("hex");
+
+/**
+ * The signature algorithm and EC parameter encoding of a certificate, read from its DER:
+ * { signatureAlgorithm: "ecdsa-with-SHA256" | … | "oid:<hex>", ecParams: "named" | "explicit" | null }
+ * (ecParams is null for a non-EC key).
+ */
+export function describeCert(pemOrDer) {
+  const der =
+    Buffer.isBuffer(pemOrDer) && pemOrDer[0] === 0x30
+      ? pemOrDer
+      : new crypto.X509Certificate(pemOrDer).raw;
+  const [tbs, sigAlg] = children(der, tlv(der, 0)); // Certificate ::= SEQ { tbs, sigAlg, sig }
+  const sigOid = hex(der, children(der, sigAlg)[0]);
+  const t = children(der, tbs);
+  const spki = t[t[0].tag === 0xa0 ? 6 : 5]; // [0] version?, serial, sigAlg, issuer, validity, subject, spki
+  const [algId] = children(der, spki);
+  const [keyOid, params] = children(der, algId);
+  let ecParams = null;
+  if (hex(der, keyOid) === OID_EC_PUBLIC_KEY) {
+    ecParams = params && params.tag === 0x06 ? "named" : "explicit";
+  }
+  return { signatureAlgorithm: SIG_ALGS[sigOid] || `oid:${sigOid}`, ecParams };
+}
+
+/** What makes this certificate unusable by Node's TLS stack, as phrases; empty when none. */
+export function certProblems(pem) {
+  const { signatureAlgorithm, ecParams } = describeCert(pem);
+  const problems = [];
+  if (!STRONG_SIG_ALGS.has(signatureAlgorithm)) {
+    problems.push(`signed with ${signatureAlgorithm} (Node needs SHA-256 or stronger)`);
+  }
+  if (ecParams === "explicit") {
+    problems.push("EC key with explicit curve parameters (Node needs a named curve)");
+  }
+  return problems;
+}
+
+/**
+ * "/usr/bin/openssl (LibreSSL 3.3.6)" — the `openssl` the proxy runs (the first on env.PATH, as
+ * execFileSync resolves it), for error messages. The version comes from running THAT binary.
+ */
+export function opensslIdentity(env = process.env) {
+  let found = null;
+  for (const dir of (env.PATH || "").split(path.delimiter)) {
+    if (!dir) continue; // an empty PATH segment ("a::b") is not the cwd here
+    const f = path.join(dir, "openssl");
+    try {
+      fs.accessSync(f, fs.constants.X_OK);
+      found = f;
+      break;
+    } catch {
+      /* next */
+    }
+  }
+  if (!found) return "openssl (not found on PATH)";
+  let version = "version unknown";
+  try {
+    version = execFileSync(found, ["version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env,
+    }).trim();
+  } catch {
+    /* keep "version unknown" */
+  }
+  return `${found} (${version})`;
+}
+
+/**
+ * Throws if `cert` (the CA, when `role` is "CA") cannot be used by Node. For a leaf, also builds
+ * the exact secure context https.createServer / setSecureContext will, so anything else Node
+ * refuses (a key/cert mismatch, a digest under the security level) fails here, with a message.
+ */
+export function assertUsableCert({ role, cert, key }, env = process.env) {
+  const problems = certProblems(cert);
+  if (!problems.length && key) {
+    try {
+      tls.createSecureContext({ key, cert });
+    } catch (e) {
+      problems.push(`Node refuses it: ${e.code || e.message}`);
+    }
+  }
+  if (problems.length) {
+    throw new Error(
+      `${opensslIdentity(env)} minted a ${role} certificate Node cannot use: ${problems.join("; ")}. ` +
+        "Put OpenSSL 3 first on PATH (macOS: `brew install openssl@3`) and relaunch.",
+    );
+  }
+}
+
+/**
+ * The leaf in force, and how to replace it. rotate() mints a new leaf and installs it; only when
+ * BOTH succeed does the new leaf become current. Before this, `leaf = mint()` ran ahead of the
+ * install, so an install that threw left the server serving the old leaf while `notAfter` already
+ * held the new leaf's expiry — the CONNECT handler's "expiring" check then never retried, and the
+ * session broke with an expired certificate once the original leaf ran out.
+ */
+export function makeLeafRotator({ initial, mint, install, log, errText = (e) => e.message }) {
+  let leaf = initial;
+  return {
+    current: () => leaf,
+    rotate(why) {
+      let next;
+      try {
+        next = mint();
+        install(next);
+      } catch (e) {
+        log(`leaf rotation FAILED (${why}), keeping the current leaf: ${errText(e)}`);
+        return false;
+      }
+      leaf = next;
+      log(`leaf rotated (${why}) notAfter=${new Date(leaf.notAfter).toISOString()}`);
+      return true;
+    },
+  };
+}

package/dist/rc-proxy.mjs

@@ -92,6 +92,7 @@ import crypto from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { TURN_HEADER, TurnOrigins, turnHeaderEnabled, turnHeaderFor } from "./turn-origin.mjs";
 import { OWNER_FILE, ensureRcStateRoot, keepPrivateDir, sweepRcDirs } from "./rc-state.mjs";
+import { assertUsableCert, makeLeafRotator } from "./rc-certs.mjs";
 
 const MITM_HOST = "api.anthropic.com";
 const env = process.env;
@@ -180,7 +181,19 @@ if (SUBSCRIPTION) {
 // session picks it up on its next TLS handshake. (A 2-day CA + leaf with the CA key deleted at
 // startup broke every session older than 48 h with "SSL certificate has expired".) openssl only
 // takes the CA key from a file, so each signing writes it 0600 into caDir and deletes it right
-// after. Works with macOS's system LibreSSL (3.3+) and OpenSSL 1.1.1+ (`-addext`).
+// after. The openssl flags used (`-addext`, `-pkeyopt`, `-sha256`) exist in OpenSSL 1.1.1+ and 3
+// and in LibreSSL 3.3+ (macOS's /usr/bin/openssl).
+//
+// Until the digest and curve encoding were pinned, this only ever worked with OpenSSL 3 first on
+// PATH: no call passed a digest, and LibreSSL's defaults differ from OpenSSL 3's in two ways that
+// each break Node (OpenSSL 3), whatever the Node version. (1) `x509 -req` signs with
+// ecdsa-with-SHA1, and https.createServer refuses that leaf with ERR_SSL_CA_MD_TOO_WEAK — the proxy
+// died before READY and --remote-control refused to launch. (2) EC keys are written with explicit
+// curve parameters, and a client verifying the chain rejects them ("Certificate public key has
+// explicit ECC parameters"). So every call passes `-sha256` and `ec_param_enc:named_curve`, and
+// every minted CA and leaf is checked before use (assertUsableCert, rc-certs.mjs): an openssl that
+// still produces something Node cannot use stops the proxy with a message naming the binary and
+// its version — or, for a rotation, fails that rotation and keeps the current leaf.
 //
 // Nothing may take the CA files mid-session. In the OS temp dir, macOS's dirhelper deleted
 // ca.pem / leaf.ext from sessions older than ~3-4 days (files not accessed for 3 days; openssl
@@ -240,6 +253,8 @@ try {
     "ec",
     "-pkeyopt",
     "ec_paramgen_curve:prime256v1",
+    "-pkeyopt",
+    "ec_param_enc:named_curve",
     "-nodes",
     "-keyout",
     p("ca.key"),
@@ -253,6 +268,7 @@ try {
     "basicConstraints=critical,CA:TRUE",
     "-addext",
     "keyUsage=critical,keyCertSign,cRLSign",
+    "-sha256",
   );
   caKey = fs.readFileSync(p("ca.key"));
   fs.rmSync(p("ca.key"));
@@ -262,6 +278,11 @@ try {
   fs.rmSync(p("ca.key"), { force: true });
   die(`could not mint the ephemeral CA with openssl: ${osslErr(e)}`);
 }
+try {
+  assertUsableCert({ role: "CA", cert: caPem });
+} catch (e) {
+  die(`${e.message} Refusing to start.`);
+}
 
 // Recreate caDir and its long-lived files from memory if something deleted them, and refresh
 // every atime/mtime so the cleaner does not try again (see the block comment above).
@@ -299,6 +320,8 @@ function mintLeaf() {
     "ec",
     "-pkeyopt",
     "ec_paramgen_curve:prime256v1",
+    "-pkeyopt",
+    "ec_param_enc:named_curve",
     "-nodes",
     "-keyout",
     p("leaf.key"),
@@ -306,6 +329,7 @@ function mintLeaf() {
     p("leaf.csr"),
     "-subj",
     `/CN=${MITM_HOST}`,
+    "-sha256",
   );
   try {
     fs.writeFileSync(p("ca.key"), caKey, { mode: 0o600, flag: "wx" });
@@ -325,23 +349,27 @@ function mintLeaf() {
       String(LEAF_DAYS),
       "-extfile",
       p("leaf.ext"),
+      "-sha256",
     );
   } finally {
     fs.rmSync(p("ca.key"), { force: true });
   }
   const cert = fs.readFileSync(p("leaf.pem"));
-  return {
-    key: fs.readFileSync(p("leaf.key")),
-    cert,
-    notAfter: Date.parse(new crypto.X509Certificate(cert).validTo),
-  };
+  const key = fs.readFileSync(p("leaf.key"));
+  assertUsableCert({ role: "leaf", cert, key }); // fail closed: never serve a leaf Node refuses
+  return { key, cert, notAfter: Date.parse(new crypto.X509Certificate(cert).validTo) };
 }
 
-let leaf;
+let firstLeaf;
 try {
-  leaf = mintLeaf();
+  firstLeaf = mintLeaf();
 } catch (e) {
-  die(`could not mint the ephemeral CA with openssl: ${osslErr(e)}`);
+  // An openssl failure carries its stderr; an unusable certificate carries assertUsableCert's message.
+  const why =
+    e.stderr && e.stderr.length
+      ? `could not mint the ephemeral CA with openssl: ${osslErr(e)}`
+      : null;
+  die(why || `${e.message} Refusing to start.`);
 }
 
 // --- request handling ---------------------------------------------------------------------
@@ -613,22 +641,22 @@ function handle(req, res, viaPlain) {
   }
 }
 
-const tlsServer = https.createServer({ key: leaf.key, cert: leaf.cert }, (req, res) =>
+const tlsServer = https.createServer({ key: firstLeaf.key, cert: firstLeaf.cert }, (req, res) =>
   handle(req, res, false),
 );
 tlsServer.on("tlsClientError", (e) => log(`tls client error: ${e.code || e.message}`));
 
 // Re-mint the leaf and hot-swap it; established TLS connections keep the old one, every new
-// handshake gets the new one. A failed re-mint keeps serving the current leaf.
-function rotateLeaf(why) {
-  try {
-    leaf = mintLeaf();
-    tlsServer.setSecureContext({ key: leaf.key, cert: leaf.cert });
-    log(`leaf rotated (${why}) notAfter=${new Date(leaf.notAfter).toISOString()}`);
-  } catch (e) {
-    log(`leaf rotation FAILED (${why}), keeping the current leaf: ${osslErr(e)}`);
-  }
-}
+// handshake gets the new one. A failed re-mint OR a failed swap keeps serving the current leaf —
+// and keeps its notAfter, so the CONNECT handler's "expiring" check retries (rc-certs.mjs).
+const leaves = makeLeafRotator({
+  initial: firstLeaf,
+  mint: mintLeaf,
+  install: (next) => tlsServer.setSecureContext({ key: next.key, cert: next.cert }),
+  log,
+  errText: osslErr,
+});
+const rotateLeaf = (why) => leaves.rotate(why);
 rotateTimer = setInterval(() => rotateLeaf("interval"), LEAF_ROTATE_MS);
 rotateTimer.unref();
 keepAliveTimer = setInterval(() => keepAlive("interval"), CA_KEEPALIVE_MS);
@@ -641,7 +669,7 @@ proxy.on("connect", (req, sock, head) => {
   sock.on("error", () => {});
   if (host === MITM_HOST && port === 443) {
     // A timer can run late (laptop sleep): never hand out a leaf that is about to expire.
-    if (leaf.notAfter - Date.now() < LEAF_MIN_LEFT_MS) rotateLeaf("expiring");
+    if (leaves.current().notAfter - Date.now() < LEAF_MIN_LEFT_MS) rotateLeaf("expiring");
     sock.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     if (head && head.length) sock.unshift(head);
     tlsServer.emit("connection", sock);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.22",
+  "version": "0.17.24",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {