@mnemom/mnemom 0.17.5 → 0.17.6-next.1

package/dist/lib/agent.js

@@ -489,10 +489,175 @@ export const CONTEXT_HANDOFF_KEY = "CONTEXT_HANDOFF_ENABLED";
  *     `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`).
+ * Sent together, value `"on"`, when the `compaction_intercept` setting is on
+ * (`resolveCompactionIntercept`) OR when `--compact-at` arms a target below 1M (below) — a
+ * target cannot be honored without both.
  */
 export const USAGE_REAL_SIZE_KEY = "GATEWAY_USAGE_REAL_SIZE";
 export const COMPACTION_INTERCEPT_KEY = "GATEWAY_COMPACTION_INTERCEPT";
+// ---------------------------------------------------------------------------
+// Compaction target (`--compact-at`, launcher.toml `compact_at`, MNEMOM_COMPACT_AT)
+// ---------------------------------------------------------------------------
+//
+// Lets an operator play with WHEN the gateway pulls this session's own client-visible
+// compaction point forward (GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS, #2251), instead of
+// leaving Claude Code to compact on its own 1M-window schedule. Unset / `1m` / `off` all
+// mean the SAME thing — no target — so a launch with nothing else configured sends no new
+// header keys at all and behaves exactly as it did before this setting existed: Claude
+// Code's own 1M window, no gateway-triggered compaction. A value strictly below 1,000,000
+// arms the compaction intercept (USAGE_REAL_SIZE_KEY + COMPACTION_INTERCEPT_KEY, above — the
+// same two keys `--compaction-intercept` arms, #2216, both required for the upload pull to be
+// honored instead of silently inert) plus the target itself. Refold (GATEWAY_COMPACTION_REFOLD)
+// is a SEPARATE, costlier opt-in (+9.5pts measured) — this setting never touches it. This never
+// sets a Claude Code autocompact env/window: Claude Code's own compaction math is untouched;
+// only what the GATEWAY reports back changes.
+export const GATEWAY_COMPACTION_UPLOAD_TARGET_KEY = "GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS";
+/** The lowest token count `--compact-at` / `compact_at` / `MNEMOM_COMPACT_AT` will accept. */
+export const COMPACT_AT_MIN_TOKENS = 50_000;
+/**
+ * The parser's ceiling (exclusive): the largest window Claude Code runs. It is NOT where a target
+ * stops working — the gateway ignores a target at or above the compaction point of the window
+ * the session actually runs on (COMPACT_AT_TRIGGER_1M / COMPACT_AT_TRIGGER_200K, below), which
+ * `compactAtWindowWarning` tells the user about at launch.
+ */
+export const COMPACT_AT_MAX_TOKENS = 1_000_000;
+/**
+ * Claude Code's own compaction point on a 1M and on a 200k window — the gateway's
+ * `ALIGN_T_1M` / `ALIGN_T_200K` (gateway/src/compaction-align.ts). The gateway honours an upload
+ * target only BELOW the point of the window the request runs on (`target_over_threshold`
+ * otherwise), and says nothing back to the client when it ignores one.
+ */
+export const COMPACT_AT_TRIGGER_1M = 967_000;
+export const COMPACT_AT_TRIGGER_200K = 167_000;
+/**
+ * `resolveWindowModel`'s answer as a window. `one-m` and a model already suffixed `[1m]` are
+ * 1M; the `CLAUDE_CODE_DISABLE_1M_CONTEXT` opt-out and a model with no 1M window are 200k (the
+ * request then carries no 1M beta, so the gateway uses its 200k point too). A passthrough
+ * `-- --model`, a resume, Claude Code's own default, any other suffix, and a non-Claude-Code CLI
+ * (`null`) are unknown.
+ */
+export function launchWindow(win) {
+    if (win === null)
+        return "unknown";
+    switch (win.reason) {
+        case "one-m":
+            return "1m";
+        case "suffixed":
+            return /\[1m\]\s*$/i.test(win.model ?? "") ? "1m" : "unknown";
+        case "opt-out":
+        case "unsupported":
+            return "200k";
+        default:
+            return "unknown";
+    }
+}
+/**
+ * The launch warning for a target the gateway will (or may) ignore because it is at or above
+ * the compaction point of the window this launch runs on; `null` when the target can take
+ * effect (or there is no target). On an unknown window a target in `[167k, 967k)` works only
+ * if the session lands on a 1M window, so the line says so instead of staying silent.
+ */
+export function compactAtWindowWarning(compactAt, window) {
+    if (compactAt === null)
+        return null;
+    const at = formatTokenCount(compactAt);
+    const t1m = formatTokenCount(COMPACT_AT_TRIGGER_1M);
+    const t200k = formatTokenCount(COMPACT_AT_TRIGGER_200K);
+    if (compactAt >= COMPACT_AT_TRIGGER_1M ||
+        (window === "200k" && compactAt >= COMPACT_AT_TRIGGER_200K)) {
+        const [w, t] = window === "200k" ? ["200k", t200k] : window === "1m" ? ["1M", t1m] : ["any", t1m];
+        return (`mnemom agent: warning: compaction target ${at} is at or above Claude Code's own compaction ` +
+            `point on ${w === "any" ? "any" : `this launch's ${w}`} window (${t}), so the gateway will ignore it. ` +
+            `Pick a value below ${t}.`);
+    }
+    if (window === "unknown" && compactAt >= COMPACT_AT_TRIGGER_200K) {
+        return (`mnemom agent: note: compaction target ${at} takes effect only on a 1M window (below ${t1m}); ` +
+            `if this session runs on a 200k window, the gateway's point is ${t200k} and it ignores the target.`);
+    }
+    return null;
+}
+/**
+ * Parse a `--compact-at` / `compact_at` / `MNEMOM_COMPACT_AT` value. `source` names the
+ * surface in the error so a customer knows which setting to fix (same convention as
+ * `parseContextProfile`).
+ *
+ *   - "" (unset), "1m", "off" (trimmed, case-insensitive) → `null`: no gateway target —
+ *     Claude Code runs its normal 1M window and nothing new is sent.
+ *   - a bare integer, or one with a `k`/`m` suffix (`200k` → 200000, `0.5m` → 500000) →
+ *     that many tokens, when it is in `[COMPACT_AT_MIN_TOKENS, COMPACT_AT_MAX_TOKENS)`.
+ *   - anything else, or a number outside that range (use `1m`/`off` for the ceiling and
+ *     above, never a bare `1000000`) → throws with a human-readable message.
+ */
+export function parseCompactAt(raw, source) {
+    const v = raw.trim().toLowerCase();
+    if (v === "" || v === "1m" || v === "off")
+        return null;
+    const m = /^(\d+(?:\.\d+)?)(k|m)?$/.exec(v);
+    if (!m) {
+        throw new Error(`${source} must be a token count (optionally with a k/m suffix), '1m', or 'off' (got '${raw}').`);
+    }
+    const mult = m[2] === "k" ? 1_000 : m[2] === "m" ? 1_000_000 : 1;
+    const tokens = Math.round(Number(m[1]) * mult);
+    if (!Number.isFinite(tokens) ||
+        tokens < COMPACT_AT_MIN_TOKENS ||
+        tokens >= COMPACT_AT_MAX_TOKENS) {
+        throw new Error(`${source} must be between ${COMPACT_AT_MIN_TOKENS} and ${COMPACT_AT_MAX_TOKENS - 1} tokens` +
+            ` (or '1m' / 'off' for no gateway compaction target); got '${raw}'.`);
+    }
+    return tokens;
+}
+/**
+ * Which compaction target this launch runs under. Precedence, highest wins:
+ *   1. `opts.compactAt` — an already-parsed `--compact-at` flag value (`undefined` when the
+ *      flag was not given at all; `null` is a valid, explicit "no target" from `1m`/`off`).
+ *   2. `MNEMOM_COMPACT_AT` (which `applyConfigToEnv` sets from the `compact_at` launcher.toml
+ *      key, UNDER any real env var — so an operator's own env always wins over the file).
+ *   3. `null` — the default: no target, nothing new sent.
+ */
+export function resolveCompactAt(opts) {
+    if (opts.compactAt !== undefined)
+        return opts.compactAt;
+    const raw = (opts.env?.MNEMOM_COMPACT_AT ?? "").trim();
+    if (raw === "")
+        return null;
+    return parseCompactAt(raw, "MNEMOM_COMPACT_AT");
+}
+/**
+ * `--no-compaction-intercept` is a deliberate, documented "keep the intercept off for this
+ * launch no matter what toml/env says" signal. A compaction target needs that SAME intercept
+ * to arm (`buildSessionConfig` ORs them), so pairing an explicit `--no-compaction-intercept`
+ * with an armed `--compact-at` is a contradiction — refuse rather than silently pick a side
+ * (either silently re-arming the intercept the user just turned off, or silently sending an
+ * inert upload-target the gateway can never act on). `compactionIntercept` here is the raw,
+ * pre-`resolveCompactionIntercept` flag value: `false` only when `--no-compaction-intercept`
+ * was explicitly passed (or the experimental gate forced it, which `compactAt` cannot reach
+ * past either — see index.ts's `assertEnabled`), never the mere absence of `--compaction-intercept`.
+ */
+export function assertCompactAtCompatible(opts) {
+    if (opts.compactionIntercept === false && opts.compactAt !== null) {
+        throw new Error("mnemom agent: --compact-at needs the compaction intercept to arm, but it is off for " +
+            "this launch (--no-compaction-intercept, or the compaction-intercept experimental " +
+            "feature is disabled). Drop --no-compaction-intercept (and run `mnemom experimental " +
+            "enable compaction-intercept`), or pass --compact-at off.");
+    }
+}
+/**
+ * `200000` → `"200k"`, anything not k-aligned → the bare digits. Every real caller only ever
+ * passes a `parseCompactAt`-validated value, which is bounded to
+ * `[COMPACT_AT_MIN_TOKENS, COMPACT_AT_MAX_TOKENS)` — i.e. `[50_000, 999_999]` — so there is no
+ * multiple of 1,000,000 to round to an `"Nm"` form; that case is intentionally not handled here.
+ */
+function formatTokenCount(tokens) {
+    if (tokens % 1_000 === 0)
+        return `${tokens / 1_000}k`;
+    return String(tokens);
+}
+/** The launch-banner line for the resolved compaction target (always printed). */
+export function describeCompactAt(compactAt) {
+    return compactAt === null
+        ? "Claude Code default (1M)"
+        : `gateway at ${formatTokenCount(compactAt)}`;
+}
 /**
  * Claude Code's opt-in for its gateway hint headers (`x-claude-code-request-class: main |
  * compaction`, `x-claude-code-compaction: auto | manual | reactive`,
@@ -768,9 +933,11 @@ export function resolveContextProfile(opts) {
  * `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, 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.
+ * `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.
  */
 export function buildSessionConfig(opts) {
     const config = {};
@@ -778,10 +945,17 @@ export function buildSessionConfig(opts) {
         config[k] = v;
     if (opts.contextHandoff)
         config[CONTEXT_HANDOFF_KEY] = "true";
-    if (opts.compactionIntercept) {
+    const hasCompactionTarget = opts.compactAt !== undefined && opts.compactAt !== null;
+    // A target needs the compaction intercept + real-size rewrite to arm (#2216) — without them
+    // the upload-target key is silently inert (compaction-align.ts: "armed only inside the
+    // intercept"). Deliberately NOT GATEWAY_COMPACTION_REFOLD — a separate, costlier opt-in.
+    if (opts.compactionIntercept || hasCompactionTarget) {
         config[USAGE_REAL_SIZE_KEY] = "on";
         config[COMPACTION_INTERCEPT_KEY] = "on";
     }
+    if (hasCompactionTarget) {
+        config[GATEWAY_COMPACTION_UPLOAD_TARGET_KEY] = String(opts.compactAt);
+    }
     return config;
 }
 /**
@@ -800,12 +974,15 @@ 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 handoff off,
- * byte-identical to a launch before profiles existed). Two independent overlays:
+ * nothing to override (the gateway's own defaults stand — `balanced` 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, `balanced` → 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
+ *     `GATEWAY_COMPACTION_UPLOAD_TARGET_TOKENS: "<N>"`; unset, `1m` or `off` → nothing beyond
+ *     what `compactionIntercept` already sent (Claude Code's own 1M window, untouched);
  *   - `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

package/dist/lib/experimental.d.ts

@@ -13,6 +13,15 @@
  * modules are the thin drivers.
  */
 export type ExperimentalId = "context-handoff" | "slack" | "implicit" | "compaction-intercept";
+/**
+ * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
+ * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
+ * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
+ * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
+ * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
+ * admitting a value the real parser would reject anyway.
+ */
+export declare function compactAtArmed(raw: string | undefined): boolean;
 export interface ExperimentalFeature {
     id: ExperimentalId;
     summary: string;
@@ -73,8 +82,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]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
- * MNEMOM_AGENT_COMPACTION_INTERCEPT.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
  */
 export declare function ignoredSettingLines(opts: {
     entries: ReadonlyArray<[string, string]>;

package/dist/lib/experimental.js

@@ -12,6 +12,18 @@
  * Everything here is pure or dependency-injected; index.ts and the command
  * modules are the thin drivers.
  */
+/**
+ * Is a `compact_at` / `MNEMOM_COMPACT_AT` value (trimmed, case-insensitive) an ARMED gateway
+ * target, as opposed to "no target" (`""`, `"1m"`, `"off"`)? Deliberately duplicates
+ * `parseCompactAt`'s no-target spellings rather than importing it, to keep this registry
+ * dependency-free (see the module doc); an unparseable value (bad k/m suffix, out of range)
+ * is treated as armed so the gate errs toward requiring the opt-in rather than toward silently
+ * admitting a value the real parser would reject anyway.
+ */
+export function compactAtArmed(raw) {
+    const v = (raw ?? "").trim().toLowerCase();
+    return v !== "" && v !== "1m" && v !== "off";
+}
 export const EXPERIMENTAL_FEATURES = [
     {
         id: "context-handoff",
@@ -140,6 +152,9 @@ export function experimentalIdForConfigKey(key, value) {
             return value === "true" ? "context-handoff" : undefined;
         case "compaction_intercept":
             return value === "true" ? "compaction-intercept" : undefined;
+        case "compact_at":
+            // Arms the SAME gateway keys compaction_intercept does — same gate.
+            return compactAtArmed(value) ? "compaction-intercept" : undefined;
         case "goal_mode":
             return value === "implicit" ? "implicit" : undefined;
         default:
@@ -152,8 +167,8 @@ function truthy(raw) {
 }
 /**
  * The stderr lines for experimental settings a launch ignores because their feature
- * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF and
- * MNEMOM_AGENT_COMPACTION_INTERCEPT.
+ * is off: launcher.toml keys (`entries` as `[key, value]`), MNEMOM_AGENT_CONTEXT_HANDOFF,
+ * MNEMOM_AGENT_COMPACTION_INTERCEPT and MNEMOM_COMPACT_AT (an armed target only).
  */
 export function ignoredSettingLines(opts) {
     const lines = [];
@@ -170,6 +185,10 @@ export function ignoredSettingLines(opts) {
         !opts.enabled.includes("compaction-intercept")) {
         lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_AGENT_COMPACTION_INTERCEPT", "compaction-intercept")}`);
     }
+    if (compactAtArmed(opts.env.MNEMOM_COMPACT_AT) &&
+        !opts.enabled.includes("compaction-intercept")) {
+        lines.push(`mnemom agent: ignoring ${gatedMessage("MNEMOM_COMPACT_AT", "compaction-intercept")}`);
+    }
     return lines;
 }
 /** The features an existing launcher.toml already uses (the one-time migration). */

package/dist/lib/first-run/backtest.d.ts

@@ -45,6 +45,14 @@ export declare function rowCost(r: Row): number;
 export declare function actualBill(rows: readonly Row[]): number;
 /** An ungoverned request's original context = its billed prompt. */
 export declare function origContext(r: Row): number;
+/**
+ * One transcript line → its billed request, or null (not an assistant record with usage).
+ * `id` is the message id (or record uuid); null when the record carries neither.
+ */
+export declare function parseUsageLine(line: Buffer, subagent: boolean): {
+    id: string | null;
+    row: Row;
+} | null;
 /**
  * Billed requests of one transcript, deduped by message id (last copy wins, first-seen
  * order). With `seen`, an id already billed in an earlier transcript (a resumed / forked

package/dist/lib/first-run/backtest.js

@@ -69,42 +69,37 @@ const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
 const USAGE = Buffer.from('"usage"');
 const ASSISTANT = Buffer.from('"assistant"');
 /**
- * Billed requests of one transcript, deduped by message id (last copy wins, first-seen
- * order). With `seen`, an id already billed in an earlier transcript (a resumed / forked
- * session copies messages) is skipped, so each request is billed once, to its origin.
+ * One transcript line → its billed request, or null (not an assistant record with usage).
+ * `id` is the message id (or record uuid); null when the record carries neither.
  */
-export function loadTranscript(path, seen) {
-    const byId = new Map();
-    const subagent = path.includes("/subagents/");
-    let anon = 0;
-    forEachLine(path, (line) => {
-        if (line.indexOf(USAGE) === -1 || line.indexOf(ASSISTANT) === -1)
-            return;
-        const d = parseJson(line);
-        if (!d || d.type !== "assistant")
-            return;
-        const m = d.message;
-        if (!m || typeof m !== "object")
-            return;
-        const u = m.usage;
-        if (!u || typeof u !== "object")
-            return;
-        const model = typeof m.model === "string" ? m.model : "";
-        if (!model || model.startsWith("<"))
-            return;
-        const t = isoSeconds(d.timestamp);
-        if (t === null)
-            return;
-        const cc = u.cache_creation ?? {};
-        const cw = num(u.cache_creation_input_tokens);
-        const cw1h = num(cc.ephemeral_1h_input_tokens);
-        // Older Claude Code versions omit the 5m split (or the whole cache_creation object):
-        // derive 5m as total − 1h, and never let a reported 5m share leave writes unbilled.
-        const cw5 = Math.max(num(cc.ephemeral_5m_input_tokens), cw - cw1h);
-        const id = (typeof m.id === "string" && m.id) ||
-            (typeof d.uuid === "string" && d.uuid) ||
-            `anon-${path}-${anon++}`;
-        byId.set(id, {
+export function parseUsageLine(line, subagent) {
+    if (line.indexOf(USAGE) === -1 || line.indexOf(ASSISTANT) === -1)
+        return null;
+    const d = parseJson(line);
+    if (!d || d.type !== "assistant")
+        return null;
+    const m = d.message;
+    if (!m || typeof m !== "object")
+        return null;
+    const u = m.usage;
+    if (!u || typeof u !== "object")
+        return null;
+    const model = typeof m.model === "string" ? m.model : "";
+    if (!model || model.startsWith("<"))
+        return null;
+    const t = isoSeconds(d.timestamp);
+    if (t === null)
+        return null;
+    const cc = u.cache_creation ?? {};
+    const cw = num(u.cache_creation_input_tokens);
+    const cw1h = num(cc.ephemeral_1h_input_tokens);
+    // Older Claude Code versions omit the 5m split (or the whole cache_creation object):
+    // derive 5m as total − 1h, and never let a reported 5m share leave writes unbilled.
+    const cw5 = Math.max(num(cc.ephemeral_5m_input_tokens), cw - cw1h);
+    const id = (typeof m.id === "string" && m.id) || (typeof d.uuid === "string" && d.uuid) || null;
+    return {
+        id,
+        row: {
             t,
             model,
             inp: num(u.input_tokens),
@@ -114,7 +109,22 @@ export function loadTranscript(path, seen) {
             out: num(u.output_tokens),
             mainThread: d.isSidechain !== true,
             subagent,
-        });
+        },
+    };
+}
+/**
+ * Billed requests of one transcript, deduped by message id (last copy wins, first-seen
+ * order). With `seen`, an id already billed in an earlier transcript (a resumed / forked
+ * session copies messages) is skipped, so each request is billed once, to its origin.
+ */
+export function loadTranscript(path, seen) {
+    const byId = new Map();
+    const subagent = path.includes("/subagents/");
+    let anon = 0;
+    forEachLine(path, (line) => {
+        const r = parseUsageLine(line, subagent);
+        if (r)
+            byId.set(r.id ?? `anon-${path}-${anon++}`, r.row);
     });
     const out = [];
     for (const [id, row] of byId) {

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

@@ -16,7 +16,7 @@
  * the caller folds the plain-value settings under the CLI flags.
  */
 import { type AgentAuth } from "./subscription-login.js";
-import type { ExperimentalId } from "./experimental.js";
+import { type ExperimentalId } from "./experimental.js";
 import { type ContextProfile, type GoalModeDefault, type LaunchShape } from "./agent.js";
 /** The human-editable settings file. Secret key lives elsewhere (launcher.json). */
 export declare const LAUNCHER_CONFIG_PATH: string;
@@ -61,6 +61,12 @@ export interface LauncherConfig {
      * folds earlier with a tighter working set. `--context-profile` overrides it per launch.
      */
     contextProfile?: ContextProfile;
+    /**
+     * The gateway compaction target (`--compact-at`; unset means no target — Claude Code's own
+     * 1M window, nothing new sent). Stored as the validated raw string (e.g. "200k", "1m",
+     * "off", "350000"), parsed with `parseCompactAt` at the point of use.
+     */
+    compactAt?: string;
     guardrails?: {
         maxTurns?: number;
         budgetUsd?: number;
@@ -113,6 +119,9 @@ export declare function launcherEntries(cfg: LauncherConfig): Array<[string, str
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, `compaction_intercept` while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * off, `compaction_intercept` (and an ARMED `compact_at` — it arms the same two gateway keys,
+ * so it needs the same opt-in; `compact_at = "off"`/`"1m"` carries no gated behaviour and is
+ * kept) while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is
+ * off (`goal_mode = off` is kept).
  */
 export declare function withoutDisabledExperimental(cfg: LauncherConfig, enabled: readonly ExperimentalId[]): LauncherConfig;

package/dist/lib/launcher-config.js

@@ -20,7 +20,8 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { dirname, join } from "node:path";
 import { parse as parseToml, stringify as stringifyToml, TomlError } from "smol-toml";
 import { MNEMOM_DIR } from "./config.js";
-import { CONTEXT_PROFILES, isPositiveInt, isPositiveNumber, parseContextProfile, } from "./agent.js";
+import { compactAtArmed } from "./experimental.js";
+import { CONTEXT_PROFILES, isPositiveInt, isPositiveNumber, parseCompactAt, parseContextProfile, } from "./agent.js";
 /** The human-editable settings file. Secret key lives elsewhere (launcher.json). */
 export const LAUNCHER_CONFIG_PATH = join(MNEMOM_DIR, "launcher.toml");
 const LAUNCH_SHAPES = ["terminal", "remote-control", "server"];
@@ -67,6 +68,13 @@ function coerceNonEmpty(name, raw) {
         throw new Error(`${name} must be a non-empty string.`);
     return v;
 }
+function coerceCompactAt(raw) {
+    const v = raw.trim().toLowerCase();
+    // Validate against the same parser the flag/env use, but keep the human-chosen spelling
+    // ("200k" vs "200000") — resolveCompactAt re-parses it at launch time anyway.
+    parseCompactAt(v, "compact_at");
+    return v;
+}
 function coerceMemberIds(raw) {
     const ids = raw
         .split(/[\s,]+/)
@@ -213,6 +221,14 @@ export const CONFIG_KEYS = [
             c.contextProfile = parseContextProfile(v, "context_profile");
         },
     },
+    {
+        key: "compact_at",
+        describe: "Gateway compaction target: a token count (k/m suffix OK), '1m' or 'off' for none (default: none — Claude Code's own 1M window)",
+        get: (c) => c.compactAt,
+        set: (c, v) => {
+            c.compactAt = coerceCompactAt(v);
+        },
+    },
     {
         key: "guardrails.max_turns",
         describe: "Contract guardrail: turn ceiling (positive integer)",
@@ -297,6 +313,8 @@ export function parseLauncherConfig(text) {
         cfg.compactionIntercept = coerceBool("compaction_intercept", str(raw.compaction_intercept) ?? "");
     if (raw.context_profile !== undefined)
         cfg.contextProfile = parseContextProfile(str(raw.context_profile) ?? "", "context_profile");
+    if (raw.compact_at !== undefined)
+        cfg.compactAt = coerceCompactAt(str(raw.compact_at) ?? "");
     const g = raw.guardrails;
     if (g !== undefined) {
         if (typeof g !== "object" || g === null || Array.isArray(g)) {
@@ -371,6 +389,8 @@ export function serializeLauncherConfig(cfg) {
         doc.compaction_intercept = cfg.compactionIntercept;
     if (cfg.contextProfile !== undefined)
         doc.context_profile = cfg.contextProfile;
+    if (cfg.compactAt !== undefined)
+        doc.compact_at = cfg.compactAt;
     const g = cfg.guardrails;
     if (g && (g.maxTurns !== undefined || g.budgetUsd !== undefined || g.stallTurns !== undefined)) {
         const gr = {};
@@ -433,6 +453,9 @@ export function applyConfigToEnv(cfg, env = process.env) {
     if (cfg.contextProfile !== undefined && !(env.MNEMOM_AGENT_CONTEXT_PROFILE ?? "").trim()) {
         env.MNEMOM_AGENT_CONTEXT_PROFILE = cfg.contextProfile;
     }
+    if (cfg.compactAt !== undefined && !(env.MNEMOM_COMPACT_AT ?? "").trim()) {
+        env.MNEMOM_COMPACT_AT = cfg.compactAt;
+    }
 }
 /** The set keys of `cfg` as `[key, value]` pairs (CONFIG_KEYS order, values stringified). */
 export function launcherEntries(cfg) {
@@ -444,7 +467,10 @@ export function launcherEntries(cfg) {
 /**
  * `cfg` without the settings of experimental features that are off (a copy; `cfg` is
  * untouched): `slack_*` while `slack` is off, `context_handoff` while `context-handoff` is
- * off, `compaction_intercept` while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is off (`goal_mode = off` is kept).
+ * off, `compaction_intercept` (and an ARMED `compact_at` — it arms the same two gateway keys,
+ * so it needs the same opt-in; `compact_at = "off"`/`"1m"` carries no gated behaviour and is
+ * kept) while `compaction-intercept` is off, and `goal_mode = implicit` while `implicit` is
+ * off (`goal_mode = off` is kept).
  */
 export function withoutDisabledExperimental(cfg, enabled) {
     const out = { ...cfg };
@@ -455,8 +481,11 @@ export function withoutDisabledExperimental(cfg, enabled) {
     }
     if (!enabled.includes("context-handoff"))
         delete out.contextHandoff;
-    if (!enabled.includes("compaction-intercept"))
+    if (!enabled.includes("compaction-intercept")) {
         delete out.compactionIntercept;
+        if (compactAtArmed(out.compactAt))
+            delete out.compactAt;
+    }
     if (!enabled.includes("implicit") && out.goalMode === "implicit")
         delete out.goalMode;
     return out;

package/dist/lib/statusline-bin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Entry for the `mnemom agent` status-bar counter (lib/statusline.ts). Claude Code runs it
+ * on every status update, so it imports only the counter — not the whole CLI.
+ */
+export {};

package/dist/lib/statusline-bin.js

@@ -0,0 +1,16 @@
+/**
+ * Entry for the `mnemom agent` status-bar counter (lib/statusline.ts). Claude Code runs it
+ * on every status update, so it imports only the counter — not the whole CLI.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { INNER_ENV, render } from "./statusline.js";
+const chunks = [];
+process.stdin.on("data", (c) => chunks.push(c));
+process.stdin.on("end", () => {
+    const line = render(Buffer.concat(chunks).toString("utf8"), {
+        stateDir: join(homedir(), ".mnemom", "statusline"),
+        inner: process.env[INNER_ENV] || undefined,
+    });
+    process.stdout.write(`${line}\n`);
+});