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

package/README.md

@@ -87,20 +87,27 @@ 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.
 
-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 +116,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)
 

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";
@@ -54,13 +54,19 @@ 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.";
 /**
- * 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 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 +180,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,
@@ -209,7 +216,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         compactionIntercept,
         compactAt,
     });
-    const sessionConfigB64 = buildSessionConfigB64({
+    let sessionConfigB64 = buildSessionConfigB64({
         profile: contextProfile,
         contextHandoff,
         compactionIntercept,
@@ -431,6 +438,33 @@ 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 });
+            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
@@ -703,7 +737,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 +1654,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. 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,26 @@ 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 named presets for how the gateway folds a session's context (`--context-profile`,
- * launcher.toml `context_profile`, `MNEMOM_AGENT_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).
- *   - `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.
+ *   - `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];
@@ -556,36 +560,42 @@ 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` 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. 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 +607,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 +619,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 +637,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,37 @@ 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 named presets for how the gateway folds a session's context (`--context-profile`,
- * launcher.toml `context_profile`, `MNEMOM_AGENT_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).
- *   - `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.
+ *   - `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: [],
+    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"]],
 };
@@ -912,17 +917,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,28 +941,33 @@ 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` 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. 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;
@@ -986,11 +999,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.1",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {