@mnemom/mnemom 0.17.28 → 0.17.30

package/dist/commands/agent-session.js

@@ -22,7 +22,8 @@
  */
 import { basename } from "node:path";
 import { sanitizeAgentName } from "../lib/agent.js";
-export const NO_SESSION_NAME_MESSAGE = "mnemom agent: a session name is required here (e.g. `mnemom agent onboarding`). " +
+export const NO_SESSION_NAME_MESSAGE = "mnemom agent: a session name is required here: pass it before `--` (e.g. `mnemom agent onboarding`) " +
+    "or as `--name <x>` (also `-n <x>` / `--name=<x>`) after `--` (e.g. `mnemom agent -- --name onboarding -p …`). " +
     "In a terminal, plain `mnemom agent` asks for one.";
 /** Current folder name, sanitised like an agent slug; "session" when that is empty. */
 export function defaultSessionName(cwd = process.cwd()) {

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

@@ -391,7 +391,7 @@ export declare function resolvePreflightedAccount(): Promise<{
  * absent or older, and leaves one at this version or newer as it is. Bump it whenever
  * the content below changes. (`card_version` is the schema date, not this.)
  */
-export declare const CODE_CARD_CONTENT_VERSION = "mnemom-agent-default/2.1.0";
+export declare const CODE_CARD_CONTENT_VERSION = "mnemom-agent-default/2.1.2";
 /**
  * Whether a refresh should replace this card's content with the current default: true when
  * it carries no content_version, or an older (or unparseable) `mnemom-agent-default/` one.
@@ -412,6 +412,7 @@ export interface CardPrincipal {
  * takes a role or org, not personal data. The agent is never its own principal.
  */
 export declare function orgPrincipal(orgId?: string | null): CardPrincipal;
+export declare const IN_PLACE_FLOOR: number[];
 export declare function buildCodeAlignmentCard(agentId: string, modes?: Pick<CardModes, "autonomy" | "integrity" | "allowUnmappedTools">, principal?: CardPrincipal): Record<string, unknown>;
 export declare function buildCodeProtectionCard(agentId: string, mode?: string): Record<string, unknown>;
 export {};

package/dist/commands/agent-setup.js

@@ -903,13 +903,15 @@ export function keptPrincipal(own, opts) {
  *
  * `existing` (a refresh that read the agent's own cards) decides content per card: a card
  * that is missing, carries no content_version, or an older default gets the current default
- * content; a card already at this default or a newer one keeps its own content and only has
- * its modes set. Without `existing` (a new agent, or a refresh a --governance flag decided)
+ * content, except a 2.1.x default, which is brought forward in place (upgradeInPlace) so its
+ * edits survive; a card already at this default or a newer one keeps its own content and only
+ * has its modes set. Without `existing` (a new agent, or a refresh a --governance flag decided)
  * both cards get the current default content.
  */
 async function publishDefaultCards(agentId, modes, opts = {}) {
-    const ownAlign = opts.existing?.align;
-    const ownProt = opts.existing?.prot;
+    // A 2.1.x card is brought forward in place first (upgradeInPlace), so it is then kept.
+    const ownAlign = carryForward(opts.existing?.align, "alignment");
+    const ownProt = carryForward(opts.existing?.prot, "protection");
     const keepAlign = !!ownAlign && !needsContentUpgrade(ownAlign);
     const keepProt = !!ownProt && !needsContentUpgrade(ownProt);
     // A kept card's principal follows the agent's current org (keptPrincipal).
@@ -1215,12 +1217,20 @@ export async function resolvePreflightedAccount() {
  * absent or older, and leaves one at this version or newer as it is. Bump it whenever
  * the content below changes. (`card_version` is the schema date, not this.)
  */
-export const CODE_CARD_CONTENT_VERSION = "mnemom-agent-default/2.1.0";
+export const CODE_CARD_CONTENT_VERSION = "mnemom-agent-default/2.1.2";
 const CONTENT_LINEAGE = "mnemom-agent-default/";
 function parseContentSemver(v) {
     const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v);
     return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
 }
+/** Negative, zero or positive as semver `a` is older than, equal to or newer than `b`. */
+function compareSemver(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return 0;
+}
 /**
  * Whether a refresh should replace this card's content with the current default: true when
  * it carries no content_version, or an older (or unparseable) `mnemom-agent-default/` one.
@@ -1291,6 +1301,114 @@ const CODE_BOUNDED_ACTIONS = [
     "WebFetch",
     "WebSearch",
 ];
+// Cross-session messaging between Claude Code sessions (2.1.1). Mapped to a capability, the
+// lane-lead card's shape: the card names `converse` with its tools, and each tool is bounded
+// as "<tool>: converse" (AAP checks the part before the colon, so the observer agrees).
+const CODE_CONVERSE_TOOLS = ["SendMessage", "ListAgents"];
+// A session's own schedule (2.1.2), e.g. a seat's hourly self-check. Same shape, its own
+// capability: none of these talks to another session, and `scheduling` is the policy engine's
+// catalog name for exactly these four tools.
+const CODE_SCHEDULING_TOOLS = ["CronCreate", "CronDelete", "CronList", "ScheduleWakeup"];
+/**
+ * The capabilities the default maps, each with the version that added it. Every version
+ * since IN_PLACE_FLOOR only ADDED one of these (the capability and its "<tool>: <capability>"
+ * bounded actions), which is what lets upgradeInPlace bring a card forward without replacing
+ * it. A version that changes or removes default content (or changes the protection card)
+ * must raise IN_PLACE_FLOOR to itself, so older cards are replaced whole again.
+ */
+const CODE_CAPABILITIES = [
+    {
+        name: "converse",
+        since: [2, 1, 1],
+        description: "Message and list the other Claude Code sessions",
+        tools: CODE_CONVERSE_TOOLS,
+    },
+    {
+        name: "scheduling",
+        since: [2, 1, 2],
+        description: "Schedule, list and cancel this session's own checks",
+        tools: CODE_SCHEDULING_TOOLS,
+    },
+];
+export const IN_PLACE_FLOOR = [2, 1, 0];
+/**
+ * Whether an AAP action list names `tool`: a case-insensitive exact match, or the part before
+ * ':' of a "name: description" entry. The policy engine's own rule (shared/policy-engine
+ * src/action-list.ts actionListIncludes), mirrored because the CLI's engine dependency is the
+ * published 0.3.0, which predates it.
+ */
+function actionListNames(list, tool) {
+    const target = tool.toLowerCase();
+    return list.some((entry) => {
+        if (typeof entry !== "string")
+            return false;
+        if (entry.toLowerCase() === target)
+            return true;
+        const colon = entry.indexOf(":");
+        return colon > 0 && entry.substring(0, colon).trim().toLowerCase() === target;
+    });
+}
+/**
+ * A stamped default from IN_PLACE_FLOOR up to (not including) this version, brought forward
+ * in place: its own content kept (`mnemom card edit` round-trips the stamp, so it may carry
+ * the customer's edits), plus each capability added since its version, stamped current.
+ * A capability the card already declares is the customer's and is left as it is, with no
+ * bounded actions added for it; a tool the card already names in bounded_actions or
+ * forbidden_actions is not bound again. Null when the card is not such a default (an older
+ * one), or has no autonomy.bounded_actions list to bind into (the api requires one): either
+ * is replaced whole, as before. A forbidden_actions that is not a list of strings may hold a
+ * forbid this cannot read, so it fails closed: no capability is added and nothing is bound;
+ * the card keeps its own content and is restamped. So is a NARROWED card, one whose
+ * bounded_actions no longer names every tool its stamped version's default bounded.
+ *
+ * Called only by carryForward, after needsContentUpgrade: the stamp is then absent,
+ * unparseable, or an older default of this lineage, so only the floor needs checking.
+ */
+function upgradeInPlace(card, kind) {
+    const v = card.content_version;
+    const have = typeof v === "string" ? parseContentSemver(v.slice(CONTENT_LINEAGE.length)) : null;
+    if (!have || compareSemver(have, IN_PLACE_FLOOR) < 0)
+        return null;
+    const upgraded = { ...card, content_version: CODE_CARD_CONTENT_VERSION };
+    if (kind === "protection")
+        return upgraded;
+    const autonomy = card.autonomy;
+    if (!isRecord(autonomy) || !Array.isArray(autonomy.bounded_actions))
+        return null;
+    const forbidden = autonomy.forbidden_actions ?? [];
+    if (!Array.isArray(forbidden) || forbidden.some((entry) => typeof entry !== "string")) {
+        return upgraded;
+    }
+    const bounded = [...autonomy.bounded_actions];
+    // A card cut below its version's default bounded set was narrowed on purpose, so it gains
+    // no grant (0.17.28 would not have touched it either): restamped with its own content.
+    const stampedDefault = [
+        ...CODE_BOUNDED_ACTIONS,
+        ...CODE_CAPABILITIES.filter((cap) => compareSemver(cap.since, have) <= 0).flatMap((cap) => cap.tools),
+    ];
+    if (!stampedDefault.every((tool) => actionListNames(bounded, tool)))
+        return upgraded;
+    const capabilities = isRecord(card.capabilities) ? { ...card.capabilities } : {};
+    for (const cap of CODE_CAPABILITIES) {
+        if (compareSemver(cap.since, have) <= 0 || cap.name in capabilities)
+            continue;
+        capabilities[cap.name] = { description: cap.description, tools: [...cap.tools] };
+        for (const tool of cap.tools) {
+            if (!actionListNames(bounded, tool) && !actionListNames(forbidden, tool)) {
+                bounded.push(`${tool}: ${cap.name}`);
+            }
+        }
+    }
+    upgraded.capabilities = capabilities;
+    upgraded.autonomy = { ...autonomy, bounded_actions: bounded };
+    return upgraded;
+}
+/** An existing card as a refresh decides on it: a 2.1.x default brought forward in place. */
+function carryForward(card, kind) {
+    if (!card || !needsContentUpgrade(card))
+        return card;
+    return upgradeInPlace(card, kind) ?? card;
+}
 export function buildCodeAlignmentCard(agentId, modes = {
     autonomy: "off",
     integrity: "off",
@@ -1339,8 +1457,15 @@ export function buildCodeAlignmentCard(agentId, modes = {
                 },
             },
         },
+        capabilities: Object.fromEntries(CODE_CAPABILITIES.map((cap) => [
+            cap.name,
+            { description: cap.description, tools: [...cap.tools] },
+        ])),
         autonomy: {
-            bounded_actions: [...CODE_BOUNDED_ACTIONS],
+            bounded_actions: [
+                ...CODE_BOUNDED_ACTIONS,
+                ...CODE_CAPABILITIES.flatMap((cap) => cap.tools.map((tool) => `${tool}: ${cap.name}`)),
+            ],
             forbidden_actions: [
                 "force_push",
                 "push_protected_branch",

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";
@@ -45,7 +46,7 @@ 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 { defaultAgentSlug, ensureClaimedServedAgent, ensureSessionAndBalance, isQuietPreambleExit, readComposedProtection, resolveDefaultSlug, resolvePinnedAgent, resolvePreflightedAccount, } from "./agent-setup.js";
-import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, assertCompactAtCompatible, assertOffProfileCompatible, compactAtWindowWarning, describeCompactAt, launchWindow, resolveCompactAt, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, resolveUsageSavings, HANDOFF_RC_KEY_ENV_NAME, HANDOFF_RC_MNEMOM_KEY_ENV_NAME, malformedAgentIdMessage, parseAgentRef, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, passthroughModel, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, resumeCommand, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, assertCompactAtCompatible, assertOffProfileCompatible, compactAtWindowWarning, describeCompactAt, launchWindow, resolveCompactAt, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, resolveUsageSavings, HANDOFF_RC_KEY_ENV_NAME, HANDOFF_RC_MNEMOM_KEY_ENV_NAME, malformedAgentIdMessage, parseAgentRef, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, passthroughModel, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, liftPassthroughName, passthroughName, sanitizeAgentName, resumeCommand, 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";
 import { appendPluginDirsEnv, applyPluginEnv, pluginEnabled, pluginPlanLine, resolvePluginDir, } from "../lib/claude-plugin.js";
@@ -163,6 +164,9 @@ function windowModelFor(options, cli) {
 }
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export async function agentCommand(scenarioArg, options = {}) {
+    // An unusable name after `--` refuses here, as a rejected launch: the RC path lifts it again
+    // in the proxy-ready timer, where a throw would be an uncaught crash, not a refusal.
+    liftPassthroughName(options.passthrough ?? []);
     // ── session name + goal ── (a bare `mnemom agent` in a terminal asks for the name;
     // goal alignment is resolved upstream: --goal seals a contract, implicit alignment
     // is on by default only while the `implicit` experimental feature is on.
@@ -1263,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);
@@ -1515,18 +1521,10 @@ function launchRemoteControl(ctx) {
 }
 function spawnRcCli(ctx) {
     // Session name for the claude.ai session list: "<agent>-<scenario>", unless
-    // the caller passed their own `--name <x>` after `--` (lifted out here).
-    const rawPassthrough = ctx.options.passthrough ?? [];
-    let rcName = sessionDisplayName(ctx.agent, ctx.scenario);
-    const passthrough = [];
-    for (let i = 0; i < rawPassthrough.length; i++) {
-        if (rawPassthrough[i] === "--name" && i + 1 < rawPassthrough.length) {
-            rcName = rawPassthrough[i + 1];
-            i++; // consume the value
-            continue;
-        }
-        passthrough.push(rawPassthrough[i]);
-    }
+    // the caller passed their own name after `--` (`--name x`, `--name=x`, `-n x`; lifted out here).
+    const lifted = liftPassthroughName(ctx.options.passthrough ?? []);
+    const rcName = lifted.name ?? sessionDisplayName(ctx.agent, ctx.scenario);
+    const passthrough = lifted.rest;
     const scopedOptions = { ...ctx.options, passthrough };
     // Every auth-shaped ANTHROPIC_* var is UNSET so the RC gate sees a first-party
     // OAuth setup; NO_PROXY/HTTP_PROXY unset so api.anthropic.com is not excluded.
@@ -1552,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
@@ -1605,7 +1607,9 @@ function spawnRcCli(ctx) {
     else {
         // Interactive RC in THIS terminal: the CLI's own `--remote-control <name>`
         // startup flag; --model/--effort/--trim-mcp/yolo apply as in a normal launch.
-        // buildCliArgs already includes the (name-stripped) passthrough.
+        // buildCliArgs already includes the (name-stripped) passthrough. `--name` carries the
+        // same name to the session itself, so its cross-session name (what ListAgents and
+        // SendMessage address) is the seat name, not one Claude Code picks.
         const flagArgs = buildCliArgs(scopedOptions, {
             yolo: ctx.yolo,
             allowCliFlags: true,
@@ -1613,7 +1617,9 @@ function spawnRcCli(ctx) {
             handoffMcpConfigPath: ctx.handoffMcpConfigPath,
             pluginDir: ctx.plugin?.dir,
         });
-        args = ["--remote-control", rcName, ...flagArgs];
+        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.`);
@@ -1807,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/commands/wrap.js

@@ -20,6 +20,7 @@ import { mergeAgentConfig } from "../lib/agent-config.js";
 import { askSelect, askInput, isInteractive } from "../lib/prompt.js";
 import { getGatewayUrl } from "../lib/config.js";
 import { fmt } from "../lib/format.js";
+import { OPENAI_WRAP_DEFAULT_MODEL, openaiBirthProbeBody } from "../lib/birth-probe.js";
 const AGENT_HEADER = "x-mnemom-agent";
 const PROVIDERS = {
     anthropic: {
@@ -33,9 +34,7 @@ const PROVIDERS = {
         label: "OpenAI",
         keyEnv: "OPENAI_API_KEY",
         keyHeader: "Authorization",
-        // gpt-6-luna: the successor MNE-8754 ruled for gpt-4o-mini, which OpenAI shuts down
-        // 2027-01-14 (MNE-8755).
-        defaultModel: "gpt-6-luna",
+        defaultModel: OPENAI_WRAP_DEFAULT_MODEL,
         basePath: "/openai",
     },
     gemini: {
@@ -220,14 +219,7 @@ export async function birthThroughGateway(gatewayUrl, provider, agentName, provi
     switch (provider) {
         case "openai":
             url = `${gatewayUrl}${prov.basePath}/v1/chat/completions`;
-            // max_completion_tokens, not max_tokens: gpt-6-luna is a reasoning-profile model and
-            // OpenAI rejects max_tokens for those on Chat Completions (models-registry.ts
-            // REASONING_SUPPORTED_PARAMS). Older chat models accept max_completion_tokens too.
-            body = JSON.stringify({
-                model: prov.defaultModel,
-                max_completion_tokens: 16,
-                messages: [{ role: "user", content: "hello" }],
-            });
+            body = JSON.stringify(openaiBirthProbeBody(prov.defaultModel));
             break;
         case "gemini":
             url = `${gatewayUrl}${prov.basePath}/v1beta/models/${prov.defaultModel}:generateContent`;

package/dist/index.js

@@ -37,7 +37,7 @@ import { applyConfigToEnv, launcherEntries, loadLauncherConfig, withoutDisabledE
 import { loadExperimentalState } from "./lib/cli-config.js";
 import { assertEnabled, EXPERIMENTAL_CONTRACT, gateCheck, ignoredSettingLines, reportCliError, } from "./lib/experimental.js";
 import { experimentalDisableCommand, experimentalEnableCommand, experimentalListCommand, runExperimentalMigration, } from "./commands/experimental.js";
-import { parseCompactAt, parseContextProfile, resolveImplicit, selectLaunchAgent, } from "./lib/agent.js";
+import { parseCompactAt, parseContextProfile, resolveImplicit, selectLaunchAgent, splitSessionArg, } from "./lib/agent.js";
 import { wrapCommand } from "./commands/wrap.js";
 import { onboardCommand } from "./commands/onboard.js";
 import { skillsListCommand, skillsDescribeCommand } from "./commands/skills.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")
@@ -228,8 +229,13 @@ const agentCmd = program
     .option("--no-compaction-intercept", "Turn the compaction intercept off for this launch (it is on by default) — Claude Code's compaction goes to the model as usual. To turn it off for every launch: config key compaction_intercept = false, or env MNEMOM_AGENT_COMPACTION_INTERCEPT=0")
     .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) => {
+    .action(async (sessionArg, passthroughArg, opts) => {
+    let scenario;
+    let passthrough;
     try {
+        // A Claude Code flag after `--` is never the session name, and an unusable or reserved
+        // name given there refuses before any sub-verb runs (splitSessionArg).
+        ({ scenario, passthrough } = splitSessionArg(sessionArg, passthroughArg));
         // `help` is reserved: `mnemom agent help [verb]` prints help and never launches
         // (nor redeems an --invite). Without this, `help` was taken as a session name and
         // the verb passed through to Claude Code as the opening prompt.
@@ -374,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/agent.d.ts

@@ -322,8 +322,37 @@ export declare function resumeCommand(ctx: {
 }): string;
 /** 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). */
+/**
+ * A caller's own session name in the Claude Code args after `--`, in each spelling Claude Code
+ * takes (`--name <x>`, `--name=<x>`, `-n <x>`; the last one wins), and the args without them.
+ * Throws when a name is given but unusable: no value, a flag as its value (`--name -p x` would
+ * take `-p` and drop headless mode), or a name with no letters or digits (blank, `!!!`), which
+ * would share its Slack state files with every other such name (normSession is empty).
+ */
+export declare function liftPassthroughName(passthrough: readonly string[]): {
+    name: string | undefined;
+    rest: string[];
+};
+/** A caller's own session name in the passthrough args, if any (liftPassthroughName). */
 export declare function passthroughName(passthrough: readonly string[]): string | undefined;
+/**
+ * The words `mnemom agent [session]` routes to a sub-verb (or a commander subcommand), so a
+ * session can never take one through `--name`: `-- --name setup -p x` would run provisioning.
+ */
+export declare const AGENT_SUB_VERBS: ReadonlySet<string>;
+/**
+ * The session name and Claude Code args of `mnemom agent [session] [passthrough...]`, with a
+ * flag commander took as the session put back. Commander fills `[session]` with the first
+ * operand even after `--`, so `mnemom agent -- --name x -p` arrived as session "--name" and
+ * passthrough `x -p` (probe P8). A leading-dash session can only have come from after `--`
+ * (before it, commander parses a flag as an option), so it returns to the front of the
+ * passthrough; with no session left, a passthrough `--name <x>` names it. Throws on an
+ * unusable name (liftPassthroughName) or a sub-verb word (AGENT_SUB_VERBS).
+ */
+export declare function splitSessionArg(session: string | undefined, passthrough: readonly string[]): {
+    scenario: string | undefined;
+    passthrough: string[];
+};
 /** A single-line, header-safe conversation id: honour a caller value, else a uuid. */
 export declare function resolveConversationId(raw: string | undefined): string;
 /** A strictly-positive integer (rejects 0, negatives, decimals, NaN, non-numeric strings). */

package/dist/lib/agent.js

@@ -23,6 +23,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getGatewayUrl } from "./config.js";
+import { normSession } from "./slack-route.js";
 /** The us-2/prod gateway host. The default door — never any other cell silently. */
 export const PROD_GATEWAY_HOST = "https://gateway.mnemom.ai";
 /**
@@ -384,14 +385,80 @@ export function resumeCommand(ctx) {
 export function sessionDisplayName(agent, scenario) {
     return sanitizeAgentName(`${agent}-${scenario}`) || agent;
 }
-/** A caller's own `--name <x>` in the passthrough args, if any (last one wins). */
-export function passthroughName(passthrough) {
+/**
+ * A caller's own session name in the Claude Code args after `--`, in each spelling Claude Code
+ * takes (`--name <x>`, `--name=<x>`, `-n <x>`; the last one wins), and the args without them.
+ * Throws when a name is given but unusable: no value, a flag as its value (`--name -p x` would
+ * take `-p` and drop headless mode), or a name with no letters or digits (blank, `!!!`), which
+ * would share its Slack state files with every other such name (normSession is empty).
+ */
+export function liftPassthroughName(passthrough) {
     let name;
-    for (let i = 0; i < passthrough.length - 1; i++) {
-        if (passthrough[i] === "--name")
-            name = passthrough[i + 1];
+    const rest = [];
+    for (let i = 0; i < passthrough.length; i++) {
+        const arg = passthrough[i];
+        if (arg.startsWith("--name=")) {
+            name = arg.slice("--name=".length);
+        }
+        else if (arg === "--name" || arg === "-n") {
+            const value = passthrough[i + 1];
+            if (value === undefined || value.startsWith("-")) {
+                throw new Error(`mnemom agent: ${arg} needs a session name after it (e.g. \`${arg} onboarding\`), not ${value === undefined ? "nothing" : `the flag \`${value}\``}.`);
+            }
+            name = value;
+            i++;
+        }
+        else {
+            rest.push(arg);
+            continue;
+        }
+        if (!normSession(name)) {
+            throw new Error(`mnemom agent: '${name}' is not a usable session name: give it a letter or a digit.`);
+        }
+    }
+    return { name, rest };
+}
+/** A caller's own session name in the passthrough args, if any (liftPassthroughName). */
+export function passthroughName(passthrough) {
+    return liftPassthroughName(passthrough).name;
+}
+/**
+ * The words `mnemom agent [session]` routes to a sub-verb (or a commander subcommand), so a
+ * session can never take one through `--name`: `-- --name setup -p x` would run provisioning.
+ */
+export const AGENT_SUB_VERBS = new Set([
+    "help",
+    "invite",
+    "config",
+    "slack",
+    "doctor",
+    "setup",
+    "list",
+    "claim",
+    "move",
+    "export",
+    "sessions",
+    "show",
+    "goal",
+]);
+/**
+ * The session name and Claude Code args of `mnemom agent [session] [passthrough...]`, with a
+ * flag commander took as the session put back. Commander fills `[session]` with the first
+ * operand even after `--`, so `mnemom agent -- --name x -p` arrived as session "--name" and
+ * passthrough `x -p` (probe P8). A leading-dash session can only have come from after `--`
+ * (before it, commander parses a flag as an option), so it returns to the front of the
+ * passthrough; with no session left, a passthrough `--name <x>` names it. Throws on an
+ * unusable name (liftPassthroughName) or a sub-verb word (AGENT_SUB_VERBS).
+ */
+export function splitSessionArg(session, passthrough) {
+    if (!session?.startsWith("-"))
+        return { scenario: session, passthrough: [...passthrough] };
+    const args = [session, ...passthrough];
+    const scenario = passthroughName(args);
+    if (scenario !== undefined && AGENT_SUB_VERBS.has(scenario.trim().toLowerCase())) {
+        throw new Error(`mnemom agent: '${scenario}' is a \`mnemom agent\` sub-verb, not a session name; pass another --name.`);
     }
-    return name;
+    return { scenario, passthrough: args };
 }
 /** A single-line, header-safe conversation id: honour a caller value, else a uuid. */
 export function resolveConversationId(raw) {

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/birth-probe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The OpenAI half of `mnemom wrap`'s birth probe, kept free of imports so
+ * `gateway/test/providers-live/openai-live.test.ts` can send these exact bytes
+ * to OpenAI without installing the CLI's dependencies (MNE-8755).
+ */
+export declare const OPENAI_WRAP_DEFAULT_MODEL = "gpt-6-luna";
+/**
+ * Chat Completions body for the one-time birth call. max_completion_tokens, not
+ * max_tokens: gpt-6-luna is a reasoning-profile model and OpenAI rejects max_tokens
+ * for those on Chat Completions (models-registry.ts REASONING_SUPPORTED_PARAMS).
+ * Older chat models accept max_completion_tokens too.
+ */
+export declare function openaiBirthProbeBody(model: string): {
+    model: string;
+    max_completion_tokens: number;
+    messages: {
+        role: "user";
+        content: string;
+    }[];
+};

package/dist/lib/birth-probe.js

@@ -0,0 +1,21 @@
+/**
+ * The OpenAI half of `mnemom wrap`'s birth probe, kept free of imports so
+ * `gateway/test/providers-live/openai-live.test.ts` can send these exact bytes
+ * to OpenAI without installing the CLI's dependencies (MNE-8755).
+ */
+// gpt-6-luna replaces gpt-4o-mini, which OpenAI shuts down 2027-01-14. MNE-8754 ruled the
+// successor; MNE-8755 made the switch.
+export const OPENAI_WRAP_DEFAULT_MODEL = "gpt-6-luna";
+/**
+ * Chat Completions body for the one-time birth call. max_completion_tokens, not
+ * max_tokens: gpt-6-luna is a reasoning-profile model and OpenAI rejects max_tokens
+ * for those on Chat Completions (models-registry.ts REASONING_SUPPORTED_PARAMS).
+ * Older chat models accept max_completion_tokens too.
+ */
+export function openaiBirthProbeBody(model) {
+    return {
+        model,
+        max_completion_tokens: 16,
+        messages: [{ role: "user", content: "hello" }],
+    };
+}

package/dist/lib/config.d.ts

@@ -10,11 +10,17 @@ export declare const MNEMOM_DIR: string;
 export type Environment = "production" | "local";
 /**
  * Thrown for `MNEMOM_ENV=staging`: the value used to be accepted, and the ring
- * it named is gone (MNE-7968). Failing loud is deliberate — the two silent
- * alternatives are both wrong: resolving to the dead staging hostnames makes
- * every call fail with a DNS/connection error that does not say why, and
- * falling through to production would send a caller who asked for a non-prod
- * ring at real customer data.
+ * it named is gone (MNE-7968, retired 2026-10-08 by platform#2446). Failing
+ * loud is deliberate. The two silent alternatives are both wrong: resolving to
+ * the dead staging hostnames makes every call fail with a DNS/connection error
+ * that does not say why, and falling through to production would send a caller
+ * who asked for a non-prod ring at real customer data.
+ *
+ * The message is customer-facing (published CLI), so it names only the public
+ * values. No internal card ids, no internal rings (MNE-8291: the Azure test
+ * cell is not a customer surface), and no link: the staging retirement has no
+ * public changelog entry by ruling (2026-10-16), so the message carries the
+ * facts itself.
  */
 export declare class RetiredEnvironmentError extends Error {
     constructor();

package/dist/lib/config.js

@@ -23,18 +23,22 @@ const WEBSITE_URLS = {
 };
 /**
  * Thrown for `MNEMOM_ENV=staging`: the value used to be accepted, and the ring
- * it named is gone (MNE-7968). Failing loud is deliberate — the two silent
- * alternatives are both wrong: resolving to the dead staging hostnames makes
- * every call fail with a DNS/connection error that does not say why, and
- * falling through to production would send a caller who asked for a non-prod
- * ring at real customer data.
+ * it named is gone (MNE-7968, retired 2026-10-08 by platform#2446). Failing
+ * loud is deliberate. The two silent alternatives are both wrong: resolving to
+ * the dead staging hostnames makes every call fail with a DNS/connection error
+ * that does not say why, and falling through to production would send a caller
+ * who asked for a non-prod ring at real customer data.
+ *
+ * The message is customer-facing (published CLI), so it names only the public
+ * values. No internal card ids, no internal rings (MNE-8291: the Azure test
+ * cell is not a customer surface), and no link: the staging retirement has no
+ * public changelog entry by ruling (2026-10-16), so the message carries the
+ * facts itself.
  */
 export class RetiredEnvironmentError extends Error {
     constructor() {
-        super("MNEMOM_ENV=staging is no longer supported: the staging ring was retired (MNE-7968) " +
-            "and nothing serves api-staging / gateway-staging.mnemom.ai. " +
-            "Use MNEMOM_RING=us-1 for the preview cell, MNEMOM_ENV=local for a local stack, " +
-            "or set MNEMOM_API_URL / MNEMOM_GATEWAY_URL / MNEMOM_WEBSITE_URL to target another cell.");
+        super("MNEMOM_ENV=staging is no longer supported: the staging environment was retired on 2026-10-08. " +
+            "Supported MNEMOM_ENV values are production (the default) and local.");
         this.name = "RetiredEnvironmentError";
     }
 }

package/dist/lib/slack-route.d.ts

@@ -67,7 +67,12 @@ export interface PostRecord {
  */
 export type ThreadIndex = Map<string, Map<string, Map<string, string | undefined>>>;
 export declare function buildThreadIndex(posts: Iterable<PostRecord>): ThreadIndex;
-/** Normalise a session name for comparison (same shape the launcher emits). */
+/**
+ * Normalise a session name for comparison (same shape the launcher emits): the
+ * lowercase alphanumeric runs joined by single dashes. Matching the runs is one
+ * linear pass, with no trim regex (`/-+$/` backtracks quadratically on a run of
+ * dashes).
+ */
 export declare function normSession(raw: string): string;
 /**
  * The live session `name` addresses: an exact (normalised) match, else the ONE live

package/dist/lib/slack-route.js

@@ -54,12 +54,14 @@ export function buildThreadIndex(posts) {
     }
     return idx;
 }
-/** Normalise a session name for comparison (same shape the launcher emits). */
+/**
+ * Normalise a session name for comparison (same shape the launcher emits): the
+ * lowercase alphanumeric runs joined by single dashes. Matching the runs is one
+ * linear pass, with no trim regex (`/-+$/` backtracks quadratically on a run of
+ * dashes).
+ */
 export function normSession(raw) {
-    return raw
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
+    return (raw.toLowerCase().match(/[a-z0-9]+/g) ?? []).join("-");
 }
 const HANDLE_RE = /(?:^|[\s(])@([a-z0-9][a-z0-9-]*[a-z0-9])(?=$|[\s,.:;!?)])/gi;
 /**

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.28",
+  "version": "0.17.30",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {