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

package/README.md

@@ -87,20 +87,32 @@ or `launch` in `launcher.toml`) also skips the Remote Control capability probe
 #### Context profile: how the gateway folds a session's context
 
 `--context-profile <off|balanced|aggressive|adaptive>` picks how the Mnemom gateway folds a
-session's context. Each profile serves a different set of use cases:
-
-- **`balanced`** (the default) keeps more of the earlier work verbatim and folds later —
-  for long sessions that revisit earlier files and decisions.
+session's context. **Unset is the default:** the launch sends no fold setting at all and the
+gateway cell's own default decides (the launch note reads `context: cell default`). A profile
+you choose is sent in full, so it means the same thing on every cell whatever that cell's
+default is. Each profile serves a different set of use cases:
+
+- **`balanced`** keeps more of the earlier work verbatim and folds later — for long sessions
+  that revisit earlier files and decisions. It sends `CONTEXT_RUNTIME_SIZE_POLICY=off`, so the
+  cell's own fold budgets apply at every size, even on a cell whose default is `adaptive`.
 - **`aggressive`** folds earlier and keeps a tighter working set — for cost-sensitive
-  sessions and short, focused tasks.
-- **`adaptive`** (opt-in) lets the gateway size the fold to the conversation's original
-  context: no fold below 200k tokens (folding a small conversation costs more than it
-  saves), the `aggressive` budgets from 200k to 1M, and `balanced` above 1M. It sends
+  sessions and short, focused tasks. It sends its three budget keys plus
+  `CONTEXT_RUNTIME_SIZE_POLICY=off`.
+- **`adaptive`** lets the gateway size the fold to the conversation's original context: no
+  fold below 200k tokens (folding a small conversation costs more than it saves), the
+  `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).
 
-Set it per launch, as a standing default, or in the environment (flag > env > `launcher.toml`):
+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;
+a flag applies to that launch alone and is never written anywhere later launches read:
 
 ```bash
 mnemom agent my-task --context-profile aggressive   # this launch only
@@ -109,11 +121,16 @@ export MNEMOM_AGENT_CONTEXT_PROFILE=aggressive      # for every launch in this s
 mnemom agent my-task --context-profile adaptive     # size-banded folding, this launch only
 ```
 
+A launch that resumes a Claude Code session (`-- --resume <id>`, or the implicit-goal relaunch)
+keeps the profile that session ran under, ahead of the standing default; a `--context-profile`
+flag on the resuming launch still wins.
+
 `--no-context` (or `context = false` in `launcher.toml`) is the same as `off`. Pass one or the
 other: `--no-context` together with `--context-profile balanced`, `aggressive` or `adaptive` is refused. A
 `--context-profile` flag overrides a standing `context = false` in `launcher.toml`. `--dry-run`
-prints the resolved profile and, when the launch sends the per-session config header, the
-decoded key/value list; `mnemom agent show` and the session ledger record the profile.
+prints the resolved profile (`cell default` when none is chosen) and, when the launch sends the
+per-session config header, the decoded key/value list; `mnemom agent show` and the session
+ledger record a chosen profile.
 
 #### Context handoff (experimental, off by default)
 
@@ -179,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.d.ts

@@ -66,8 +66,9 @@ export interface AgentOptions {
     context?: boolean;
     /**
      * How the gateway folds this session's context (`--context-profile`): `off`, `balanced`,
-     * `aggressive` or `adaptive`. Undefined ⇒ MNEMOM_AGENT_CONTEXT_PROFILE (the `context_profile` setting), else
-     * `balanced`. `--no-context` is `off`; combined with balanced|aggressive|adaptive the launch refuses.
+     * `aggressive` or `adaptive`. Undefined ⇒ the resumed session's own profile, else
+     * MNEMOM_AGENT_CONTEXT_PROFILE (the `context_profile` setting), else none — the cell default,
+     * nothing sent. `--no-context` is `off`; combined with balanced|aggressive|adaptive the launch refuses.
      */
     contextProfile?: ContextProfile;
     /**
@@ -195,8 +196,8 @@ export declare function recordSessionLaunch(ctx: {
     goalMode: string | null;
     /** The Claude Code session id (pickCcSessionId); null/absent when Claude Code picks it. */
     ccSessionId?: string | null;
-    /** The resolved context profile this launch runs under. */
-    contextProfile: ContextProfile;
+    /** The resolved context profile this launch runs under; `null` = none chosen (cell default). */
+    contextProfile: ContextProfile | null;
     /** The resolved compaction target this launch runs under (`resolveCompactAt`). */
     compactAt: number | null;
 }): Promise<void>;
@@ -374,8 +375,8 @@ export declare function printPlan(ctx: {
     goalMode: string | null;
     yolo: boolean;
     cli: ResolvedCli;
-    /** The resolved context profile (`resolveContextProfile`). */
-    contextProfile: ContextProfile;
+    /** The resolved context profile (`resolveContextProfile`); `null` = none chosen (cell default). */
+    contextProfile: ContextProfile | null;
     /** The resolved compaction target (`resolveCompactAt`); `null` = no target (default). */
     compactAt: number | null;
     /** The decoded `x-mnemom-session-config` overlay (`buildSessionConfig`); empty ⇒ no header. */

package/dist/commands/agent.js

@@ -35,7 +35,7 @@ import { statuslineLaunch } from "../lib/statusline.js";
 import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { apiAcceptsMnemomKey, createOrgApiKey, getAgentByName, listOwnApiKeysForCheck, revokeApiKey, } from "../lib/api.js";
 import { checkMnemomKey, MNEMOM_KEY_ENV, readLocalMnemomKey, readStoredMnemomKey, resolveAgentAuth, resolveLaunchMnemomKey, storePatchForMnemomKey, subscriptionChildEnv, subscriptionShape, } from "../lib/subscription-login.js";
-import { LEDGER_FILE, appendSessionRecord, findResumeCandidate, readSessionRecords, resolveRetentionDays, toLedgerContract, } from "../lib/agent-ledger.js";
+import { LEDGER_FILE, appendSessionRecord, findResumeCandidate, readSessionRecords, resolveRetentionDays, resumedContextProfile, toLedgerContract, } from "../lib/agent-ledger.js";
 import { getActiveOrg, loadCliConfig } from "../lib/cli-config.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { experimentalNotice } from "../lib/experimental.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,14 +53,34 @@ 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 one-line launch note for a non-default context profile (`balanced`, the default, is
- * silent — nothing is sent). `off` keeps the wording `--no-context` has always printed.
+ * 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.
  */
 function sayContextProfile(profile) {
-    if (profile === "off") {
+    if (profile === null) {
+        say("mnemom agent: context: cell default");
+    }
+    else if (profile === "off") {
         say("mnemom agent: context folding OFF for this session (--no-context or context = false).");
     }
+    else if (profile === "balanced") {
+        say("mnemom agent: context profile balanced — the gateway keeps more of the earlier work verbatim and folds later.");
+    }
     else if (profile === "aggressive") {
         say("mnemom agent: context profile aggressive — the gateway folds earlier and keeps a tighter working set.");
     }
@@ -174,11 +194,12 @@ export async function agentCommand(scenarioArg, options = {}) {
     const cellNote = isProdGateway(env) ? "us-2/prod" : `custom (${gatewayHost})`;
     const yolo = options.yolo !== false; // default ON
     const contextHint = options.contextHint !== false; // default ON
-    // Context profile: `balanced` (the gateway's own defaults) unless --context-profile /
-    // MNEMOM_AGENT_CONTEXT_PROFILE (the `context_profile` setting) says otherwise; --no-context
-    // (or `context = false` in launcher.toml → MNEMOM_AGENT_CONTEXT) is `off`. Anything but
-    // balanced rides in the per-session config header; `undefined` sessionConfigB64 ⇒ nothing sent.
-    const contextProfile = resolveContextProfile({
+    // Context profile: none (null — the cell's own default, no fold key sent) unless
+    // --context-profile / MNEMOM_AGENT_CONTEXT_PROFILE (the `context_profile` setting) chooses
+    // one; --no-context (or `context = false` in launcher.toml → MNEMOM_AGENT_CONTEXT) is `off`. A
+    // chosen profile rides in the per-session config header; `undefined` sessionConfigB64 ⇒
+    // nothing sent. A resume re-resolves it below, once the resumed session is known.
+    let contextProfile = resolveContextProfile({
         contextProfile: options.contextProfile,
         context: options.context,
         env,
@@ -202,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,
@@ -209,7 +237,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         compactionIntercept,
         compactAt,
     });
-    const sessionConfigB64 = buildSessionConfigB64({
+    let sessionConfigB64 = buildSessionConfigB64({
         profile: contextProfile,
         contextHandoff,
         compactionIntercept,
@@ -273,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,
@@ -431,6 +457,38 @@ export async function agentCommand(scenarioArg, options = {}) {
             passthrough: [...(options.passthrough ?? []), "--resume", continuation.resumeCcSessionId],
         };
     }
+    // A launch that resumes a Claude Code session (the continuation above, or the caller's own
+    // `-- --resume <id>`) keeps the profile that session ran under, unless this launch chose one
+    // with a flag. Read from the ledger only — nothing here writes a default anywhere.
+    const resumeId = shape === "server" ? null : passthroughResumeId(options.passthrough ?? []);
+    if (resumeId && options.contextProfile === undefined && options.context !== false) {
+        let resumed;
+        try {
+            resumed = resumedContextProfile(readSessionRecords({ dir: MNEMOM_DIR }), {
+                ccSessionId: resumeId,
+                orgId: account.orgId,
+                gatewayHost,
+            });
+        }
+        catch {
+            resumed = null; // best-effort: an unreadable ledger keeps the launch's own resolution
+        }
+        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,
+                compactionIntercept,
+                compactAt,
+                experimental,
+            });
+        }
+    }
     // ── local session ledger (~/.mnemom/sessions.jsonl) ── one line per real
     // launch so `mnemom agent sessions` / `show` can find this conversation later.
     // Written after provisioning so a freshly claimed agent's id resolves. Holds
@@ -462,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
@@ -703,7 +759,9 @@ export async function recordSessionLaunch(ctx) {
         cli: ctx.cli.name,
         contract: toLedgerContract(ctx.envelope?.contract ?? null),
         goal_mode: goalAlignmentMode(ctx.envelope, ctx.goalMode),
-        context_profile: ctx.contextProfile,
+        ...(ctx.contextProfile !== null
+            ? { context_profile: ctx.contextProfile, context_profile_v: 2 }
+            : {}),
         compact_at: ctx.compactAt,
         cc_session_id: ctx.ccSessionId ?? null,
         ...(ctx.options.experimental?.length ? { experimental: [...ctx.options.experimental] } : {}),
@@ -1618,7 +1676,7 @@ export function printPlan(ctx) {
     L.push(`  agent:         ${ctx.agent}`);
     L.push(`  conversation:  ${ctx.conversationId}`);
     L.push(`  yolo:          ${ctx.yolo ? "on (--dangerously-skip-permissions)" : "off"}`);
-    L.push(`  context:       ${ctx.contextProfile}`);
+    L.push(`  context:       ${ctx.contextProfile ?? "cell default"}`);
     L.push(`  compaction:    ${describeCompactAt(ctx.compactAt)}`);
     const overlay = Object.entries(ctx.sessionConfig);
     if (overlay.length > 0) {

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. "balanced" (default) 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. Also: 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-ledger.d.ts

@@ -14,7 +14,7 @@
  * `sessions.retention_days` (default 30) are dropped when the next one is
  * recorded. No count cap — a long retention keeps everything in the window.
  */
-import type { ContextProfile, LaunchShape, SealedContract } from "./agent.js";
+import { type ContextProfile, type LaunchShape, type SealedContract } from "./agent.js";
 /** The ledger's file name under MNEMOM_DIR. */
 export declare const LEDGER_FILE = "sessions.jsonl";
 /** Days a launch stays in the ledger when `sessions.retention_days` is unset. */
@@ -77,10 +77,17 @@ export interface SessionRecord {
     cc_session_id?: string | null;
     /**
      * The context profile the launch ran under (`--context-profile` / `context_profile` /
-     * `MNEMOM_AGENT_CONTEXT_PROFILE`, or `balanced` by default). Optional: records written
-     * before profiles existed omit it (still `v: 1`).
+     * `MNEMOM_AGENT_CONTEXT_PROFILE`, or the resumed session's own). Absent when none was chosen
+     * (the cell default) and on records written before profiles existed (still `v: 1`).
      */
     context_profile?: ContextProfile;
+    /**
+     * `2` when `context_profile` was written with complete profiles (`balanced` sends size policy
+     * off, `aggressive` adds it). Absent on older records, where `balanced` was also written for a
+     * launch that chose nothing and sent no fold key — so a resume reads an unmarked `balanced` as
+     * the cell default, which is what that session actually ran under.
+     */
+    context_profile_v?: 2;
     /**
      * The resolved gateway compaction target (`--compact-at` / `compact_at` /
      * `MNEMOM_COMPACT_AT`): `null` means no target (Claude Code's own 1M window; the default,
@@ -168,3 +175,15 @@ export declare function findResumeCandidate(records: readonly SessionRecord[], w
     gatewayHost: string;
     resumeId?: string | null;
 }): ResumeCandidate | null;
+/**
+ * The context profile the Claude Code session `ccSessionId` ran under — the newest row with the
+ * same org and gateway host that pinned that session — so a launch that resumes it
+ * (`--resume <id>`) keeps that session's own profile. `null` when no row matches, the row chose
+ * no profile (the cell default), it is an older row's `balanced` (see `context_profile_v`), or its
+ * value is not a known profile (the file is hand-editable).
+ */
+export declare function resumedContextProfile(records: readonly SessionRecord[], want: {
+    ccSessionId: string | null;
+    orgId: string;
+    gatewayHost: string;
+}): ContextProfile | null;

package/dist/lib/agent-ledger.js

@@ -16,6 +16,7 @@
  */
 import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { CONTEXT_PROFILES, } from "./agent.js";
 /** The ledger's file name under MNEMOM_DIR. */
 export const LEDGER_FILE = "sessions.jsonl";
 /** Days a launch stays in the ledger when `sessions.retention_days` is unset. */
@@ -197,3 +198,25 @@ export function findResumeCandidate(records, want) {
     }
     return latest ? { record: latest, source: "session_name", byCcSession: false } : null;
 }
+/**
+ * The context profile the Claude Code session `ccSessionId` ran under — the newest row with the
+ * same org and gateway host that pinned that session — so a launch that resumes it
+ * (`--resume <id>`) keeps that session's own profile. `null` when no row matches, the row chose
+ * no profile (the cell default), it is an older row's `balanced` (see `context_profile_v`), or its
+ * value is not a known profile (the file is hand-editable).
+ */
+export function resumedContextProfile(records, want) {
+    const id = want.ccSessionId?.trim();
+    if (!id || !want.orgId)
+        return null;
+    for (let i = records.length - 1; i >= 0; i--) {
+        const r = records[i];
+        if (r.cc_session_id !== id || r.org_id !== want.orgId || r.gateway_host !== want.gatewayHost)
+            continue;
+        const p = r.context_profile;
+        if (p === "balanced" && r.context_profile_v !== 2)
+            return null; // an older row: sent nothing
+        return p !== undefined && CONTEXT_PROFILES.includes(p) ? p : null;
+    }
+    return null;
+}

package/dist/lib/agent.d.ts

@@ -294,22 +294,44 @@ export declare const CONTEXT_TAIL_BUDGET_KEY = "CONTEXT_RUNTIME_TAIL_BUDGET_TOKE
 export declare const CONTEXT_READ_CACHE_KEY = "CONTEXT_RUNTIME_READ_CACHE_TOKENS";
 export declare const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT_RECLAIM";
 /**
- * The gateway key the `adaptive` context profile sets (allow-listed per session): turns on the
- * size-banded fold policy. Only the literal `banded` enables it; the band thresholds and budgets
- * stay at the gateway's own defaults.
+ * The gateway key that turns the size-banded fold policy on or off (allow-listed per session).
+ * Only the literal `banded` enables it; any other value — the profiles send `off` — disables it,
+ * and a session's value replaces the cell's own. The band thresholds and budgets stay at the
+ * 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`):
- *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` — compaction is left to the coding agent
- *                    (the same bytes `--no-context` has always sent).
- *   - `balanced`   → NO fold keys: the gateway's own defaults stand. The default.
- *   - `aggressive` → a smaller tail budget + read cache and head-breakpoint reclaim on: folds
- *                    earlier and keeps a tighter working set.
+ * 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"` 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
+ *                    policy off: folds earlier and keeps a tighter working set at every size.
  *   - `adaptive`   → `CONTEXT_RUNTIME_SIZE_POLICY: "banded"` — the gateway picks the fold by the
  *                    conversation's original size: no fold below 200k tokens, the aggressive
- *                    budgets from 200k to 1M, balanced above. Opt-in; never the default.
+ *                    budgets from 200k to 1M, balanced above.
  */
 export declare const CONTEXT_PROFILES: readonly ["off", "balanced", "aggressive", "adaptive"];
 export type ContextProfile = (typeof CONTEXT_PROFILES)[number];
@@ -322,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;
@@ -412,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;
 /**
@@ -556,36 +576,45 @@ export declare function resolveContextFold(opts: {
  */
 export declare function parseContextProfile(raw: string, source: string): ContextProfile;
 /**
- * Which context profile this launch runs under. Precedence, highest wins:
+ * Which context profile this launch runs under, or `null` when none was chosen anywhere — then
+ * no fold key is sent and the cell's own default decides. Precedence, highest wins:
  *   1. `--no-context` — always `off`. Combined with an explicit `--context-profile
  *      balanced|aggressive|adaptive` it is a CONFLICT and the launch refuses (never a silent override);
  *      `--context-profile off` agrees with it.
  *   2. an explicit `--context-profile <profile>` flag (`--context` alongside it is fine — the
  *      profile wins);
- *   3. `MNEMOM_AGENT_CONTEXT_PROFILE` (which `applyConfigToEnv` sets from the `context_profile`
+ *   3. `resumed`: the profile the session this launch resumes ran under (from the session
+ *      ledger), so a resume keeps that session's own choice over the saved default;
+ *   4. `MNEMOM_AGENT_CONTEXT_PROFILE` (which `applyConfigToEnv` sets from the `context_profile`
  *      config key) — an invalid value is an error, never a silent default;
- *   4. the folding boolean when NO profile is set anywhere: `context = false` in launcher.toml
+ *   5. the folding boolean when NO profile is set anywhere: `context = false` in launcher.toml
  *      (→ `MNEMOM_AGENT_CONTEXT`, see `resolveContextFold`) means `off`;
- *   5. `balanced` (the default).
+ *   6. `null` — unset, the cell default.
  */
 export declare function resolveContextProfile(opts: {
     contextProfile?: ContextProfile;
     context?: boolean;
+    resumed?: ContextProfile | null;
     env?: NodeJS.ProcessEnv;
-}): ContextProfile;
+}): ContextProfile | null;
 /**
  * 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 for `aggressive`;
- * `CONTEXT_RUNTIME_SIZE_POLICY` for `adaptive`; nothing for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
+ * (`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 for `balanced` with everything off — the common case, where no
- * header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
+ * 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: {
-    profile: ContextProfile;
+    /** `resolveContextProfile` output: `null` ⇒ no profile chosen, no fold key sent. */
+    profile: ContextProfile | null;
     contextHandoff: boolean;
     compactionIntercept?: boolean;
     /** `resolveCompactAt` output: `null` (or absent) ⇒ no target, send nothing new. */
@@ -597,7 +626,7 @@ export declare function buildSessionConfig(opts: {
  * gateway's allow-list never sees them as env keys; it ignores unknown envelope fields.
  */
 export declare function buildSessionConfigPayload(opts: {
-    profile: ContextProfile;
+    profile: ContextProfile | null;
     contextHandoff: boolean;
     compactionIntercept?: boolean;
     compactAt?: number | null;
@@ -609,11 +638,12 @@ export declare function buildSessionConfigPayload(opts: {
 } | undefined;
 /**
  * The `x-mnemom-session-config` value for this launch, or `undefined` when there is
- * nothing to override (the gateway's own defaults stand — `balanced` with everything else off,
- * byte-identical to a launch before profiles existed). Independent overlays:
+ * nothing to override (the cell's own defaults stand — no profile chosen with everything else
+ * off, byte-identical to a launch before profiles existed). Independent overlays:
  *   - the context profile (`buildSessionConfig`): `off` → `CONTEXT_RUNTIME_ENABLED: "false"`,
- *     `aggressive` → the three fold-tuning keys, `adaptive` → `CONTEXT_RUNTIME_SIZE_POLICY:
- *     "banded"`, `balanced` → nothing;
+ *     `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);
  *   - `compactAt: <N>` (`--compact-at`, below 1M) → the SAME two intercept keys plus
@@ -626,7 +656,7 @@ export declare function buildSessionConfigPayload(opts: {
  * base64url so it survives the gateway's inbound strip.
  */
 export declare function buildSessionConfigB64(opts: {
-    profile: ContextProfile;
+    profile: ContextProfile | null;
     contextHandoff: boolean;
     compactionIntercept?: boolean;
     compactAt?: number | null;

package/dist/lib/agent.js

@@ -452,32 +452,59 @@ export const CONTEXT_TAIL_BUDGET_KEY = "CONTEXT_RUNTIME_TAIL_BUDGET_TOKENS";
 export const CONTEXT_READ_CACHE_KEY = "CONTEXT_RUNTIME_READ_CACHE_TOKENS";
 export const CONTEXT_HEAD_RECLAIM_KEY = "CONTEXT_RUNTIME_HEAD_BREAKPOINT_RECLAIM";
 /**
- * The gateway key the `adaptive` context profile sets (allow-listed per session): turns on the
- * size-banded fold policy. Only the literal `banded` enables it; the band thresholds and budgets
- * stay at the gateway's own defaults.
+ * The gateway key that turns the size-banded fold policy on or off (allow-listed per session).
+ * Only the literal `banded` enables it; any other value — the profiles send `off` — disables it,
+ * and a session's value replaces the cell's own. The band thresholds and budgets stay at the
+ * 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`):
- *   - `off`        → `CONTEXT_RUNTIME_ENABLED: "false"` — compaction is left to the coding agent
- *                    (the same bytes `--no-context` has always sent).
- *   - `balanced`   → NO fold keys: the gateway's own defaults stand. The default.
- *   - `aggressive` → a smaller tail budget + read cache and head-breakpoint reclaim on: folds
- *                    earlier and keeps a tighter working set.
+ * 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"` 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
+ *                    policy off: folds earlier and keeps a tighter working set at every size.
  *   - `adaptive`   → `CONTEXT_RUNTIME_SIZE_POLICY: "banded"` — the gateway picks the fold by the
  *                    conversation's original size: no fold below 200k tokens, the aggressive
- *                    budgets from 200k to 1M, balanced above. Opt-in; never the default.
+ *                    budgets from 200k to 1M, balanced above.
  */
 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"]],
-    balanced: [],
+    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"],
         [CONTEXT_READ_CACHE_KEY, "8000"],
         [CONTEXT_HEAD_RECLAIM_KEY, "true"],
+        [CONTEXT_SIZE_POLICY_KEY, "off"],
     ],
     adaptive: [[CONTEXT_SIZE_POLICY_KEY, "banded"]],
 };
@@ -490,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)
 // ---------------------------------------------------------------------------
@@ -651,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
@@ -912,17 +946,20 @@ export function parseContextProfile(raw, source) {
     throw new Error(`${source} must be one of ${CONTEXT_PROFILES.join(", ")} (got '${raw}').`);
 }
 /**
- * Which context profile this launch runs under. Precedence, highest wins:
+ * Which context profile this launch runs under, or `null` when none was chosen anywhere — then
+ * no fold key is sent and the cell's own default decides. Precedence, highest wins:
  *   1. `--no-context` — always `off`. Combined with an explicit `--context-profile
  *      balanced|aggressive|adaptive` it is a CONFLICT and the launch refuses (never a silent override);
  *      `--context-profile off` agrees with it.
  *   2. an explicit `--context-profile <profile>` flag (`--context` alongside it is fine — the
  *      profile wins);
- *   3. `MNEMOM_AGENT_CONTEXT_PROFILE` (which `applyConfigToEnv` sets from the `context_profile`
+ *   3. `resumed`: the profile the session this launch resumes ran under (from the session
+ *      ledger), so a resume keeps that session's own choice over the saved default;
+ *   4. `MNEMOM_AGENT_CONTEXT_PROFILE` (which `applyConfigToEnv` sets from the `context_profile`
  *      config key) — an invalid value is an error, never a silent default;
- *   4. the folding boolean when NO profile is set anywhere: `context = false` in launcher.toml
+ *   5. the folding boolean when NO profile is set anywhere: `context = false` in launcher.toml
  *      (→ `MNEMOM_AGENT_CONTEXT`, see `resolveContextFold`) means `off`;
- *   5. `balanced` (the default).
+ *   6. `null` — unset, the cell default.
  */
 export function resolveContextProfile(opts) {
     if (opts.context === false) {
@@ -933,34 +970,44 @@ export function resolveContextProfile(opts) {
     }
     if (opts.contextProfile !== undefined)
         return opts.contextProfile;
+    if (opts.resumed)
+        return opts.resumed;
     const raw = (opts.env?.MNEMOM_AGENT_CONTEXT_PROFILE ?? "").trim();
     if (raw !== "")
         return parseContextProfile(raw, "MNEMOM_AGENT_CONTEXT_PROFILE");
     if (!resolveContextFold({ context: opts.context, env: opts.env }))
         return "off";
-    return "balanced";
+    return null;
 }
 /**
  * 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 for `aggressive`;
- * `CONTEXT_RUNTIME_SIZE_POLICY` for `adaptive`; nothing for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
+ * (`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 for `balanced` with everything off — the common case, where no
- * header is sent at all. Exported so `--dry-run` can list exactly what the header carries.
+ * 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) {
     const config = {};
-    for (const [k, v] of CONTEXT_PROFILE_CONFIG[opts.profile])
-        config[k] = v;
+    if (opts.profile !== null) {
+        for (const [k, v] of CONTEXT_PROFILE_CONFIG[opts.profile])
+            config[k] = v;
+    }
     if (opts.contextHandoff)
         config[CONTEXT_HANDOFF_KEY] = "true";
     const hasCompactionTarget = opts.compactAt !== undefined && opts.compactAt !== null;
     // 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";
@@ -986,11 +1033,12 @@ export function buildSessionConfigPayload(opts) {
 }
 /**
  * The `x-mnemom-session-config` value for this launch, or `undefined` when there is
- * nothing to override (the gateway's own defaults stand — `balanced` with everything else off,
- * byte-identical to a launch before profiles existed). Independent overlays:
+ * nothing to override (the cell's own defaults stand — no profile chosen with everything else
+ * off, byte-identical to a launch before profiles existed). Independent overlays:
  *   - the context profile (`buildSessionConfig`): `off` → `CONTEXT_RUNTIME_ENABLED: "false"`,
- *     `aggressive` → the three fold-tuning keys, `adaptive` → `CONTEXT_RUNTIME_SIZE_POLICY:
- *     "banded"`, `balanced` → nothing;
+ *     `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);
  *   - `compactAt: <N>` (`--compact-at`, below 1M) → the SAME two intercept keys plus

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

@@ -56,10 +56,11 @@ export interface LauncherConfig {
      */
     compactionIntercept?: boolean;
     /**
-     * How the gateway folds each session's context (`balanced` when unset): `off` leaves
-     * compaction to the coding agent, `balanced` keeps more earlier work verbatim, `aggressive`
-     * folds earlier with a tighter working set, `adaptive` sizes the fold to the conversation
-     * (none below 200k tokens, aggressive up to 1M, balanced above). `--context-profile` overrides it per launch.
+     * How the gateway folds each session's context (unset: nothing is sent, the gateway cell's
+     * own default decides): `off` leaves compaction to the coding agent, `balanced` keeps more
+     * earlier work verbatim, `aggressive` folds earlier with a tighter working set, `adaptive`
+     * sizes the fold to the conversation (none below 200k tokens, aggressive up to 1M, balanced
+     * above). `--context-profile` overrides it for one launch without saving anything.
      */
     contextProfile?: ContextProfile;
     /**

package/dist/lib/launcher-config.js

@@ -215,7 +215,7 @@ export const CONFIG_KEYS = [
     },
     {
         key: "context_profile",
-        describe: `How the gateway folds each session's context (${CONTEXT_PROFILES.join("|")}; balanced by default)`,
+        describe: `How the gateway folds each session's context (${CONTEXT_PROFILES.join("|")}; unset = the gateway cell's default)`,
         get: (c) => c.contextProfile,
         set: (c, v) => {
             c.contextProfile = parseContextProfile(v, "context_profile");

package/package.json

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