@mnemom/mnemom 0.17.7-next.1 → 0.17.7-next.2

package/README.md

@@ -103,7 +103,12 @@ default is. Each profile serves a different set of use cases:
   `aggressive` budgets from 200k to 1M, and `balanced` above 1M. It sends
   `CONTEXT_RUNTIME_SIZE_POLICY=banded` in the per-session config; the band thresholds are the
   gateway's defaults.
-- **`off`** leaves compaction to the coding agent.
+- **`off`** leaves compaction to the coding agent. It sends `CONTEXT_RUNTIME_ENABLED=false`
+  plus `GATEWAY_USAGE_REAL_SIZE=off` and `GATEWAY_COMPACTION_INTERCEPT=off`, so a session with
+  no fold never has its compaction intercepted or its reported context size rewritten, even on
+  a cell whose default turns the intercept on. `--compaction-intercept` or `--compact-at <n>` on
+  the same launch is refused; a standing `compaction_intercept` / `compact_at` setting is left
+  out for that session (the launch note says so).
 
 Choose it for one launch, as a standing default, or in the environment (flag > env >
 `launcher.toml`). Only `mnemom agent config set` (or editing `launcher.toml`) saves a default;
@@ -191,7 +196,8 @@ enable compaction-intercept`) — a target arms the identical pair of gateway ke
 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
 `--compact-at` is refused outright (they contradict: the target cannot arm without the intercept
-you just turned off).
+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.
 
 Set it per launch, as a standing default, or in the environment (flag > env > `launcher.toml` >
 default):

package/dist/commands/agent.js

@@ -45,7 +45,7 @@ import { authConfigured, chooseAuth, detectClaudeLogin, readClaudeLoginState, }
 import { requireConsoleKey, readConsoleKey } from "../lib/console-key.js";
 import { goalAlignmentLine, resolveSessionSetup } from "./agent-session.js";
 import { AgentIdentityMismatchError, defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, resolvePreflightedAccount, } from "./agent-setup.js";
-import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, assertCompactAtCompatible, compactAtWindowWarning, describeCompactAt, launchWindow, resolveCompactAt, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, HANDOFF_RC_MNEMOM_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, assertCompactAtCompatible, assertOffProfileCompatible, compactAtWindowWarning, describeCompactAt, launchWindow, resolveCompactAt, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, HANDOFF_RC_MNEMOM_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
 import { LAUNCHER_STORE_PATH, mergeStore, readStore } from "../lib/launcher-store.js";
 import { slackChannelArgs } from "../lib/slack-launch.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
@@ -53,6 +53,20 @@ 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.
+ */
+function sayCompaction(profile, compactionIntercept, compactAt, window) {
+    const off = profile === "off";
+    sayCompactAt(off ? null : compactAt, window);
+    if (off && (compactionIntercept || compactAt !== null))
+        say(OFF_DROPS_COMPACTION_NOTE);
+    else if (compactionIntercept)
+        say(COMPACTION_INTERCEPT_NOTE);
+}
 /**
  * The one-line launch note for the context profile: `null` (none chosen — nothing is sent) names
  * the cell default. `off` keeps the wording `--no-context` has always printed.
@@ -209,6 +223,13 @@ export async function agentCommand(scenarioArg, options = {}) {
     // cannot arm without the intercept it just turned off. Refuse rather than silently pick
     // a side.
     assertCompactAtCompatible({ compactionIntercept: options.compactionIntercept, compactAt });
+    // Context profile off sends the intercept off: an explicit --compaction-intercept or
+    // --compact-at <N> in the same launch contradicts it. A resume re-checks below.
+    assertOffProfileCompatible({
+        profile: contextProfile,
+        compactionIntercept: options.compactionIntercept,
+        compactAt: options.compactAt,
+    });
     const experimental = options.experimental ?? [];
     const sessionConfig = buildSessionConfig({
         profile: contextProfile,
@@ -280,12 +301,10 @@ export async function agentCommand(scenarioArg, options = {}) {
             say("mnemom agent: the plan shows Remote Control because this machine can run it; the real launch uses it only if your account is entitled (internal Mnemom accounts), else terminal-only.");
         }
         sayContextProfile(contextProfile);
-        sayCompactAt(compactAt, launchWindow(windowModelFor(options, cli)));
+        sayCompaction(contextProfile, compactionIntercept, compactAt, launchWindow(windowModelFor(options, cli)));
         if (contextHandoff) {
             say("mnemom agent: context handoff ON (experimental) — the `handoff` MCP tool would be registered.");
         }
-        if (compactionIntercept)
-            say(COMPACTION_INTERCEPT_NOTE);
         return;
     }
     // Real launch: make sure we actually have a CLI to run. If we couldn't find it,
@@ -456,6 +475,11 @@ export async function agentCommand(scenarioArg, options = {}) {
         }
         if (resumed !== null && resumed !== contextProfile) {
             contextProfile = resolveContextProfile({ context: options.context, resumed, env });
+            assertOffProfileCompatible({
+                profile: contextProfile,
+                compactionIntercept: options.compactionIntercept,
+                compactAt: options.compactAt,
+            });
             sessionConfigB64 = buildSessionConfigB64({
                 profile: contextProfile,
                 contextHandoff,
@@ -496,16 +520,14 @@ export async function agentCommand(scenarioArg, options = {}) {
         goalMode,
         ccSessionId: cc.id,
         contextProfile,
-        compactAt,
+        compactAt: contextProfile === "off" ? null : compactAt,
     });
     logLaunch({ shape, door, agent, conversationId, cellNote, envelope, goalMode, cli });
     if (expNotice)
         say(expNotice);
     say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
     sayContextProfile(contextProfile);
-    sayCompactAt(compactAt, launchWindow(win));
-    if (compactionIntercept)
-        say(COMPACTION_INTERCEPT_NOTE);
+    sayCompaction(contextProfile, compactionIntercept, compactAt, launchWindow(win));
     // ── handoff MCP tool (MNE-7564) ── OFF by default: absent/false ⇒ handoffMcpConfigPath stays
     // undefined and buildCliArgs/spawnRcCli are byte-identical to a build without this flag. ON:
     // the config is written to a 0600 temp file and referenced by PATH only — never inlined into

package/dist/index.js

@@ -175,7 +175,7 @@ const agentCmd = program
     .addOption(new Option("--slack", "EXPERIMENTAL (`mnemom experimental enable slack`): attach the Slack channel — messages addressed to this session arrive in it, and it can reply (see `mnemom agent slack`)").hideHelp(hiddenUnless("slack")))
     .option("--context", "Force context folding ON for this launch even when launcher.toml (context = false) or MNEMOM_AGENT_CONTEXT turns it off")
     .option("--no-context", "Disable context folding for this launch (folding is on by default; tells the gateway to skip it for this session)")
-    .addOption(new Option("--context-profile <profile>", 'How the gateway folds this session\'s context. Unset (the default): nothing is sent and the gateway cell\'s own default decides. "balanced" keeps more of the earlier work verbatim and folds later — for long sessions that revisit earlier files and decisions. "aggressive" folds earlier and keeps a tighter working set — for cost-sensitive sessions and short, focused tasks. "adaptive" sizes the fold to the conversation: no fold below 200k tokens, aggressive from 200k to 1M, balanced above. "off" leaves compaction to the coding agent. Applies to this launch only (a resumed session keeps its own); to change the default for every launch: config key context_profile, env MNEMOM_AGENT_CONTEXT_PROFILE.').argParser((v) => {
+    .addOption(new Option("--context-profile <profile>", 'How the gateway folds this session\'s context. Unset (the default): nothing is sent and the gateway cell\'s own default decides. "balanced" keeps more of the earlier work verbatim and folds later — for long sessions that revisit earlier files and decisions. "aggressive" folds earlier and keeps a tighter working set — for cost-sensitive sessions and short, focused tasks. "adaptive" sizes the fold to the conversation: no fold below 200k tokens, aggressive from 200k to 1M, balanced above. "off" leaves compaction to the coding agent and never intercepts it (fold, compaction intercept and real-size usage all off; refused with --compaction-intercept or --compact-at <n>). Applies to this launch only (a resumed session keeps its own); to change the default for every launch: config key context_profile, env MNEMOM_AGENT_CONTEXT_PROFILE.').argParser((v) => {
     // One validator for all three surfaces (flag, MNEMOM_AGENT_CONTEXT_PROFILE,
     // launcher.toml context_profile): trimmed, case-insensitive, same error wording.
     try {

package/dist/lib/agent.d.ts

@@ -300,13 +300,31 @@ export declare const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT
  * gateway's own defaults.
  */
 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):
+ *   - `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"`.
+ */
+export declare const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
+export declare const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
 /**
  * The named presets for how the gateway folds a session's context (`--context-profile`,
  * launcher.toml `context_profile`, `MNEMOM_AGENT_CONTEXT_PROFILE`). Choosing NONE sends no fold
  * key at all and the cell's own default decides (see `resolveContextProfile`). A chosen profile
  * is complete on its own, so a change to a cell's default can never change what it means:
- *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` — compaction is left to the coding agent
- *                    (the same bytes `--no-context` has always sent).
+ *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` plus `GATEWAY_USAGE_REAL_SIZE: "off"` and
+ *                    `GATEWAY_COMPACTION_INTERCEPT: "off"` — compaction is left to the coding agent
+ *                    and never intercepted, even on a cell whose default turns the intercept on.
+ *                    The gateway already skips the intercept with the fold off, but the real-size
+ *                    usage rewrite is not gated on the fold, so `off` turns both off by name.
  *   - `balanced`   → `CONTEXT_RUNTIME_SIZE_POLICY: "off"` — the cell's own fold budgets, never
  *                    the size bands, even on a cell whose default is adaptive.
  *   - `aggressive` → a smaller tail budget + read cache and head-breakpoint reclaim on, size
@@ -326,21 +344,6 @@ export type ContextProfile = (typeof CONTEXT_PROFILES)[number];
  * header without the tool.
  */
 export declare const CONTEXT_HANDOFF_KEY = "CONTEXT_HANDOFF_ENABLED";
-/**
- * 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):
- *   - `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.
- */
-export declare const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
-export declare const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
 export declare const GATEWAY_COMPACTION_UPLOAD_TARGET_KEY = "GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS";
 /** The lowest token count `--compact-at` / `compact_at` / `MNEMOM_COMPACT_AT` will accept. */
 export declare const COMPACT_AT_MIN_TOKENS = 50000;
@@ -416,6 +419,19 @@ export declare function assertCompactAtCompatible(opts: {
     compactionIntercept?: boolean;
     compactAt: number | null;
 }): void;
+/**
+ * The `off` context profile turns the fold off, and the compaction intercept answers a compaction
+ * from that fold, so `off` sends the intercept and real-size keys as `"off"`. An explicit
+ * `--compaction-intercept` or `--compact-at <N>` in the same launch asks for the opposite —
+ * refuse rather than silently drop the flag. A standing intercept or target (environment or
+ * launcher.toml) is not refused: the session's `off` wins and `buildSessionConfig` leaves it out.
+ * `compactionIntercept` / `compactAt` here are the raw flag values (`undefined` when not passed).
+ */
+export declare function assertOffProfileCompatible(opts: {
+    profile: ContextProfile | null;
+    compactionIntercept?: boolean;
+    compactAt?: number | null;
+}): void;
 /** The launch-banner line for the resolved compaction target (always printed). */
 export declare function describeCompactAt(compactAt: number | null): string;
 /**
@@ -584,13 +600,16 @@ export declare function resolveContextProfile(opts: {
 /**
  * The decoded per-session env overlay for this launch — the `config` object of the
  * `x-mnemom-session-config` payload, in wire order: the profile's keys first
- * (`CONTEXT_RUNTIME_ENABLED` for `off`; the three fold-tuning keys + size policy off for
+ * (`CONTEXT_RUNTIME_ENABLED: "false"` + real-size and intercept `"off"` for `off`; the three fold-tuning keys + size policy off for
  * `aggressive`; size policy off for `balanced`; size policy banded for `adaptive`; nothing when
  * no profile was chosen), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, 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. Empty with no profile chosen and everything off — the common case, where
+ * 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.
  */
 export declare function buildSessionConfig(opts: {

package/dist/lib/agent.js

@@ -458,13 +458,31 @@ export const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT_RECLAIM
  * gateway's own defaults.
  */
 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):
+ *   - `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"`.
+ */
+export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
+export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
 /**
  * The named presets for how the gateway folds a session's context (`--context-profile`,
  * launcher.toml `context_profile`, `MNEMOM_AGENT_CONTEXT_PROFILE`). Choosing NONE sends no fold
  * key at all and the cell's own default decides (see `resolveContextProfile`). A chosen profile
  * is complete on its own, so a change to a cell's default can never change what it means:
- *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` — compaction is left to the coding agent
- *                    (the same bytes `--no-context` has always sent).
+ *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` plus `GATEWAY_USAGE_REAL_SIZE: "off"` and
+ *                    `GATEWAY_COMPACTION_INTERCEPT: "off"` — compaction is left to the coding agent
+ *                    and never intercepted, even on a cell whose default turns the intercept on.
+ *                    The gateway already skips the intercept with the fold off, but the real-size
+ *                    usage rewrite is not gated on the fold, so `off` turns both off by name.
  *   - `balanced`   → `CONTEXT_RUNTIME_SIZE_POLICY: "off"` — the cell's own fold budgets, never
  *                    the size bands, even on a cell whose default is adaptive.
  *   - `aggressive` → a smaller tail budget + read cache and head-breakpoint reclaim on, size
@@ -476,7 +494,11 @@ export const CONTEXT_SIZE_POLICY_KEY = "CONTEXT_RUNTIME_SIZE_POLICY";
 export const CONTEXT_PROFILES = ["off", "balanced", "aggressive", "adaptive"];
 /** The per-session env overlay each profile expands to (key order is the wire order). */
 const CONTEXT_PROFILE_CONFIG = {
-    off: [[CONTEXT_RUNTIME_KEY, "false"]],
+    off: [
+        [CONTEXT_RUNTIME_KEY, "false"],
+        [USAGE_REAL_SIZE_KEY, "off"],
+        [COMPACTION_INTERCEPT_KEY, "off"],
+    ],
     balanced: [[CONTEXT_SIZE_POLICY_KEY, "off"]],
     aggressive: [
         [CONTEXT_TAIL_BUDGET_KEY, "60000"],
@@ -495,21 +517,6 @@ const CONTEXT_PROFILE_CONFIG = {
  * header without the tool.
  */
 export const CONTEXT_HANDOFF_KEY = "CONTEXT_HANDOFF_ENABLED";
-/**
- * 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):
- *   - `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.
- */
-export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
-export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
 // ---------------------------------------------------------------------------
 // Compaction target (`--compact-at`, launcher.toml `compact_at`, MNEMOM_COMPACT_AT)
 // ---------------------------------------------------------------------------
@@ -656,6 +663,28 @@ export function assertCompactAtCompatible(opts) {
             "enable compaction-intercept`), or pass --compact-at off.");
     }
 }
+/**
+ * The `off` context profile turns the fold off, and the compaction intercept answers a compaction
+ * from that fold, so `off` sends the intercept and real-size keys as `"off"`. An explicit
+ * `--compaction-intercept` or `--compact-at <N>` in the same launch asks for the opposite —
+ * refuse rather than silently drop the flag. A standing intercept or target (environment or
+ * launcher.toml) is not refused: the session's `off` wins and `buildSessionConfig` leaves it out.
+ * `compactionIntercept` / `compactAt` here are the raw flag values (`undefined` when not passed).
+ */
+export function assertOffProfileCompatible(opts) {
+    if (opts.profile !== "off")
+        return;
+    const flag = opts.compactionIntercept === true
+        ? "--compaction-intercept"
+        : typeof opts.compactAt === "number"
+            ? "--compact-at"
+            : null;
+    if (flag === null)
+        return;
+    throw new Error(`mnemom agent: context profile off and ${flag} disagree — with the fold off the gateway has ` +
+        `no fold to answer a compaction from, so off sends the compaction intercept off. Drop ` +
+        `${flag}, or choose another --context-profile.`);
+}
 /**
  * `200000` → `"200k"`, anything not k-aligned → the bare digits. Every real caller only ever
  * passes a `parseCompactAt`-validated value, which is bounded to
@@ -953,13 +982,16 @@ export function resolveContextProfile(opts) {
 /**
  * The decoded per-session env overlay for this launch — the `config` object of the
  * `x-mnemom-session-config` payload, in wire order: the profile's keys first
- * (`CONTEXT_RUNTIME_ENABLED` for `off`; the three fold-tuning keys + size policy off for
+ * (`CONTEXT_RUNTIME_ENABLED: "false"` + real-size and intercept `"off"` for `off`; the three fold-tuning keys + size policy off for
  * `aggressive`; size policy off for `balanced`; size policy banded for `adaptive`; nothing when
  * no profile was chosen), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, 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. Empty with no profile chosen and everything off — the common case, where
+ * 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.
  */
 export function buildSessionConfig(opts) {
@@ -974,6 +1006,8 @@ export function buildSessionConfig(opts) {
     // A target needs the compaction intercept + real-size rewrite to arm (#2216) — without them
     // the upload-target key is silently inert (compaction-align.ts: "armed only inside the
     // intercept"). Deliberately NOT GATEWAY_COMPACTION_REFOLD — a separate, costlier opt-in.
+    if (opts.profile === "off")
+        return config;
     if (opts.compactionIntercept || hasCompactionTarget) {
         config[USAGE_REAL_SIZE_KEY] = "on";
         config[COMPACTION_INTERCEPT_KEY] = "on";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.7-next.1",
+  "version": "0.17.7-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {