@mnemom/mnemom 0.17.29 → 0.17.30

package/dist/commands/agent.d.ts

@@ -88,6 +88,12 @@ export interface AgentOptions {
      * the #2216 intercept/real-size keys for this session only; unset/null sends nothing new.
      */
     compactAt?: number | null;
+    /**
+     * `--allow-autocompact-off` (or MNEMOM_AGENT_ALLOW_AUTOCOMPACT_OFF=1): keep Claude Code's
+     * auto-compaction off when the user turned it off. Default: the launch turns it back on for
+     * this session and says so (lib/autocompact-guard.ts).
+     */
+    allowAutocompactOff?: boolean;
     /** context-hint seed default: commander `--no-context-hint` sets this false. */
     contextHint?: boolean;
     /** Attach the Slack channel server (`--slack`; lib/slack-launch.ts). */

package/dist/commands/agent.js

@@ -32,6 +32,7 @@ import { tmpdir, homedir, hostname } from "node:os";
 import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { MEASURED_ENV, statuslineLaunch } from "../lib/statusline.js";
+import { ALLOW_AUTOCOMPACT_OFF_ENV, dropAutocompactOffEnv, hasOwnSettingsFlag, mergedSettingsArgs, planAutocompactGuard, } from "../lib/autocompact-guard.js";
 import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { createApiKey } from "../lib/api.js";
 import { MNEMOM_KEY_STORE_FIELD, resolveAgentAuth, sayRetiredConsoleNotice, readMnemomKey, resolveSubscriptionMnemomKey, subscriptionChildEnv, subscriptionShape, } from "../lib/subscription-login.js";
@@ -1266,18 +1267,20 @@ function launchTerminal(ctx) {
     // decision alone: a value inherited from an outer `mnemom agent` session never rides along.
     Reflect.deleteProperty(childEnv, MEASURED_ENV);
     if (ctx.cli.name === "claude") {
+        const passthrough = ctx.options.passthrough ?? [];
         const sl = statuslineLaunch({
-            passthrough: ctx.options.passthrough ?? [],
+            passthrough,
             env: childEnv,
             cwd: process.cwd(),
             node: process.execPath,
             bin: join(dirname(fileURLToPath(import.meta.url)), "..", "lib", "statusline-bin.js"),
             measured: ctx.usageSavings,
         });
-        if (sl) {
-            args.push(...sl.args);
+        if (sl)
             Object.assign(childEnv, sl.env);
-        }
+        // Autocompact guard (lib/autocompact-guard.ts): one --settings carries both layers.
+        const guard = applyAutocompactGuard(childEnv, ctx.options, !hasOwnSettingsFlag(passthrough));
+        args.push(...mergedSettingsArgs(guard, sl?.settings ?? null));
     }
     if (ctx.contextHint) {
         seedContextHintFlag(childEnv);
@@ -1547,6 +1550,10 @@ 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;
+    // Autocompact guard (lib/autocompact-guard.ts). The interactive shape gets the --settings layer
+    // below; the headless server only drops the env switches (its sessions are spawned by the server).
+    const rcGuard = ctx.cli.name === "claude" &&
+        applyAutocompactGuard(childEnv, ctx.options, ctx.shape !== "server" && !hasOwnSettingsFlag(passthrough));
     // 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
@@ -1611,6 +1618,8 @@ function spawnRcCli(ctx) {
             pluginDir: ctx.plugin?.dir,
         });
         args = ["--remote-control", rcName, "--name", rcName, ...flagArgs];
+        if (rcGuard)
+            args.push(...mergedSettingsArgs(true, null));
         if (ctx.options.slack)
             args.push(...slackChannelArgs(rcName));
         say(`mnemom agent: remote-control: interactive session in THIS terminal with Remote Control on (session name '${rcName}'); it also appears under Remote Control at claude.ai/code and in the Claude app. Exit the CLI to stop everything.`);
@@ -1804,6 +1813,25 @@ export function pickCcSessionId(passthrough, newId = randomUUID) {
 // ───────────────────────────────────────────────────────────────────────────
 // Context-hint seed (opt-out) — best-effort, never throws
 // ───────────────────────────────────────────────────────────────────────────
+/**
+ * Warn when Claude Code's auto-compaction is off for this launch and, unless the user opted out,
+ * drop its env switches from `childEnv`. Returns true when the caller should add the
+ * `--settings` layer that turns it back on (only when `canPassSettings`).
+ */
+function applyAutocompactGuard(childEnv, options, canPassSettings) {
+    const plan = planAutocompactGuard({
+        env: childEnv,
+        cwd: process.cwd(),
+        allowOff: options.allowAutocompactOff === true || process.env[ALLOW_AUTOCOMPACT_OFF_ENV] === "1",
+        canPassSettings,
+    });
+    if (plan.warning)
+        say(plan.warning);
+    if (!plan.override)
+        return false;
+    dropAutocompactOffEnv(childEnv);
+    return canPassSettings;
+}
 /**
  * Set cachedGrowthBookFeatures.tengu_hazel_osprey = true in the local Claude
  * Code config (${CLAUDE_CONFIG_DIR:-$HOME}/.claude.json) so the client offers the

package/dist/index.js

@@ -180,6 +180,7 @@ const agentCmd = program
     "xhigh",
     "max",
 ]))
+    .option("--allow-autocompact-off", 'Keep Claude Code\'s auto-compact off when you turned it off (DISABLE_AUTO_COMPACT, DISABLE_COMPACT or autoCompactEnabled: false). By default the launch turns it back on for this session and says so: with it off, a long session ends in "Prompt is too long" at the context limit. Also: env MNEMOM_AGENT_ALLOW_AUTOCOMPACT_OFF=1')
     .option("--trim-mcp", "Launch the CLI with no MCP servers (--strict-mcp-config + empty --mcp-config)")
     .option("--invite <token>", "Redeem a Mnemom Agent invitation (pinv_…): unlocks Mnemom Agent for you + credits your starter µ; launches too when a session name is given")
     .option("--setup", "Re-check the served agent and refresh its default cards before launch")
@@ -379,6 +380,7 @@ const agentCmd = program
             model: opts.model ?? cfg.model,
             effort: opts.effort ?? cfg.effort,
             trimMcp: opts.trimMcp,
+            allowAutocompactOff: opts.allowAutocompactOff,
             yolo: opts.yolo,
             contextHint: opts.contextHint,
             plugin: opts.plugin,

package/dist/lib/autocompact-guard.d.ts

@@ -0,0 +1,67 @@
+/** Opt-out env: "1" keeps the user's autocompact-off setting as it is (warning only). */
+export declare const ALLOW_AUTOCOMPACT_OFF_ENV = "MNEMOM_AGENT_ALLOW_AUTOCOMPACT_OFF";
+/** Claude Code's env switches that turn auto-compaction off (DISABLE_COMPACT also /compact). */
+export declare const AUTOCOMPACT_OFF_ENV: readonly ["DISABLE_AUTO_COMPACT", "DISABLE_COMPACT"];
+/** The `--settings` layer that turns it back on. */
+export declare const AUTOCOMPACT_ON_SETTINGS: {
+    readonly autoCompactEnabled: true;
+    readonly env: {
+        readonly DISABLE_AUTO_COMPACT: "0";
+        readonly DISABLE_COMPACT: "0";
+    };
+};
+/** One switch that turns autocompact off, named the way the user would find it. */
+export interface AutocompactOffSwitch {
+    /** e.g. `DISABLE_AUTO_COMPACT=1` or `autoCompactEnabled: false`. */
+    setting: string;
+    /** e.g. `your environment` or a file path. */
+    where: string;
+}
+/**
+ * Claude Code's truthiness for these env values. A settings file's `env` block can hold a JSON
+ * boolean: `true` turns it off and `false` clears an off process env (MEASURED, 2.1.301).
+ */
+export declare function envOn(v: unknown): boolean;
+/**
+ * Every switch that leaves Claude Code's autocompact off for a launch from `cwd`, in the order
+ * Claude Code layers them (later wins): the global config, then the user, project and local
+ * settings files for `autoCompactEnabled`; the process env, then each settings file's `env` block
+ * for the two env switches. Only the switches still in force are returned (a later layer turning
+ * it back on clears an earlier one). Managed (policy) settings are not read — the launcher could
+ * not override them anyway. Never throws.
+ */
+export declare function detectAutocompactOff(o: {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    home?: string;
+}): AutocompactOffSwitch[];
+/** True when the user passed their own `--settings` (a second one would replace ours whole). */
+export declare function hasOwnSettingsFlag(passthrough: readonly string[]): boolean;
+export interface AutocompactGuardPlan {
+    /** What turned it off; empty ⇒ nothing to do, no warning. */
+    switches: AutocompactOffSwitch[];
+    /** True ⇒ the launcher turns it back on for this child (env drop + settings layer). */
+    override: boolean;
+    /** The one warning line to print, or null when nothing is off. */
+    warning: string | null;
+}
+/**
+ * Decide what the launch does about autocompact. `canPassSettings` is false where the launcher
+ * cannot add a `--settings` layer (the user's own `--settings`, the headless RC server); there the
+ * env switches are still dropped, but a settings-file switch can only be warned about.
+ */
+export declare function planAutocompactGuard(o: {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    home?: string;
+    allowOff: boolean;
+    canPassSettings: boolean;
+}): AutocompactGuardPlan;
+/** Drop the env switches from a child env. Mutates and returns it. */
+export declare function dropAutocompactOffEnv(childEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * The child's `--settings` args: our layer merged with the status-bar layer (`extra`), since
+ * Claude Code keeps only the LAST `--settings` it is given (MEASURED, 2.1.301) — two would make
+ * one of them vanish. Empty when there is nothing to pass.
+ */
+export declare function mergedSettingsArgs(guard: boolean, extra: Record<string, unknown> | null): string[];

package/dist/lib/autocompact-guard.js

@@ -0,0 +1,157 @@
+/**
+ * Autocompact guard — Claude Code's own auto-compaction switched off ends a long session in a
+ * lockout: once the context reaches the client's hard block (967k on a 1M window), every turn
+ * fails locally with "Prompt is too long", nothing reaches the gateway, and only a manual
+ * /compact gets the session going again. Reproduced 2026-10-17 through the launcher on the test
+ * cell (Claude Code 2.1.301): with autocompact on, every crossing compacts (the gateway intercepts
+ * it); with DISABLE_AUTO_COMPACT=1 the session locks at 966,753 and the debug file shows no
+ * `autocompact:` line at all.
+ *
+ * At launch the launcher finds every switch that turns it off and, unless the user opts out
+ * (`--allow-autocompact-off` / MNEMOM_AGENT_ALLOW_AUTOCOMPACT_OFF=1), turns it back on for the
+ * child only: the env switches are dropped from the child env and a `--settings` layer sets
+ * `autoCompactEnabled: true` with both env switches `"0"`. Flag settings outrank every settings
+ * file and the global config, and their `env` block outranks the process env (MEASURED against
+ * 2.1.301 for each source below). Nothing on disk is changed.
+ *
+ * Claude Code's gate (2.1.301): `zp(){ if (DISABLE_COMPACT || DISABLE_AUTO_COMPACT) return false;
+ * return settings("autoCompactEnabled", true) }`; the env values count as on when they are
+ * 1/true/yes/on (trimmed, any case).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Opt-out env: "1" keeps the user's autocompact-off setting as it is (warning only). */
+export const ALLOW_AUTOCOMPACT_OFF_ENV = "MNEMOM_AGENT_ALLOW_AUTOCOMPACT_OFF";
+/** Claude Code's env switches that turn auto-compaction off (DISABLE_COMPACT also /compact). */
+export const AUTOCOMPACT_OFF_ENV = ["DISABLE_AUTO_COMPACT", "DISABLE_COMPACT"];
+/** The `--settings` layer that turns it back on. */
+export const AUTOCOMPACT_ON_SETTINGS = {
+    autoCompactEnabled: true,
+    env: { DISABLE_AUTO_COMPACT: "0", DISABLE_COMPACT: "0" },
+};
+/**
+ * Claude Code's truthiness for these env values. A settings file's `env` block can hold a JSON
+ * boolean: `true` turns it off and `false` clears an off process env (MEASURED, 2.1.301).
+ */
+export function envOn(v) {
+    if (v === undefined || v === null)
+        return false;
+    return ["1", "true", "yes", "on"].includes(String(v).trim().toLowerCase());
+}
+function readJsonObject(file) {
+    try {
+        if (!existsSync(file))
+            return null;
+        const d = JSON.parse(readFileSync(file, "utf8"));
+        return d && typeof d === "object" && !Array.isArray(d) ? d : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Every switch that leaves Claude Code's autocompact off for a launch from `cwd`, in the order
+ * Claude Code layers them (later wins): the global config, then the user, project and local
+ * settings files for `autoCompactEnabled`; the process env, then each settings file's `env` block
+ * for the two env switches. Only the switches still in force are returned (a later layer turning
+ * it back on clears an earlier one). Managed (policy) settings are not read — the launcher could
+ * not override them anyway. Never throws.
+ */
+export function detectAutocompactOff(o) {
+    const home = o.home ?? homedir();
+    const configDir = o.env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+    const globalFile = join(o.env.CLAUDE_CONFIG_DIR || home, ".claude.json");
+    const settingsFiles = [
+        join(configDir, "settings.json"),
+        join(o.cwd, ".claude", "settings.json"),
+        join(o.cwd, ".claude", "settings.local.json"),
+    ];
+    // autoCompactEnabled: the global config, then each settings file (a settings value wins).
+    let enabled = null;
+    const global = readJsonObject(globalFile);
+    if (typeof global?.autoCompactEnabled === "boolean") {
+        enabled = { value: global.autoCompactEnabled, where: globalFile };
+    }
+    const settings = settingsFiles.map((f) => ({ file: f, data: readJsonObject(f) }));
+    for (const s of settings) {
+        if (typeof s.data?.autoCompactEnabled === "boolean") {
+            enabled = { value: s.data.autoCompactEnabled, where: s.file };
+        }
+    }
+    const out = [];
+    if (enabled && !enabled.value) {
+        out.push({ setting: "autoCompactEnabled: false", where: enabled.where });
+    }
+    // The env switches: the process env, then each settings file's env block (last one wins).
+    for (const key of AUTOCOMPACT_OFF_ENV) {
+        let last = o.env[key] !== undefined ? { value: o.env[key], where: "your environment" } : null;
+        for (const s of settings) {
+            const env = s.data?.env;
+            if (env && typeof env === "object" && !Array.isArray(env) && key in env) {
+                last = { value: env[key], where: `${s.file} (env)` };
+            }
+        }
+        if (last && envOn(last.value)) {
+            out.push({ setting: `${key}=${String(last.value).trim()}`, where: last.where });
+        }
+    }
+    return out;
+}
+/** True when the user passed their own `--settings` (a second one would replace ours whole). */
+export function hasOwnSettingsFlag(passthrough) {
+    return passthrough.some((a) => a === "--settings" || a.startsWith("--settings="));
+}
+/**
+ * Decide what the launch does about autocompact. `canPassSettings` is false where the launcher
+ * cannot add a `--settings` layer (the user's own `--settings`, the headless RC server); there the
+ * env switches are still dropped, but a settings-file switch can only be warned about.
+ */
+export function planAutocompactGuard(o) {
+    const switches = detectAutocompactOff(o);
+    if (switches.length === 0)
+        return { switches, override: false, warning: null };
+    const named = switches.map((s) => `${s.setting} in ${s.where}`).join("; ");
+    const lead = `mnemom agent: Claude Code auto-compact is off (${named}). On a long session that ends in ` +
+        `"Prompt is too long" at the context limit, with every turn refused until you run /compact.`;
+    if (o.allowOff) {
+        return {
+            switches,
+            override: false,
+            warning: `${lead} Leaving it off (--allow-autocompact-off).`,
+        };
+    }
+    const fromFile = switches.some((s) => !s.where.startsWith("your environment"));
+    if (fromFile && !o.canPassSettings) {
+        return {
+            switches,
+            override: true,
+            warning: `${lead} mnemom could not turn it back on for this launch (your own --settings is in use, ` +
+                `or this is a headless server): set "autoCompactEnabled": true there, or turn Auto-compact on in /config.`,
+        };
+    }
+    return {
+        switches,
+        override: true,
+        warning: `${lead} Turning it back on for this session only (pass --allow-autocompact-off to keep it off).`,
+    };
+}
+/** Drop the env switches from a child env. Mutates and returns it. */
+export function dropAutocompactOffEnv(childEnv) {
+    for (const key of AUTOCOMPACT_OFF_ENV)
+        Reflect.deleteProperty(childEnv, key);
+    return childEnv;
+}
+/**
+ * The child's `--settings` args: our layer merged with the status-bar layer (`extra`), since
+ * Claude Code keeps only the LAST `--settings` it is given (MEASURED, 2.1.301) — two would make
+ * one of them vanish. Empty when there is nothing to pass.
+ */
+export function mergedSettingsArgs(guard, extra) {
+    if (!guard && !extra)
+        return [];
+    return [
+        "--settings",
+        JSON.stringify({ ...(extra ?? {}), ...(guard ? AUTOCOMPACT_ON_SETTINGS : {}) }),
+    ];
+}

package/dist/lib/statusline.d.ts

@@ -128,4 +128,5 @@ export declare function statuslineLaunch(o: {
 }): {
     args: string[];
     env: Record<string, string>;
+    settings: Record<string, unknown>;
 } | null;

package/dist/lib/statusline.js

@@ -339,5 +339,7 @@ export function statuslineLaunch(o) {
     const env = user ? { [INNER_ENV]: user.command } : {};
     if (o.measured)
         env[MEASURED_ENV] = "1";
-    return { args: ["--settings", JSON.stringify({ statusLine })], env };
+    // `settings` is the same layer as `args`, for a caller that merges it with its own (Claude Code
+    // keeps only the last --settings it is given).
+    return { args: ["--settings", JSON.stringify({ statusLine })], env, settings: { statusLine } };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.29",
+  "version": "0.17.30",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {