@mnemom/mnemom 0.17.4-next.5 → 0.17.4-next.7

package/README.md

@@ -129,6 +129,25 @@ mnemom agent config set context_handoff off  # back to the default
 This is experimental: it only ever ADDS the one tool (no gateway behavior changes for a
 session that leaves the setting off, and no change to Claude Code's own `/compact`).
 
+#### Compaction signal and intercept
+
+Every launch shape (terminal, `-- -p …` headless, `--remote-control`, `--server`) starts Claude
+Code with `CLAUDE_CODE_GATEWAY_HINT_HEADERS=1`, so its requests carry the
+`x-claude-code-request-class` / `x-claude-code-compaction` hint headers, which mark exactly
+which request is a compaction (a gateway that does not read them ignores them). A value you set yourself (even `0`) wins. The launcher
+never sets or changes your own auto-compaction settings (`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`,
+`CLAUDE_CODE_AUTO_COMPACT_WINDOW`, or `autoCompactWindow` in settings.json).
+
+**Experimental, off by default.** `--compaction-intercept` (after `mnemom experimental enable
+compaction-intercept`; standing default `mnemom agent config set compaction_intercept on`, or
+`MNEMOM_AGENT_COMPACTION_INTERCEPT=1`) sends `GATEWAY_USAGE_REAL_SIZE=on` and
+`GATEWAY_COMPACTION_INTERCEPT=on` in the per-session config header, asking the gateway to report
+the real context size (so Claude Code compacts at its own threshold) and to answer that
+compaction at once from its fold instead of a blocking model call. This needs the companion
+gateway support: a gateway without it drops both keys (they are echoed back in
+`x-mnemom-session-config-dropped`) and the session behaves exactly as with the setting off. `--no-compaction-intercept` turns it off for
+one launch.
+
 ## How It Works
 
 ```

package/dist/commands/agent-config.js

@@ -193,6 +193,9 @@ function deleteKey(cfg, key) {
         case "context_handoff":
             delete cfg.contextHandoff;
             break;
+        case "compaction_intercept":
+            delete cfg.compactionIntercept;
+            break;
         case "context_profile":
             delete cfg.contextProfile;
             break;

package/dist/commands/agent-setup.d.ts

@@ -74,11 +74,20 @@ export interface EnsureAgentOptions {
     gatewayHost: string;
     /** Override interactivity (defaults to isInteractive()). */
     interactive?: boolean;
+    /** Where the served-agent cache lives (defaults to ~/.mnemom). */
+    cacheDir?: string;
 }
+/** A bare launch never waits on the served-agent probe longer than this. */
+export declare const SERVED_PROBE_TIMEOUT_MS = 10000;
 export interface EnsureAgentResult {
     slug: string;
     /** true only when this call actually birthed/claimed/published. */
     provisioned: boolean;
+    /**
+     * The mnm- id the gateway serves for (key, slug), when this call learned it (a verified name
+     * match, a mismatch, or a fresh birth). Absent when it never asked the gateway.
+     */
+    agentId?: string;
 }
 /**
  * Ensure `slug` is a usable governed agent in the customer's org. Returns

package/dist/commands/agent-setup.js

@@ -26,11 +26,12 @@
 import { claimAgent, getAgentByName, getMe, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
 import { getAuthInfo, isLoggedIn, loginWithBrowser, loginWithDeviceFlow, resolveAuth, } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.js";
-import { getApiUrl, getGatewayUrl, getWebsiteUrl } from "../lib/config.js";
+import { getApiUrl, getGatewayUrl, getWebsiteUrl, MNEMOM_DIR } from "../lib/config.js";
 import { fmt } from "../lib/format.js";
 import { askYesNo, isInteractive } from "../lib/prompt.js";
 import { resolveAnthropicDoor, resolveGatewayHost, sanitizeAgentName, singleCellError, } from "../lib/agent.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
+import { readServedAgent, servedFingerprint, writeServedAgent } from "../lib/served-agent-cache.js";
 import { deriveHashProof } from "./agents.js";
 import { birthThroughGateway } from "./wrap.js";
 import { resolveAnthropicKey } from "./agent.js";
@@ -104,6 +105,8 @@ export class AgentIdentityMismatchError extends Error {
         this.name = "AgentIdentityMismatchError";
     }
 }
+/** A bare launch never waits on the served-agent probe longer than this. */
+export const SERVED_PROBE_TIMEOUT_MS = 10_000;
 /**
  * Ensure `slug` is a usable governed agent in the customer's org. Returns
  * {provisioned:false} when it is already usable, when provisioning is not
@@ -115,33 +118,61 @@ export class AgentIdentityMismatchError extends Error {
  */
 export async function ensureGovernedAgent(opts) {
     const slug = opts.slug;
+    const cacheDir = opts.cacheDir ?? MNEMOM_DIR;
     const interactive = opts.interactive ?? isInteractive();
     // 1. Already usable? A named agent in the caller's fleet is claimed by them.
     const loggedIn = await isLoggedIn();
     if (loggedIn) {
         const existing = await getAgentByName(slug).catch(() => null);
         if (existing) {
+            // MNE-7650: the name is client-controlled and the API exposes no
+            // agent_hash, so a name match proves nothing about which agent the
+            // gateway will serve for (key, slug) — it looks agents up by
+            // hash(credential, name) only. Ask the gateway on EVERY launch, not just
+            // under --setup: the same 16-token "hello" the birth path uses answers
+            // with the served mnm- id on x-mnemom-agent. A bare launch that trusted
+            // the name recorded and reported an org agent while the gateway governed
+            // a different, unclaimed one (a second Anthropic key on a shared name).
+            //
+            // The answer is stable per (key, name, gateway), so a bare launch reuses a cached one and
+            // only probes (time-boxed) the first time; --setup always re-asks.
+            const gatewayUrl = opts.gatewayHost.replace(/\/+$/, "");
+            const fp = servedFingerprint(opts.anthropicKey, slug, gatewayUrl);
+            const cached = opts.setup === true ? null : readServedAgent(cacheDir, fp);
+            let served;
+            try {
+                served =
+                    cached ??
+                        (await birthThroughGateway(gatewayUrl, "anthropic", slug, opts.anthropicKey, {
+                            timeoutMs: opts.setup === true ? undefined : SERVED_PROBE_TIMEOUT_MS,
+                        }));
+            }
+            catch (err) {
+                // --setup must know which agent it governs; a bare launch carries on
+                // with the id unresolved rather than guessing it from the name.
+                if (opts.setup === true)
+                    throw err;
+                say(fmt.dim(`mnemom agent: couldn't confirm which agent the gateway serves for '${slug}' (${err instanceof Error ? err.message : String(err)}) — launching anyway.`));
+                return { slug, provisioned: false };
+            }
+            if (!cached)
+                writeServedAgent(cacheDir, fp, served);
+            if (served !== existing.id) {
+                if (opts.setup === true)
+                    throw new AgentIdentityMismatchError(slug, existing.id, served);
+                warnServedMismatch(slug, existing.id, served);
+                return { slug, provisioned: false, agentId: served };
+            }
             // On an EXPLICIT `mnemom agent setup`, repair/complete the cards on the
             // already-claimed agent (e.g. a protection card that failed on a prior run
             // before we minted its one-time grant). A bare launch leaves it alone.
             if (opts.setup === true) {
-                // MNE-7650: the name is client-controlled and the API exposes no
-                // agent_hash, so a name match proves nothing about which agent the
-                // gateway will serve for (key, slug) — it looks agents up by
-                // hash(credential, name) only. Ask the gateway: the same 16-token
-                // "hello" the birth path uses answers with the served mnm- id on
-                // x-mnemom-agent. Govern that agent or none.
-                const gatewayUrl = opts.gatewayHost.replace(/\/+$/, "");
-                const served = await birthThroughGateway(gatewayUrl, "anthropic", slug, opts.anthropicKey);
-                if (served !== existing.id) {
-                    throw new AgentIdentityMismatchError(slug, existing.id, served);
-                }
                 say(fmt.dim(`mnemom agent: '${slug}' is already claimed (${existing.id}, the agent the gateway serves) — refreshing its cards.`));
                 await publishDefaultCards(existing.id);
                 persistAgentSlug(slug);
-                return { slug, provisioned: true };
+                return { slug, provisioned: true, agentId: existing.id };
             }
-            return { slug, provisioned: false };
+            return { slug, provisioned: false, agentId: existing.id };
         }
     }
     // 2. Are we allowed to provision here?
@@ -186,7 +217,17 @@ export async function ensureGovernedAgent(opts) {
     await publishDefaultCards(agentId);
     // 6. Remember the slug so future launches skip straight to usable.
     persistAgentSlug(slug);
-    return { slug, provisioned: true };
+    return { slug, provisioned: true, agentId };
+}
+/**
+ * A bare launch whose name matches an org agent the gateway does NOT serve for this key. Not
+ * fatal (no --setup asked to govern it), but the user must know their governance lands on the
+ * served agent, and how to get a governed one of their own.
+ */
+function warnServedMismatch(slug, namedId, servedId) {
+    say(fmt.warn(`mnemom agent: '${slug}' in your org is ${namedId}, but the gateway serves ${servedId} for this Anthropic key + name — this session is governed as ${servedId}, which is not claimed to your org.`));
+    say(fmt.dim("  The gateway identity is hash(Anthropic key, name), so another key on the same name is a different agent. " +
+        `Use a name of your own: \`mnemom agent <scenario> --agent <unique-name> --setup\` (or claim the served one: \`mnemom agent claim ${servedId} --key <this key>\`).`));
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**

package/dist/commands/agent.d.ts

@@ -79,6 +79,13 @@ export interface AgentOptions {
      * ⇒ no header key, no MCP server — the launch is byte-identical to a build without this flag.
      */
     contextHandoff?: boolean;
+    /**
+     * EXPERIMENTAL, off by default (payload-bound fix): tells the gateway
+     * `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` for this session only (real
+     * context size in usage, so Claude Code compacts at its OWN threshold; the compaction request
+     * answered at once from the gateway's fold). Absent/false ⇒ no header key.
+     */
+    compactionIntercept?: boolean;
     /**
      * Governed-agent provisioning: undefined = AUTO (provision-with-confirm when
      * interactive, warn-and-continue otherwise), true = force (`--setup`), false =
@@ -116,11 +123,30 @@ export declare function passthroughResumeId(passthrough: readonly string[]): str
  *   - `-- --resume <cc-session-id>` → the matching row that pinned that Claude Code session
  *     (else the newest matching row), reused without asking;
  *   - no `--resume` → "Resume previous session <name>? [Y/n]", default Y; Y reuses that row's
- *     conversation, n mints a new one. `--resume` is NOT added to Claude Code (the user often
- *     resumes inside it with /resume). No TTY: Y.
+ *     conversation, n mints a new one. No TTY: Y.
  * The ledger read is best-effort: a failure means a new id.
  */
-export declare function resolveLaunchConversationId(input: {
+export declare function resolveLaunchConversationId(input: LaunchContinuationInput): Promise<string>;
+/**
+ * Whether Claude Code still has the transcript of session `id`
+ * (`${CLAUDE_CONFIG_DIR:-~/.claude}/projects/<any project>/<id>.jsonl`; `--resume` finds it in any
+ * project). Claude Code exits on `--resume` of an id it has no transcript for, so a relaunch only
+ * resumes one that is there. Best-effort: an unreadable directory or a non-UUID id → false.
+ */
+export declare function ccSessionTranscriptExists(id: string, env: NodeJS.ProcessEnv): boolean;
+/**
+ * resolveLaunchConversationId, plus the Claude Code session to resume. A Y (or no-TTY) relaunch
+ * of an earlier implicit launch also resumes the CC session that launch pinned (`--resume <id>`),
+ * when the caller passed no session flag of their own: the gateway gives the conversation's main
+ * goal to ONE CC session id, and a fresh `--session-id` cannot reuse it (CC refuses an id already
+ * in use), so without the resume the relaunch would run on a new, empty thread. An n, a new
+ * conversation, or the caller's own `--resume` / `--session-id` / `--continue` resume nothing.
+ */
+export declare function resolveLaunchContinuation(input: LaunchContinuationInput): Promise<{
+    conversationId: string;
+    resumeCcSessionId: string | null;
+}>;
+interface LaunchContinuationInput {
     session: string;
     orgId: string;
     agent: string;
@@ -131,7 +157,9 @@ export declare function resolveLaunchConversationId(input: {
     interactive: boolean;
     records: () => SessionRecord[];
     askYesNo: (question: string, defaultYes: boolean) => Promise<boolean>;
-}): Promise<string>;
+    /** Whether Claude Code still has that session's transcript (ccSessionTranscriptExists). */
+    ccSessionExists: (ccSessionId: string) => boolean;
+}
 /**
  * Record this launch in ~/.mnemom/sessions.jsonl. The agent record id is
  * resolved best-effort (a lookup failure or an unknown slug records null); a
@@ -141,6 +169,11 @@ export declare function recordSessionLaunch(ctx: {
     session: string;
     conversationId: string;
     agent: string;
+    /**
+     * The id the gateway serves, as setup learned it (null = asked, unknown). Undefined = setup
+     * never asked, so fall back to the org's name lookup.
+     */
+    agentId?: string | null;
     account: {
         orgId: string;
         orgLabel: string;
@@ -313,3 +346,4 @@ export declare function printPlan(ctx: {
     /** The experimental features on for this launch (the header's `experimental` array). */
     experimental?: readonly string[];
 }): void;
+export {};

package/dist/commands/agent.js

@@ -43,12 +43,14 @@ import { askInput, askSelect, askYesNo, isInteractive } from "../lib/prompt.js";
 import { authConfigured, chooseAuth, detectClaudeLogin, readClaudeLoginState, } from "../lib/login-detect.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, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, GATEWAY_HINT_HEADERS_ENV, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_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 } 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. */
 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.";
 /**
  * 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.
@@ -149,11 +151,20 @@ export async function agentCommand(scenarioArg, options = {}) {
         say("mnemom agent: context handoff is not available with subscription login yet — launching without it.");
         contextHandoff = false;
     }
+    const compactionIntercept = resolveCompactionIntercept({
+        compactionIntercept: options.compactionIntercept,
+        env,
+    });
     const experimental = options.experimental ?? [];
-    const sessionConfig = buildSessionConfig({ profile: contextProfile, contextHandoff });
+    const sessionConfig = buildSessionConfig({
+        profile: contextProfile,
+        contextHandoff,
+        compactionIntercept,
+    });
     const sessionConfigB64 = buildSessionConfigB64({
         profile: contextProfile,
         contextHandoff,
+        compactionIntercept,
         experimental,
     });
     const expNotice = experimentalNotice(experimental);
@@ -212,6 +223,8 @@ export async function agentCommand(scenarioArg, options = {}) {
         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,
@@ -297,19 +310,24 @@ export async function agentCommand(scenarioArg, options = {}) {
     // provisions-with-confirm when interactive; warns and continues otherwise.
     // Skipped entirely by `--no-setup`. A provisioning failure never blocks the
     // launch — it degrades to the unclaimed (fail-open) identity with a warning.
+    // The agent id the gateway serves, when setup asked it (undefined = never asked, so the ledger
+    // falls back to the org's name lookup).
+    let servedAgentId;
     if (options.setup !== false && !anthropicKey) {
         // Subscription login: the gateway creates the agent in the Mnemom key's org on the first
         // turn, so there is nothing to birth or claim here.
         say(`mnemom agent: subscription login — '${agent}' is created in your org on the first turn (identity: your Mnemom API key).`);
     }
     else if (options.setup !== false && anthropicKey) {
+        servedAgentId = null; // asked below; stays null if setup can't tell
         try {
-            await ensureGovernedAgent({
+            const ensured = await ensureGovernedAgent({
                 slug: agent,
                 anthropicKey,
                 setup: options.setup,
                 gatewayHost,
             });
+            servedAgentId = ensured.agentId ?? null;
         }
         catch (err) {
             // An identity mismatch is the one setup failure that must NOT degrade: the
@@ -325,7 +343,7 @@ export async function agentCommand(scenarioArg, options = {}) {
     // so the goal the gateway inferred there is still the one it steers by. Resolved here, after
     // sign-in and the agent refresh, because a resume needs the org, agent and gateway host to
     // match the earlier launch.
-    const conversationId = await resolveLaunchConversationId({
+    const continuation = await resolveLaunchContinuation({
         session: scenario,
         orgId: account.orgId,
         agent,
@@ -336,7 +354,19 @@ export async function agentCommand(scenarioArg, options = {}) {
         interactive: isInteractive(),
         records: () => readSessionRecords({ dir: MNEMOM_DIR }),
         askYesNo: (q, d) => askYesNo(q, d),
+        ccSessionExists: (id) => ccSessionTranscriptExists(id, process.env),
     });
+    const conversationId = continuation.conversationId;
+    // A relaunch that continues an earlier conversation resumes that Claude Code session, so the
+    // same CC session id keeps owning the conversation's main goal on the gateway (a fresh
+    // --session-id would land on a new, empty m.<sha16> thread). The server shape hosts many
+    // sessions and pins none.
+    if (continuation.resumeCcSessionId && shape !== "server") {
+        options = {
+            ...options,
+            passthrough: [...(options.passthrough ?? []), "--resume", continuation.resumeCcSessionId],
+        };
+    }
     // ── 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
@@ -368,6 +398,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         session: scenario,
         conversationId,
         agent,
+        agentId: servedAgentId,
         account,
         gatewayHost,
         shape,
@@ -383,6 +414,8 @@ export async function agentCommand(scenarioArg, options = {}) {
         say(expNotice);
     say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
     sayContextProfile(contextProfile);
+    if (compactionIntercept)
+        say(COMPACTION_INTERCEPT_NOTE);
     // ── 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
@@ -483,21 +516,62 @@ export function passthroughResumeId(passthrough) {
  *   - `-- --resume <cc-session-id>` → the matching row that pinned that Claude Code session
  *     (else the newest matching row), reused without asking;
  *   - no `--resume` → "Resume previous session <name>? [Y/n]", default Y; Y reuses that row's
- *     conversation, n mints a new one. `--resume` is NOT added to Claude Code (the user often
- *     resumes inside it with /resume). No TTY: Y.
+ *     conversation, n mints a new one. No TTY: Y.
  * The ledger read is best-effort: a failure means a new id.
  */
 export async function resolveLaunchConversationId(input) {
-    if ((input.explicit ?? "").trim())
-        return resolveConversationId(input.explicit);
+    return (await resolveLaunchContinuation(input)).conversationId;
+}
+/**
+ * Whether the caller's passthrough already chooses the Claude Code session (`--session-id`,
+ * `--resume` / `-r`, `--continue` / `-c`, `--fork-session`): exactly when pickCcSessionId would
+ * NOT mint one, so the two never disagree about which flags count.
+ */
+function choosesCcSession(passthrough) {
+    return !pickCcSessionId([...passthrough], () => "").inject;
+}
+const CC_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Whether Claude Code still has the transcript of session `id`
+ * (`${CLAUDE_CONFIG_DIR:-~/.claude}/projects/<any project>/<id>.jsonl`; `--resume` finds it in any
+ * project). Claude Code exits on `--resume` of an id it has no transcript for, so a relaunch only
+ * resumes one that is there. Best-effort: an unreadable directory or a non-UUID id → false.
+ */
+export function ccSessionTranscriptExists(id, env) {
+    if (!CC_SESSION_ID_RE.test(id))
+        return false;
+    const projects = join((env.CLAUDE_CONFIG_DIR ?? "").trim() || join(homedir(), ".claude"), "projects");
+    try {
+        return readdirSync(projects).some((d) => existsSync(join(projects, d, `${id}.jsonl`)));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * resolveLaunchConversationId, plus the Claude Code session to resume. A Y (or no-TTY) relaunch
+ * of an earlier implicit launch also resumes the CC session that launch pinned (`--resume <id>`),
+ * when the caller passed no session flag of their own: the gateway gives the conversation's main
+ * goal to ONE CC session id, and a fresh `--session-id` cannot reuse it (CC refuses an id already
+ * in use), so without the resume the relaunch would run on a new, empty thread. An n, a new
+ * conversation, or the caller's own `--resume` / `--session-id` / `--continue` resume nothing.
+ */
+export async function resolveLaunchContinuation(input) {
+    const fresh = () => ({
+        conversationId: resolveConversationId(undefined),
+        resumeCcSessionId: null,
+    });
+    if ((input.explicit ?? "").trim()) {
+        return { conversationId: resolveConversationId(input.explicit), resumeCcSessionId: null };
+    }
     if (!input.implicit)
-        return resolveConversationId(undefined);
+        return fresh();
     let records;
     try {
         records = input.records();
     }
     catch {
-        return resolveConversationId(undefined);
+        return fresh();
     }
     const found = findResumeCandidate(records, {
         session: input.session,
@@ -507,15 +581,24 @@ export async function resolveLaunchConversationId(input) {
         resumeId: passthroughResumeId(input.passthrough),
     });
     if (!found)
-        return resolveConversationId(undefined);
+        return fresh();
     const conv = found.record.conversation_id;
     if (found.source === "session_name" && input.interactive) {
         const yes = await input.askYesNo(`Resume previous session ${input.session}?`, true);
         if (!yes)
-            return resolveConversationId(undefined);
+            return fresh();
     }
     say(`mnemom agent: continuing conversation ${conv} from the earlier '${found.record.session}' launch (${found.record.started_at}), so its goal carries over.`);
-    return resolveConversationId(conv);
+    const cc = found.record.cc_session_id?.trim() ?? "";
+    let resumeCcSessionId = null;
+    if (found.source === "session_name" && cc && !choosesCcSession(input.passthrough)) {
+        if (input.ccSessionExists(cc))
+            resumeCcSessionId = cc;
+        else {
+            say(`mnemom agent: Claude Code no longer has session ${cc}, so this launch starts a new one (its goal starts empty on the gateway).`);
+        }
+    }
+    return { conversationId: resolveConversationId(conv), resumeCcSessionId };
 }
 /**
  * Record this launch in ~/.mnemom/sessions.jsonl. The agent record id is
@@ -523,12 +606,19 @@ export async function resolveLaunchConversationId(input) {
  * ledger write failure warns to stderr and the launch proceeds regardless.
  */
 export async function recordSessionLaunch(ctx) {
+    // Never re-derive a known id from the name: the name can match an org agent the gateway does
+    // not serve for this key (MNE-7650), which is exactly what the ledger must not record.
     let agentId;
-    try {
-        agentId = (await getAgentByName(ctx.agent))?.id ?? null;
+    if (ctx.agentId !== undefined) {
+        agentId = ctx.agentId;
     }
-    catch {
-        agentId = null; // unresolvable right now — the ledger still records the launch
+    else {
+        try {
+            agentId = (await getAgentByName(ctx.agent))?.id ?? null;
+        }
+        catch {
+            agentId = null; // unresolvable right now — the ledger still records the launch
+        }
     }
     const result = appendSessionRecord({
         session: ctx.session,
@@ -855,7 +945,11 @@ function launchTerminal(ctx) {
     applyToolSearchDefault(childEnv);
     const sessionName = passthroughName(ctx.options.passthrough ?? []) ?? sessionDisplayName(ctx.agent, ctx.scenario);
     childEnv[SESSION_NAME_ENV] = sessionName;
-    childEnv[GATEWAY_HINT_HEADERS_ENV] = "1";
+    // Exact compaction signal for the gateway (x-claude-code-request-class: compaction), on every
+    // terminal launch — interactive and `-p` passthrough alike; a user's own value wins. The
+    // user's CLAUDE_AUTOCOMPACT_PCT_OVERRIDE / CLAUDE_CODE_AUTO_COMPACT_WINDOW ride through
+    // untouched in the copied env (USER_AUTOCOMPACT_ENV).
+    applyGatewayHintHeaders(childEnv);
     if (ctx.options.slack)
         args.push(...slackChannelArgs(sessionName));
     if (ctx.contextHint) {
@@ -1099,6 +1193,11 @@ function spawnRcCli(ctx) {
     childEnv.https_proxy = `http://127.0.0.1:${ctx.port}`;
     childEnv.NODE_EXTRA_CA_CERTS = ctx.ca;
     childEnv[SESSION_NAME_ENV] = rcName;
+    // Same exact compaction signal as the terminal shape. Not an ANTHROPIC_* var, so the RC gate
+    // ignores it (like HTTPS_PROXY above); the proxy forwards every non-hop request header, so the
+    // x-claude-code-* hints reach the gateway. The user's own autocompact env is not on the strip
+    // list and rides through untouched.
+    applyGatewayHintHeaders(childEnv);
     // Under RC Claude Code sees a first-party host (the proxy, not ANTHROPIC_BASE_URL, routes to the
     // gateway), so tool search is already on by default; setting it anyway keeps every launch shape
     // on the same switch. A user value is kept.

package/dist/commands/wrap.d.ts

@@ -24,5 +24,7 @@ export interface WrapOptions {
     providerKey?: string;
 }
 export declare function wrapCommand(options?: WrapOptions): Promise<void>;
-export declare function birthThroughGateway(gatewayUrl: string, provider: Provider, agentName: string, providerKey: string): Promise<string>;
+export declare function birthThroughGateway(gatewayUrl: string, provider: Provider, agentName: string, providerKey: string, opts?: {
+    timeoutMs?: number;
+}): Promise<string>;
 export {};

package/dist/commands/wrap.js

@@ -199,7 +199,7 @@ async function resolveProviderKey(options, prov, nonInteractive, say) {
     return key;
 }
 // ── Birth call ────────────────────────────────────────────────────────────────
-export async function birthThroughGateway(gatewayUrl, provider, agentName, providerKey) {
+export async function birthThroughGateway(gatewayUrl, provider, agentName, providerKey, opts = {}) {
     const prov = PROVIDERS[provider];
     const authValue = provider === "openai" ? `Bearer ${providerKey}` : providerKey;
     const headers = {
@@ -235,7 +235,12 @@ export async function birthThroughGateway(gatewayUrl, provider, agentName, provi
                 messages: [{ role: "user", content: "hello" }],
             });
     }
-    const response = await fetch(url, { method: "POST", headers, body });
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined,
+    });
     const agentId = response.headers.get(AGENT_HEADER);
     if (!response.ok && !agentId) {
         const text = await response.text().catch(() => "");

package/dist/index.js

@@ -173,6 +173,8 @@ const agentCmd = program
 }))
     .addOption(new Option("--context-handoff", "EXPERIMENTAL (`mnemom experimental enable context-handoff`): register the `handoff(note)` MCP tool and tell the gateway to turn on the context-handoff capability for this session").hideHelp(hiddenUnless("context-handoff")))
     .option("--no-context-handoff", "Keep context handoff off for this launch even when launcher.toml (context_handoff = true) or MNEMOM_AGENT_CONTEXT_HANDOFF turns it on")
+    .addOption(new Option("--compaction-intercept", "EXPERIMENTAL (`mnemom experimental enable compaction-intercept`): tell the gateway to report the real context size (Claude Code compacts at its own threshold) and answer the compaction at once from its fold, for this session").hideHelp(hiddenUnless("compaction-intercept")))
+    .option("--no-compaction-intercept", "Keep the compaction intercept off for this launch even when launcher.toml (compaction_intercept = true) or MNEMOM_AGENT_COMPACTION_INTERCEPT turns it on")
     .option("--dry-run", "Print the resolved launch plan and exit — no key read, no spawn")
     .option("--first-run", "Show the first-run look again: what Mnemom would have saved on your last 30 days of Claude Code (runs on this machine, read-only, nothing uploaded) — then exit")
     .action(async (scenario, passthrough, opts) => {
@@ -216,6 +218,11 @@ const agentCmd = program
                 used: opts.contextHandoff === true,
             },
             { what: "--implicit", id: "implicit", used: opts.implicit === true },
+            {
+                what: "--compaction-intercept",
+                id: "compaction-intercept",
+                used: opts.compactionIntercept === true,
+            },
         ], experimental);
         if (opts.gateway)
             process.env.MNEMOM_AGENT_GATEWAY = opts.gateway;
@@ -301,6 +308,10 @@ const agentCmd = program
             contextProfile: opts.contextProfile,
             // Off ⇒ an explicit false, so MNEMOM_AGENT_CONTEXT_HANDOFF cannot turn it on.
             contextHandoff: experimental.includes("context-handoff") ? opts.contextHandoff : false,
+            // Same gate: off ⇒ an explicit false, so MNEMOM_AGENT_COMPACTION_INTERCEPT cannot turn it on.
+            compactionIntercept: experimental.includes("compaction-intercept")
+                ? opts.compactionIntercept
+                : false,
             experimental,
             setup: opts.setup,
             keySource: cfg.keySource,

package/dist/lib/agent.d.ts

@@ -228,15 +228,6 @@ export declare function resolveWindowModel(input: {
     env: Record<string, string | undefined>;
     settings: () => CcSettingsView[];
 }): WindowModel;
-/**
- * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class`,
- * `x-claude-code-agent-type`, `x-claude-code-prompt-id`). CC sends them to api.anthropic.com on
- * its own, so a Remote Control launch (rc-proxy in front of api.anthropic.com) already carries
- * them; with `ANTHROPIC_BASE_URL` pointing at the gateway door (the terminal shape) CC sends them
- * only when this is "1". The gateway reads them to keep away summaries, titles, compaction and
- * teammates off the main implicit goal.
- */
-export declare const GATEWAY_HINT_HEADERS_ENV = "CLAUDE_CODE_GATEWAY_HINT_HEADERS";
 /** The session display name: "<agent>-<scenario>" (sanitised), else the agent slug. */
 export declare function sessionDisplayName(agent: string, scenario: string): string;
 /** A caller's own `--name <x>` in the passthrough args, if any (last one wins). */
@@ -322,6 +313,42 @@ 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"`, ONLY when the setting is on (see `resolveCompactionIntercept`).
+ */
+export declare const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
+export declare const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
+/**
+ * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class: main |
+ * compaction`, `x-claude-code-compaction: auto | manual | reactive`,
+ * `x-claude-code-context-compacted` on the next turn, `x-claude-code-prompt-id`). Off by default
+ * in the client; the launcher turns it on for EVERY launch shape (terminal, `-p` passthrough,
+ * Remote Control interactive and server) so the gateway gets an exact compaction signal instead
+ * of relying on the body rule alone. Headers only — no behaviour change in the client. The
+ * gateway also reads them to keep summaries, titles, compaction and teammates off the main
+ * implicit goal.
+ */
+export declare const GATEWAY_HINT_HEADERS_ENV = "CLAUDE_CODE_GATEWAY_HINT_HEADERS";
+/**
+ * Claude Code's own auto-compaction knobs (env). The launcher NEVER sets, changes or strips
+ * them: whatever the user configured is what the client honours (the `autoCompactWindow`
+ * settings.json key is likewise never touched — the launcher writes no settings file).
+ */
+export declare const USER_AUTOCOMPACT_ENV: readonly ["CLAUDE_AUTOCOMPACT_PCT_OVERRIDE", "CLAUDE_CODE_AUTO_COMPACT_WINDOW"];
+/**
+ * Turn Claude Code's gateway hint headers on in a child env, unless the user already set
+ * `CLAUDE_CODE_GATEWAY_HINT_HEADERS` themselves (any non-blank value, `0` included, wins).
+ * Mutates and returns `childEnv`. Touches no other key.
+ */
+export declare function applyGatewayHintHeaders(childEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /**
  * The `x-mnemom-goal-mode` header value for `--implicit`, or null when the flag
  * is absent: `implicit[; max_turns=N][; budget_usd=X][; stall_turns=N]` — the
@@ -456,13 +483,15 @@ export declare function resolveContextProfile(opts: {
  * The decoded per-session env overlay for this launch — the `config` object of the
  * `x-mnemom-session-config` payload, in wire order: the profile's keys first
  * (`CONTEXT_RUNTIME_ENABLED` for `off`; the three fold-tuning keys for `aggressive`; nothing
- * for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON. Empty
- * for `balanced` with handoff off — the common case, where no header is sent at all.
+ * for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
+ * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when the compaction
+ * intercept is ON. Empty for `balanced` with both 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;
     contextHandoff: boolean;
+    compactionIntercept?: boolean;
 }): Record<string, string>;
 /**
  * The `x-mnemom-session-config` payload: `{ v: 1, config, experimental? }`. The active
@@ -472,6 +501,7 @@ export declare function buildSessionConfig(opts: {
 export declare function buildSessionConfigPayload(opts: {
     profile: ContextProfile;
     contextHandoff: boolean;
+    compactionIntercept?: boolean;
     experimental?: readonly string[];
 }): {
     v: 1;
@@ -484,6 +514,8 @@ export declare function buildSessionConfigPayload(opts: {
  * byte-identical to a launch before profiles existed). Two independent overlays:
  *   - the context profile (`buildSessionConfig`): `off` → `CONTEXT_RUNTIME_ENABLED: "false"`,
  *     `aggressive` → the three fold-tuning keys, `balanced` → nothing;
+ *   - `compactionIntercept: true` → `GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT`
+ *     `"on"` (the `compaction_intercept` setting);
  *   - `contextHandoff: true` → `CONTEXT_HANDOFF_ENABLED: "true"` (the `context_handoff`
  *     setting) — the SAME header the `handoff` MCP tool's own call to
  *     `/mnemom/context/handoff` must also send, since the gateway resolves the flag
@@ -493,6 +525,7 @@ export declare function buildSessionConfigPayload(opts: {
 export declare function buildSessionConfigB64(opts: {
     profile: ContextProfile;
     contextHandoff: boolean;
+    compactionIntercept?: boolean;
     experimental?: readonly string[];
 }): string | undefined;
 /**
@@ -507,6 +540,17 @@ export declare function resolveContextHandoff(opts: {
     contextHandoff?: boolean;
     env?: NodeJS.ProcessEnv;
 }): boolean;
+/**
+ * Is the compaction intercept (`GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT` in the
+ * session-config header) ON for this launch? OFF by default, same shape as
+ * `resolveContextHandoff`: an explicit `--compaction-intercept` / `--no-compaction-intercept`
+ * wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which `applyConfigToEnv` sets from the
+ * `compaction_intercept` config key), else OFF.
+ */
+export declare function resolveCompactionIntercept(opts: {
+    compactionIntercept?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
 /** The name the `handoff` MCP tool server is registered under in `--mcp-config`. */
 export declare const HANDOFF_MCP_SERVER_NAME = "mnemom-handoff";
 /**

package/dist/lib/agent.js

@@ -301,15 +301,6 @@ export function resolveWindowModel(input) {
         return { model: explicit, reason: "unsupported" };
     return { model: `${base}${ONE_M_SUFFIX}`, reason: "one-m", from: base };
 }
-/**
- * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class`,
- * `x-claude-code-agent-type`, `x-claude-code-prompt-id`). CC sends them to api.anthropic.com on
- * its own, so a Remote Control launch (rc-proxy in front of api.anthropic.com) already carries
- * them; with `ANTHROPIC_BASE_URL` pointing at the gateway door (the terminal shape) CC sends them
- * only when this is "1". The gateway reads them to keep away summaries, titles, compaction and
- * teammates off the main implicit goal.
- */
-export const GATEWAY_HINT_HEADERS_ENV = "CLAUDE_CODE_GATEWAY_HINT_HEADERS";
 /** The session display name: "<agent>-<scenario>" (sanitised), else the agent slug. */
 export function sessionDisplayName(agent, scenario) {
     return sanitizeAgentName(`${agent}-${scenario}`) || agent;
@@ -489,6 +480,50 @@ 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"`, ONLY when the setting is on (see `resolveCompactionIntercept`).
+ */
+export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
+export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
+/**
+ * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class: main |
+ * compaction`, `x-claude-code-compaction: auto | manual | reactive`,
+ * `x-claude-code-context-compacted` on the next turn, `x-claude-code-prompt-id`). Off by default
+ * in the client; the launcher turns it on for EVERY launch shape (terminal, `-p` passthrough,
+ * Remote Control interactive and server) so the gateway gets an exact compaction signal instead
+ * of relying on the body rule alone. Headers only — no behaviour change in the client. The
+ * gateway also reads them to keep summaries, titles, compaction and teammates off the main
+ * implicit goal.
+ */
+export const GATEWAY_HINT_HEADERS_ENV = "CLAUDE_CODE_GATEWAY_HINT_HEADERS";
+/**
+ * Claude Code's own auto-compaction knobs (env). The launcher NEVER sets, changes or strips
+ * them: whatever the user configured is what the client honours (the `autoCompactWindow`
+ * settings.json key is likewise never touched — the launcher writes no settings file).
+ */
+export const USER_AUTOCOMPACT_ENV = [
+    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE",
+    "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
+];
+/**
+ * Turn Claude Code's gateway hint headers on in a child env, unless the user already set
+ * `CLAUDE_CODE_GATEWAY_HINT_HEADERS` themselves (any non-blank value, `0` included, wins).
+ * Mutates and returns `childEnv`. Touches no other key.
+ */
+export function applyGatewayHintHeaders(childEnv) {
+    if ((childEnv[GATEWAY_HINT_HEADERS_ENV] ?? "").trim() === "") {
+        childEnv[GATEWAY_HINT_HEADERS_ENV] = "1";
+    }
+    return childEnv;
+}
 const SEALED_ONLY_FLAGS = "--goal/--requirement/--allow/--forbid/--goal-id";
 /**
  * `--implicit` and a sealed contract are mutually exclusive: on the gateway a
@@ -732,8 +767,9 @@ export function resolveContextProfile(opts) {
  * The decoded per-session env overlay for this launch — the `config` object of the
  * `x-mnemom-session-config` payload, in wire order: the profile's keys first
  * (`CONTEXT_RUNTIME_ENABLED` for `off`; the three fold-tuning keys for `aggressive`; nothing
- * for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON. Empty
- * for `balanced` with handoff off — the common case, where no header is sent at all.
+ * for `balanced`), then `CONTEXT_HANDOFF_ENABLED: "true"` when context handoff is ON, then
+ * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` when the compaction
+ * intercept is ON. Empty for `balanced` with both 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) {
@@ -742,6 +778,10 @@ export function buildSessionConfig(opts) {
         config[k] = v;
     if (opts.contextHandoff)
         config[CONTEXT_HANDOFF_KEY] = "true";
+    if (opts.compactionIntercept) {
+        config[USAGE_REAL_SIZE_KEY] = "on";
+        config[COMPACTION_INTERCEPT_KEY] = "on";
+    }
     return config;
 }
 /**
@@ -764,6 +804,8 @@ export function buildSessionConfigPayload(opts) {
  * byte-identical to a launch before profiles existed). Two independent overlays:
  *   - the context profile (`buildSessionConfig`): `off` → `CONTEXT_RUNTIME_ENABLED: "false"`,
  *     `aggressive` → the three fold-tuning keys, `balanced` → nothing;
+ *   - `compactionIntercept: true` → `GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT`
+ *     `"on"` (the `compaction_intercept` setting);
  *   - `contextHandoff: true` → `CONTEXT_HANDOFF_ENABLED: "true"` (the `context_handoff`
  *     setting) — the SAME header the `handoff` MCP tool's own call to
  *     `/mnemom/context/handoff` must also send, since the gateway resolves the flag
@@ -792,6 +834,21 @@ export function resolveContextHandoff(opts) {
         return false;
     return raw === "1" || raw === "true" || raw === "on" || raw === "yes";
 }
+/**
+ * Is the compaction intercept (`GATEWAY_USAGE_REAL_SIZE` + `GATEWAY_COMPACTION_INTERCEPT` in the
+ * session-config header) ON for this launch? OFF by default, same shape as
+ * `resolveContextHandoff`: an explicit `--compaction-intercept` / `--no-compaction-intercept`
+ * wins, else `MNEMOM_AGENT_COMPACTION_INTERCEPT` (which `applyConfigToEnv` sets from the
+ * `compaction_intercept` config key), else OFF.
+ */
+export function resolveCompactionIntercept(opts) {
+    if (opts.compactionIntercept !== undefined)
+        return opts.compactionIntercept;
+    const raw = (opts.env?.MNEMOM_AGENT_COMPACTION_INTERCEPT ?? "").trim().toLowerCase();
+    if (raw === "")
+        return false;
+    return raw === "1" || raw === "true" || raw === "on" || raw === "yes";
+}
 /** The name the `handoff` MCP tool server is registered under in `--mcp-config`. */
 export const HANDOFF_MCP_SERVER_NAME = "mnemom-handoff";
 /**

package/dist/lib/experimental.d.ts

@@ -12,7 +12,7 @@
  * Everything here is pure or dependency-injected; index.ts and the command
  * modules are the thin drivers.
  */
-export type ExperimentalId = "context-handoff" | "slack" | "implicit";
+export type ExperimentalId = "context-handoff" | "slack" | "implicit" | "compaction-intercept";
 export interface ExperimentalFeature {
     id: ExperimentalId;
     summary: string;
@@ -73,7 +73,8 @@ export declare function assertEnabled(uses: ReadonlyArray<{
 export declare function experimentalIdForConfigKey(key: string, value: string): ExperimentalId | undefined;
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`) and MNEMOM_AGENT_CONTEXT_HANDOFF.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT.
  */
 export declare function ignoredSettingLines(opts: {
     entries: ReadonlyArray<[string, string]>;

package/dist/lib/experimental.js

@@ -46,6 +46,17 @@ export const EXPERIMENTAL_FEATURES = [
             env: [],
         },
     },
+    {
+        id: "compaction-intercept",
+        summary: "Have the gateway report the real context size (so Claude Code compacts at its own threshold) and answer the compaction at once from its fold",
+        since: "0.17.4",
+        gates: {
+            flags: ["--compaction-intercept"],
+            configKeys: ["compaction_intercept"],
+            commands: [],
+            env: ["MNEMOM_AGENT_COMPACTION_INTERCEPT"],
+        },
+    },
 ];
 export const EXPERIMENTAL_IDS = EXPERIMENTAL_FEATURES.map((f) => f.id);
 export const EXPERIMENTAL_ENV = "MNEMOM_EXPERIMENTAL";
@@ -127,19 +138,22 @@ export function experimentalIdForConfigKey(key, value) {
             return value === "true" ? "slack" : undefined;
         case "context_handoff":
             return value === "true" ? "context-handoff" : undefined;
+        case "compaction_intercept":
+            return value === "true" ? "compaction-intercept" : undefined;
         case "goal_mode":
             return value === "implicit" ? "implicit" : undefined;
         default:
             return undefined;
     }
 }
-/** Is an env value one of the truthy spellings resolveContextHandoff accepts? */
+/** Is an env value one of the truthy spellings resolveContextHandoff / resolveCompactionIntercept accept? */
 function truthy(raw) {
     return ["1", "true", "on", "yes"].includes((raw ?? "").trim().toLowerCase());
 }
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`) and MNEMOM_AGENT_CONTEXT_HANDOFF.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT.
  */
 export function ignoredSettingLines(opts) {
     const lines = [];
@@ -152,6 +166,10 @@ export function ignoredSettingLines(opts) {
     if (truthy(opts.env.MNEMOM_AGENT_CONTEXT_HANDOFF) && !opts.enabled.includes("context-handoff")) {
         lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_CONTEXT_HANDOFF", "context-handoff")}`);
     }
+    if (truthy(opts.env.MNEMOM_AGENT_COMPACTION_INTERCEPT) &&
+        !opts.enabled.includes("compaction-intercept")) {
+        lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_COMPACTION_INTERCEPT", "compaction-intercept")}`);
+    }
     return lines;
 }
 /** The features an existing launcher.toml already uses (the one-time migration). */
@@ -199,6 +217,8 @@ export function configKeyFeature(key) {
         return "slack";
     if (key === "context_handoff")
         return "context-handoff";
+    if (key === "compaction_intercept")
+        return "compaction-intercept";
     if (key === "goal_mode")
         return "implicit";
     return undefined;

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

@@ -49,6 +49,12 @@ export interface LauncherConfig {
      * every launch. Off means byte-identical to a launch with no MNE-7564 change at all.
      */
     contextHandoff?: boolean;
+    /**
+     * Compaction-intercept default (EXPERIMENTAL, off when unset): `true` sends
+     * `GATEWAY_USAGE_REAL_SIZE: "on"` + `GATEWAY_COMPACTION_INTERCEPT: "on"` in the per-session
+     * config header for every launch. Off means no header key at all.
+     */
+    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`
@@ -107,6 +113,6 @@ export declare function launcherEntries(cfg: LauncherConfig): Array<[string, str
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * off, `compaction_intercept` while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
  */
 export declare function withoutDisabledExperimental(cfg: LauncherConfig, enabled: readonly ExperimentalId[]): LauncherConfig;

package/dist/lib/launcher-config.js

@@ -197,6 +197,14 @@ export const CONFIG_KEYS = [
             c.contextHandoff = coerceBool("context_handoff", v);
         },
     },
+    {
+        key: "compaction_intercept",
+        describe: "EXPERIMENTAL: tell the gateway GATEWAY_USAGE_REAL_SIZE=on + GATEWAY_COMPACTION_INTERCEPT=on (off by default)",
+        get: (c) => c.compactionIntercept,
+        set: (c, v) => {
+            c.compactionIntercept = coerceBool("compaction_intercept", v);
+        },
+    },
     {
         key: "context_profile",
         describe: `How the gateway folds each session's context (${CONTEXT_PROFILES.join("|")}; balanced by default)`,
@@ -285,6 +293,8 @@ export function parseLauncherConfig(text) {
         cfg.slackChannel = coerceNonEmpty("slack_channel", str(raw.slack_channel) ?? "");
     if (raw.context_handoff !== undefined)
         cfg.contextHandoff = coerceBool("context_handoff", str(raw.context_handoff) ?? "");
+    if (raw.compaction_intercept !== undefined)
+        cfg.compactionIntercept = coerceBool("compaction_intercept", str(raw.compaction_intercept) ?? "");
     if (raw.context_profile !== undefined)
         cfg.contextProfile = parseContextProfile(str(raw.context_profile) ?? "", "context_profile");
     const g = raw.guardrails;
@@ -357,6 +367,8 @@ export function serializeLauncherConfig(cfg) {
         doc.slack_allow = cfg.slackAllow;
     if (cfg.contextHandoff !== undefined)
         doc.context_handoff = cfg.contextHandoff;
+    if (cfg.compactionIntercept !== undefined)
+        doc.compaction_intercept = cfg.compactionIntercept;
     if (cfg.contextProfile !== undefined)
         doc.context_profile = cfg.contextProfile;
     const g = cfg.guardrails;
@@ -414,6 +426,10 @@ export function applyConfigToEnv(cfg, env = process.env) {
     if (cfg.contextHandoff !== undefined && !(env.MNEMOM_AGENT_CONTEXT_HANDOFF ?? "").trim()) {
         env.MNEMOM_AGENT_CONTEXT_HANDOFF = cfg.contextHandoff ? "1" : "0";
     }
+    if (cfg.compactionIntercept !== undefined &&
+        !(env.MNEMOM_AGENT_COMPACTION_INTERCEPT ?? "").trim()) {
+        env.MNEMOM_AGENT_COMPACTION_INTERCEPT = cfg.compactionIntercept ? "1" : "0";
+    }
     if (cfg.contextProfile !== undefined && !(env.MNEMOM_AGENT_CONTEXT_PROFILE ?? "").trim()) {
         env.MNEMOM_AGENT_CONTEXT_PROFILE = cfg.contextProfile;
     }
@@ -428,7 +444,7 @@ export function launcherEntries(cfg) {
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * off, `compaction_intercept` while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
  */
 export function withoutDisabledExperimental(cfg, enabled) {
     const out = { ...cfg };
@@ -439,6 +455,8 @@ export function withoutDisabledExperimental(cfg, enabled) {
     }
     if (!enabled.includes("context-handoff"))
         delete out.contextHandoff;
+    if (!enabled.includes("compaction-intercept"))
+        delete out.compactionIntercept;
     if (!enabled.includes("implicit") && out.goalMode === "implicit")
         delete out.goalMode;
     return out;

package/dist/lib/served-agent-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Which mnm- agent the gateway serves for (Anthropic key, agent name, gateway).
+ *
+ * The gateway identity is hash(key, name), so the answer for one (key, name, gateway) is stable:
+ * once a launch has asked, later launches reuse it instead of paying for another probe
+ * completion. Entries are keyed by a one-way fingerprint and never hold the key itself (nor the
+ * sha256(key|name) claim proof). `--setup` always re-asks and overwrites.
+ */
+/**
+ * A slow KDF (scrypt), not a fast hash: the fingerprint is derived from a credential and lands on
+ * disk, so recovering the key from it must cost what guessing a password would. Name and
+ * gateway are the salt — the lookup has to be deterministic, and they make each entry unique.
+ */
+export declare function servedFingerprint(anthropicKey: string, slug: string, gateway: string): string;
+/** The cached served id, or null (missing, unreadable, or not an mnm- id). */
+export declare function readServedAgent(dir: string, fingerprint: string): string | null;
+/** Best effort: a failed write only means the next launch asks again. */
+export declare function writeServedAgent(dir: string, fingerprint: string, agentId: string): void;

package/dist/lib/served-agent-cache.js

@@ -0,0 +1,50 @@
+/**
+ * Which mnm- agent the gateway serves for (Anthropic key, agent name, gateway).
+ *
+ * The gateway identity is hash(key, name), so the answer for one (key, name, gateway) is stable:
+ * once a launch has asked, later launches reuse it instead of paying for another probe
+ * completion. Entries are keyed by a one-way fingerprint and never hold the key itself (nor the
+ * sha256(key|name) claim proof). `--setup` always re-asks and overwrites.
+ */
+import { scryptSync } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const FILE = "served-agents.json";
+/**
+ * A slow KDF (scrypt), not a fast hash: the fingerprint is derived from a credential and lands on
+ * disk, so recovering the key from it must cost what guessing a password would. Name and
+ * gateway are the salt — the lookup has to be deterministic, and they make each entry unique.
+ */
+export function servedFingerprint(anthropicKey, slug, gateway) {
+    return scryptSync(anthropicKey, `mnemom-served-agent-v1\n${slug}\n${gateway}`, 32).toString("hex");
+}
+function readAll(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, FILE), "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** The cached served id, or null (missing, unreadable, or not an mnm- id). */
+export function readServedAgent(dir, fingerprint) {
+    const id = readAll(dir)[fingerprint];
+    return typeof id === "string" && /^mnm-/.test(id) ? id : null;
+}
+/** Best effort: a failed write only means the next launch asks again. */
+export function writeServedAgent(dir, fingerprint, agentId) {
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const tmp = path.join(dir, `${FILE}.${process.pid}.tmp`);
+        fs.writeFileSync(tmp, JSON.stringify({ ...readAll(dir), [fingerprint]: agentId }, null, 2), {
+            mode: 0o600,
+        });
+        fs.renameSync(tmp, path.join(dir, FILE));
+    }
+    catch {
+        /* best effort */
+    }
+}

package/package.json

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