@mnemom/mnemom 0.17.21 → 0.17.23

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/api.d.ts

@@ -371,6 +371,18 @@ export interface MoveAgentResult {
 export declare function moveAgent(agentId: string, destOrgId: string, opts?: {
     idempotencyKey?: string;
 }): Promise<MoveAgentResult>;
+/**
+ * GET /v1/agents/:id/compliance-export — the agent's full record (JSON or CSV).
+ *
+ * Returns the raw body bytes (written to disk verbatim so the checksum the CLI
+ * prints matches what the server sent) plus the response headers (CSV carries
+ * its per-section counts in `X-Mnemom-Export-Counts`). `query` is the full
+ * `?format=…&from=…&to=…` string (see lib/agent-export.ts buildExportQuery).
+ */
+export declare function getComplianceExport(agentId: string, query: string): Promise<{
+    body: Uint8Array;
+    headers: Headers;
+}>;
 /**
  * GET /v1/auth/me/personal-org — accessor for the user's personal org.
  * Idempotent: lazily provisions for legacy accounts that pre-date the

package/dist/lib/api.js

@@ -367,6 +367,23 @@ export async function moveAgent(agentId, destOrgId, opts = {}) {
         to_org_id: data.to_org_id ?? null,
     };
 }
+/**
+ * GET /v1/agents/:id/compliance-export — the agent's full record (JSON or CSV).
+ *
+ * Returns the raw body bytes (written to disk verbatim so the checksum the CLI
+ * prints matches what the server sent) plus the response headers (CSV carries
+ * its per-section counts in `X-Mnemom-Export-Counts`). `query` is the full
+ * `?format=…&from=…&to=…` string (see lib/agent-export.ts buildExportQuery).
+ */
+export async function getComplianceExport(agentId, query) {
+    const url = validateUrl(`${API_BASE}/v1/agents/${encodeURIComponent(agentId)}/compliance-export${query}`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        headers: { ...(await authHeaders()), Accept: "application/json, text/csv" },
+    }));
+    if (!response.ok)
+        throw await readApiError(response, "Failed to export the agent record");
+    return { body: new Uint8Array(await response.arrayBuffer()), headers: response.headers };
+}
 /**
  * GET /v1/auth/me/personal-org — accessor for the user's personal org.
  * Idempotent: lazily provisions for legacy accounts that pre-date 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.21",
+  "version": "0.17.23",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {