@mnemom/mnemom 0.17.22 → 0.17.23

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/package.json

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