@mnemom/mnemom 0.17.20-next.0 → 0.17.21

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

@@ -52,6 +52,9 @@ export declare function assertCodeEnabled(orgId: string, orgLabel: string): Prom
 /** Ensures a Mnemom session exists (injected so tests never touch the real login flow). */
 export type EnsureSession = (opts: {
     interactive?: boolean;
+    /** The invitation being redeemed — carried into the browser sign-in so a new
+     *  invitee's sign-up skips the confirmation email. */
+    inviteToken?: string;
 }) => Promise<boolean>;
 /** The accept route's 403 codes (mnemom-api `product-invite-accept.ts`). */
 export declare const INVITE_ACCOUNT_MISMATCH = "invite_account_mismatch";

package/dist/commands/agent-invite.js

@@ -210,7 +210,7 @@ export async function agentInviteCommand(token, opts = {}) {
     }
     const interactive = opts.interactive ?? isInteractive();
     const ensureSession = opts.ensureSession ?? defaultEnsureSession;
-    const haveSession = await ensureSession({ interactive });
+    const haveSession = await ensureSession({ interactive, inviteToken: trimmed });
     if (!haveSession) {
         throw new Error("mnemom agent --invite: redeeming needs a Mnemom account.\n" +
             "  Sign in:   mnemom login\n" +

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

@@ -110,11 +110,13 @@ export declare function formatTrailEntry(e: AgentSessionVerdictTrailEntry): stri
  */
 export declare function verdictTrailKey(e: Pick<AgentSessionVerdictTrailEntry, "request_id" | "turn">): string;
 /**
- * Best-effort "has this session ended" check for `--follow`'s exit condition. No field is locked
- * in on the wire yet: MNE-8149 adds an `expired` seal state on the gateway's row, and a later
- * mnemom-api card is expected to carry it through to this response — so this reads defensively,
- * off either the top-level response or the `sealed` block, and returns null (never throws) when
- * neither carries a recognized value, which is every server today.
+ * Best-effort "has this session ended" check for `--follow`'s exit condition. MNE-8234 wired the
+ * seal lifecycle through on the wire (`remote.seal.state`), so that is read first and is
+ * authoritative: `"expired"` there means the prior seal lapsed and ends the watch. The older
+ * top-level `state` and `remote.sealed.state` fallbacks predate that field actually landing on
+ * the response — neither has ever been observed non-null on any real server — and are kept
+ * defensively in case an even older/non-conformant server ever carries one of them; this never
+ * throws, returning null when nothing recognized is present.
  */
 export declare function sessionEndedState(remote: AgentSessionResponse): "expired" | "ended" | null;
 /** Default and floor for `--follow`'s poll interval. */
@@ -152,6 +154,14 @@ export interface ShowJson {
         guardrails: AgentSessionResponse["guardrails"];
         /** R10 (MNE-8200): oldest first (the gateway's own wire order), unlike the human view. */
         verdict_trail: AgentSessionResponse["verdict_trail"];
+        /**
+         * MNE-8234: the seal's lifecycle (state incl. `expired`, version, mode, hashes). Absent on
+         * an older server; `null` when the API reports no seal.
+         */
+        seal: AgentSessionResponse["seal"];
+        /** MNE-8234 (MNE-8166 R4): judging counts under the current seal. */
+        unjudged_turns: AgentSessionResponse["unjudged_turns"];
+        memoised_turns: AgentSessionResponse["memoised_turns"];
     } | {
         source: "gateway";
         available: false;

package/dist/commands/agent-sessions.js

@@ -190,14 +190,21 @@ export function verdictTrailKey(e) {
     return `${e.request_id ?? ""}#${e.turn}`;
 }
 /**
- * Best-effort "has this session ended" check for `--follow`'s exit condition. No field is locked
- * in on the wire yet: MNE-8149 adds an `expired` seal state on the gateway's row, and a later
- * mnemom-api card is expected to carry it through to this response — so this reads defensively,
- * off either the top-level response or the `sealed` block, and returns null (never throws) when
- * neither carries a recognized value, which is every server today.
+ * Best-effort "has this session ended" check for `--follow`'s exit condition. MNE-8234 wired the
+ * seal lifecycle through on the wire (`remote.seal.state`), so that is read first and is
+ * authoritative: `"expired"` there means the prior seal lapsed and ends the watch. The older
+ * top-level `state` and `remote.sealed.state` fallbacks predate that field actually landing on
+ * the response — neither has ever been observed non-null on any real server — and are kept
+ * defensively in case an even older/non-conformant server ever carries one of them; this never
+ * throws, returning null when nothing recognized is present.
  */
 export function sessionEndedState(remote) {
     const as = (v) => v === "expired" || v === "ended" ? v : null;
+    if (remote.seal) {
+        const sealState = as(remote.seal.state);
+        if (sealState)
+            return sealState;
+    }
     const top = as(remote.state);
     if (top)
         return top;
@@ -349,6 +356,12 @@ export function buildShowView(local, remote, reason) {
     else {
         L.push(fmt.dim("  no sealed contract on the gateway for this conversation"));
     }
+    // MNE-8234: the seal's lifecycle — independent of `sealed` above (which carries the contract
+    // body, not whether the seal itself is still live or has lapsed). Absent on an older server.
+    if (remote.seal) {
+        const modeBit = remote.seal.state === "live" ? ` · mode ${remote.seal.mode}` : "";
+        L.push(fmt.label("seal:           ", `${remote.seal.state.toUpperCase()} (v${remote.seal.version})${modeBit}`));
+    }
     if (remote.verdict) {
         const v = remote.verdict;
         L.push(fmt.label("verdict:        ", `${v.verdict.toUpperCase()} at turn ${v.turn} — ${v.reason}`));
@@ -385,6 +398,14 @@ export function buildShowView(local, remote, reason) {
     if (remote.turn !== null) {
         L.push(fmt.label("turn:           ", String(remote.turn)));
     }
+    // MNE-8234 (MNE-8166 R4): judging counts under the current seal. `null`/absent ⇒ no judge
+    // ledger counts (older server, or nothing judged under this seal yet) — no line then.
+    if (remote.unjudged_turns !== null && remote.unjudged_turns !== undefined) {
+        const memoisedBit = remote.memoised_turns !== null && remote.memoised_turns !== undefined
+            ? ` · memoised ${remote.memoised_turns}`
+            : "";
+        L.push(fmt.label("judging:        ", `unjudged ${remote.unjudged_turns}${memoisedBit}`));
+    }
     return L;
 }
 export function buildShowJson(local, remote, reason) {
@@ -400,6 +421,9 @@ export function buildShowJson(local, remote, reason) {
                 turn: remote.turn,
                 guardrails: remote.guardrails,
                 verdict_trail: remote.verdict_trail,
+                seal: remote.seal,
+                unjudged_turns: remote.unjudged_turns,
+                memoised_turns: remote.memoised_turns,
             }
             : { source: "gateway", available: false, reason: reason ?? "unknown" },
     };

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

@@ -218,6 +218,7 @@ export declare function isQuietPreambleExit(err: unknown): boolean;
  */
 export declare function ensureMnemomSession(opts?: {
     interactive?: boolean;
+    inviteToken?: string;
 }): Promise<boolean>;
 /**
  * Enforce a positive Mnemom Units balance on the org the agent lives in.

package/dist/commands/agent-setup.js

@@ -621,16 +621,26 @@ export async function ensureMnemomSession(opts = {}) {
     if (!(await askYesNo("Sign in or create your account now?", true)))
         return false;
     const device = headlessEnv();
+    // The device-code page has no way to carry the invitation, so a NEW invitee
+    // signing up there gets the confirmation email — say so instead of dropping
+    // the invitation silently. (The browser path carries it; see loginWithLoopback.)
+    const deviceSignIn = async () => {
+        if (opts.inviteToken) {
+            say(fmt.dim("  New to Mnemom? Signing up from a device code asks you to confirm your email first."));
+            say(fmt.dim("  To skip that, open the link in your invitation email on a machine with a browser."));
+        }
+        await loginWithDeviceFlow();
+    };
     try {
         if (device)
-            await loginWithDeviceFlow();
+            await deviceSignIn();
         else
-            await loginWithBrowser();
+            await loginWithBrowser({ inviteToken: opts.inviteToken });
     }
     catch (err) {
         if (!device) {
             say(fmt.dim("  Browser sign-in didn't work here — falling back to a device code…"));
-            await loginWithDeviceFlow();
+            await deviceSignIn();
         }
         else {
             throw err;

package/dist/commands/agent.d.ts

@@ -124,6 +124,13 @@ export interface AgentOptions {
      * session-config header's `experimental` array. Absent/empty ⇒ none of the three.
      */
     experimental?: readonly ExperimentalId[];
+    /**
+     * Load the "Mnemom for Claude Code" plugin (`plugins/mnemom`: the Mnemom band,
+     * `/mnemom`, the gateway guard, Mnemom attribution) into the launched Claude Code.
+     * Default OFF (the plugin lands dark); `--plugin` ⇒ true; `--no-plugin` ⇒ false; undefined ⇒
+     * MNEMOM_AGENT_PLUGIN decides (lib/claude-plugin).
+     */
+    plugin?: boolean;
     passthrough?: string[];
     /** Print the resolved launch plan and exit — no key read, no spawn. */
     dryRun?: boolean;
@@ -335,6 +342,8 @@ export declare function buildCliArgs(options: AgentOptions, ctx: {
     allowCliFlags: boolean;
     ccSessionId?: string;
     handoffMcpConfigPath?: string;
+    /** The bundled Mnemom plugin folder → `--plugin-dir <dir>` (lib/claude-plugin). */
+    pluginDir?: string;
 }): string[];
 /**
  * The Claude Code session id a launch runs under, from the caller's passthrough (implicit-goal
@@ -365,6 +374,8 @@ export declare function logLaunch(ctx: {
     envelope: SealedContractEnvelope | null;
     goalMode: string | null;
     cli: ResolvedCli;
+    /** The plugin line (`pluginPlanLine`): `off`, `off (<why>)` or `<name> (<dir>)`. */
+    plugin: string;
 }): void;
 /** The launch line for the yolo default: permission prompts are skipped, and how to keep them. */
 export declare function permissionPromptsLine(cli: ResolvedCli): string;
@@ -392,5 +403,7 @@ export declare function printPlan(ctx: {
     sessionConfig: Record<string, string>;
     /** The experimental features on for this launch (the header's `experimental` array). */
     experimental?: readonly string[];
+    /** The bundled Claude Code plugin line (`pluginPlanLine`); always printed, like the launch log. */
+    plugin: string;
 }): void;
 export {};

package/dist/commands/agent.js

@@ -26,7 +26,7 @@
  * an argv value.
  */
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { tmpdir, homedir, hostname } from "node:os";
 import { basename, join, dirname } from "node:path";
@@ -48,6 +48,8 @@ import { defaultAgentSlug, ensureClaimedServedAgent, ensureSessionAndBalance, is
 import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, assertCompactAtCompatible, assertOffProfileCompatible, compactAtWindowWarning, describeCompactAt, launchWindow, resolveCompactAt, applyGatewayHintHeaders, resolveCompactionIntercept, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, resolveUsageSavings, HANDOFF_RC_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, applyToolSearchDefault, DISABLE_1M_ENV, readCcSettings, resolveWindowModel, resolveAnthropicDoor, resolveLaunchModel, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, 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";
+import { CLI_VERSION } from "../version.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
 const CODE_STORE = LAUNCHER_STORE_PATH;
 const say = (line = "") => console.error(line);
@@ -194,6 +196,13 @@ export async function agentCommand(scenarioArg, options = {}) {
     if (cellError)
         throw new Error(cellError);
     const cellNote = isProdGateway(env) ? "us-2/prod" : `custom (${gatewayHost})`;
+    // ── the bundled Claude Code plugin (lib/claude-plugin) ── resolved up front so the dry-run plan
+    // and the launch log print the same line. Only Claude Code proper takes `--plugin-dir`.
+    const pluginWanted = pluginEnabled(options.plugin, env);
+    const bundledPluginDir = pluginWanted ? resolvePluginDir() : null;
+    const pluginFor = (cliName) => cliName !== "claude" && pluginWanted
+        ? { dir: null, line: `off (${cliName} is not Claude Code)` }
+        : { dir: bundledPluginDir, line: pluginPlanLine(bundledPluginDir, pluginWanted) };
     const yolo = options.yolo !== false; // default ON
     const contextHint = options.contextHint !== false; // default ON
     // Context profile: none (null — the cell's own default, no fold key sent) unless
@@ -303,6 +312,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             compactAt,
             sessionConfig,
             experimental,
+            plugin: pluginFor(planCli.name).line,
         });
         if (auth === "subscription") {
             say("mnemom agent: auth = subscription — Claude Code would use your claude.ai login (Team/Enterprise plans only) with a Mnemom API key; no Anthropic key.");
@@ -516,7 +526,46 @@ export async function agentCommand(scenarioArg, options = {}) {
         contextProfile,
         compactAt: contextProfile === "off" ? null : compactAt,
     });
-    logLaunch({ shape, door, agent, conversationId, cellNote, envelope, goalMode, cli });
+    const launchPlugin = pluginFor(cli.name);
+    logLaunch({
+        shape,
+        door,
+        agent,
+        conversationId,
+        cellNote,
+        envelope,
+        goalMode,
+        cli,
+        plugin: launchPlugin.line,
+    });
+    if (pluginWanted && cli.name === "claude" && !bundledPluginDir) {
+        say(fmt.warn("mnemom agent: the Mnemom plugin folder is not in this install — launching without the Mnemom band and /mnemom."));
+    }
+    // Non-secret launch facts for the plugin's band and `/mnemom status`. Built here, applied to the
+    // child env by each launch shape AFTER it has built that env (lib/claude-plugin, PLUGIN_ENV).
+    const plugin = launchPlugin.dir
+        ? {
+            dir: launchPlugin.dir,
+            launch: {
+                gatewayHost,
+                apiUrl: getApiUrl(),
+                agent,
+                conversationId,
+                cellNote,
+                shape,
+                contractSha: envelope?.sha,
+                contract: envelope?.canonical,
+                goalMode,
+                scenario,
+                launcherVersion: CLI_VERSION,
+                // The mod re-runs this CLI (`agent show --json`, `agent goal show --json`) for the live
+                // goal state; execArgv keeps a `tsx`/`--import` dev launch runnable the same way.
+                launcherExec: process.argv[1]
+                    ? [process.execPath, ...process.execArgv, process.argv[1]]
+                    : [],
+            },
+        }
+        : undefined;
     if (expNotice)
         say(expNotice);
     say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
@@ -586,6 +635,7 @@ export async function agentCommand(scenarioArg, options = {}) {
                 ccSessionId: id,
             }),
             knownCcSessionId: cc.id ?? continuedCcSessionId,
+            plugin,
         });
         return; // launchTerminal exits the process
     }
@@ -602,6 +652,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         goalMode,
         sessionConfigB64,
         handoffMcpConfigPath,
+        plugin,
         options: launchOptions,
         yolo,
         ccSessionId,
@@ -1081,6 +1132,7 @@ function launchTerminal(ctx) {
         allowCliFlags: true,
         ccSessionId: ctx.ccSessionId,
         handoffMcpConfigPath: ctx.handoffMcpConfigPath,
+        pluginDir: ctx.plugin?.dir,
     });
     // Claude Code logged in via claude.ai (OAuth) PREEMPTS ANTHROPIC_API_KEY, so
     // it is force-unset; the real key rides in ANTHROPIC_CUSTOM_HEADERS and
@@ -1102,6 +1154,9 @@ function launchTerminal(ctx) {
     // Both auth arms point ANTHROPIC_BASE_URL at the gateway door, which makes Claude Code turn
     // tool search off and inline every tool schema on every request — unless told otherwise.
     applyToolSearchDefault(childEnv);
+    // The plugin's non-secret launch facts (MNEMOM_CC_*): never a key, never a header value.
+    if (ctx.plugin)
+        applyPluginEnv(childEnv, ctx.plugin.launch);
     const sessionName = passthroughName(ctx.options.passthrough ?? []) ?? sessionDisplayName(ctx.agent, ctx.scenario);
     childEnv[SESSION_NAME_ENV] = sessionName;
     // Exact compaction signal for the gateway (x-claude-code-request-class: compaction), on every
@@ -1248,7 +1303,8 @@ function launchRemoteControl(ctx) {
         }
     }
     const proxyScript = resolveProxyScript();
-    const rcDir = mkdtempSync(join(tmpdir(), "mnemom-code-rc."));
+    const rcDir = mkdtempSync(join(rcStateRoot(), "mnemom-code-rc."));
+    writeFileSync(join(rcDir, "owner.pid"), `${process.pid}\n`, { mode: 0o600 }); // rc-state.mjs sweep
     const proxyLog = process.env.MNEMOM_AGENT_RC_PROXY_LOG || join(rcDir, "proxy.log");
     const proxy = spawn("node", [proxyScript], {
         env: {
@@ -1397,6 +1453,10 @@ function spawnRcCli(ctx) {
     if (ctx.handoffMcpConfigPath && ctx.anthropicKey) {
         childEnv[HANDOFF_RC_KEY_ENV_NAME] = ctx.anthropicKey;
     }
+    // The plugin's non-secret launch facts (MNEMOM_CC_*), also after the strip loop: not an
+    // ANTHROPIC_* var, so the RC gate ignores them, and nothing here is a key or a header value.
+    if (ctx.plugin)
+        applyPluginEnv(childEnv, ctx.plugin.launch);
     let args;
     if (ctx.shape === "server") {
         // Headless dispatcher: no --model/--effort/--trim-mcp/yolo flags; the model
@@ -1408,6 +1468,10 @@ function spawnRcCli(ctx) {
             say("mnemom agent: --slack is not applied to a headless server (a channel server needs an interactive confirmation); use the terminal or remote-control shape.");
         }
         args = ["remote-control", "--name", rcName, ...passthrough];
+        // No `--plugin-dir` on the headless server: the env path list loads the plugin into every
+        // session it spawns instead (a user's own list is kept).
+        if (ctx.plugin)
+            appendPluginDirsEnv(childEnv, ctx.plugin.dir);
         // Additive, never `--strict-mcp-config`: --trim-mcp is not applied under --server (every
         // dispatched session keeps its full MCP set, unrestricted — see warnServerDrops below), so
         // the handoff tool rides in on TOP of that set rather than replacing it.
@@ -1424,6 +1488,7 @@ function spawnRcCli(ctx) {
             allowCliFlags: true,
             ccSessionId: ctx.ccSessionId,
             handoffMcpConfigPath: ctx.handoffMcpConfigPath,
+            pluginDir: ctx.plugin?.dir,
         });
         args = ["--remote-control", rcName, ...flagArgs];
         if (ctx.options.slack)
@@ -1455,6 +1520,23 @@ function warnServerDrops(options, yolo) {
         say("mnemom agent: yolo (--dangerously-skip-permissions) is not applied under --server; set permissions from the driven sessions.");
     }
 }
+/**
+ * ~/.mnemom/rc, created 0700 — the same root src/rc-state.mjs gives the proxy's CA dir (tsc emits
+ * no .mjs, so this mirrors its rcStateRoot() rather than importing it). Never the OS temp dir,
+ * whose cleaners delete files behind a long session; that is only the fallback when home is not
+ * writable. Read at call time, not from MNEMOM_DIR: HOME can move after import (tests do).
+ */
+function rcStateRoot() {
+    const root = join(homedir(), ".mnemom", "rc");
+    try {
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+        chmodSync(root, 0o700);
+        return root;
+    }
+    catch {
+        return tmpdir();
+    }
+}
 function resolveProxyScript() {
     const here = dirname(fileURLToPath(import.meta.url));
     const cand = join(here, "..", "rc-proxy.mjs");
@@ -1540,6 +1622,8 @@ export function buildCliArgs(options, ctx) {
             args.push("--dangerously-skip-permissions");
         if (ctx.ccSessionId)
             args.push("--session-id", ctx.ccSessionId);
+        if (ctx.pluginDir)
+            args.push("--plugin-dir", ctx.pluginDir);
     }
     if (options.passthrough?.length)
         args.push(...options.passthrough);
@@ -1650,6 +1734,7 @@ export function goalAlignmentMode(envelope, goalMode) {
 }
 export function logLaunch(ctx) {
     say(`mnemom agent: routing ${ctx.cli.name} through ${ctx.door} [${ctx.cellNote}] as '${ctx.agent}' (conversation ${ctx.conversationId}).`);
+    say(`mnemom agent: plugin: ${ctx.plugin}`);
     if (ctx.envelope) {
         say(`mnemom agent: contract statement: ${ctx.envelope.contract.statement}`);
         say(`mnemom agent: contract sha256[0:16]: ${ctx.envelope.sha}`);
@@ -1673,6 +1758,7 @@ export function printPlan(ctx) {
     L.push("mnemom agent — launch plan (dry run)");
     L.push(`  scenario:      ${ctx.scenario}`);
     L.push(`  cli:           ${ctx.cli.name} (${ctx.cli.bin})`);
+    L.push(`  plugin:        ${ctx.plugin}`);
     L.push(`  shape:         ${ctx.shape}`);
     L.push(`  door:          ${ctx.door}  [${ctx.cellNote}]`);
     L.push(`  agent:         ${ctx.agent}`);

package/dist/commands/validate.d.ts

@@ -3,7 +3,7 @@
  * integration). Surface for engineers to check whether staging is safe
  * to promote to production based on the most recent harness run state.
  *
- *   mnemom validate safe-house [--against=staging] [--max-age=24h]
+ *   mnemom validate safe-house [--against=test] [--max-age=24h]
  *                              [--lane=full|fast] [--strict] [--json]
  *
  * Wraps `GET /v1/admin/safe-house/harness-state` (mnemom-staff only).

package/dist/commands/validate.js

@@ -3,7 +3,7 @@
  * integration). Surface for engineers to check whether staging is safe
  * to promote to production based on the most recent harness run state.
  *
- *   mnemom validate safe-house [--against=staging] [--max-age=24h]
+ *   mnemom validate safe-house [--against=test] [--max-age=24h]
  *                              [--lane=full|fast] [--strict] [--json]
  *
  * Wraps `GET /v1/admin/safe-house/harness-state` (mnemom-staff only).
@@ -76,10 +76,12 @@ export async function validateSafeHouseCommand(opts) {
     await requireAuth();
     // `--against` is informational only today (validation is always against
     // the api root the user is authenticated to). Keep the flag for forward-
-    // compat: production gains a separate harness corpus per T1.
-    const against = opts.against ?? "staging";
-    if (against !== "staging" && against !== "production") {
-        console.log(fmt.error(`--against must be 'staging' or 'production' (got '${against}')`) + "\n");
+    // compat: production gains a separate harness corpus per T1. The non-prod
+    // value is `test` (the Azure test cell): `staging` named the retired ring
+    // (MNE-7968) and is rejected so a stale script fails loud, not quietly.
+    const against = opts.against ?? "test";
+    if (against !== "test" && against !== "production") {
+        console.log(fmt.error(`--against must be 'test' or 'production' (got '${against}')`) + "\n");
         process.exit(1);
         return;
     }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./lib/retired-env-guard.js";
 import { program } from "commander";
 export { program };
 /**

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// MUST stay the first import: it exits cleanly on MNEMOM_ENV=staging before any
+// module below resolves the (retired) staging URLs at import time (MNE-7968).
+import "./lib/retired-env-guard.js";
 import { program, InvalidArgumentError, Option } from "commander";
 import { isEntrypoint } from "./lib/entrypoint.js";
 import { CLI_VERSION } from "./version.js";
@@ -141,7 +144,7 @@ function printAgentHelp(verb) {
 const agentCmd = program
     .command("agent [session] [passthrough...]")
     .description("Launch your governed agent (Claude Code in v1) through the Mnemom gateway — governed identity + optional sealed goal contract. Plain `mnemom agent` asks for a session name. " +
-    "Sub-verbs: `setup` provisions your governed agent; `doctor` preflights prerequisites; `config …` manages persistent settings (~/.mnemom/launcher.toml); `invite <token>` redeems a Mnemom Agent invitation; `list` / `claim` / `move` manage the agents in your orgs; `sessions` lists your past launches and `show [ref]` merges one with its live goal state; `help [verb]` prints help and never launches.")
+    "Sub-verbs: `setup` provisions your governed agent; `doctor` preflights prerequisites; `config …` manages persistent settings (~/.mnemom/launcher.toml); `--invite <token>` redeems a Mnemom Agent invitation (the one-liner your invitation email shows; `invite <token>` is its alias); `list` / `claim` / `move` manage the agents in your orgs; `sessions` lists your past launches and `show [ref]` merges one with its live goal state; `help [verb]` prints help and never launches.")
     .option("--goal <statement>", "Contract goal statement (required if any contract flag is given)")
     .option("--requirement <text>", "Contract requirement (repeatable)", collectRepeatable, [])
     .option("--allow <glob>", "Allowed path/glob (repeatable)", collectRepeatable, [])
@@ -182,6 +185,11 @@ const agentCmd = program
     .option("--no-governance", "Turn governance OFF for the agent's cards, autonomy policy checks included (by default new agents run autonomy observe, rules only; a card refresh otherwise keeps an existing agent's modes)")
     .option("--no-yolo", "Do NOT pass --dangerously-skip-permissions (yolo is on by default)")
     .option("--no-context-hint", "Do NOT seed Claude Code's context-hint feature flag before launch")
+    // The Mnemom plugin lands dark: off by default and not in the published package, so its two
+    // flags stay out of --help until the shipping PR turns it on (lib/claude-plugin.ts). They still
+    // parse, for a source checkout.
+    .addOption(new Option("--plugin", "Load the Mnemom plugin (the Mnemom band, /mnemom, the gateway guard) into Claude Code — off by default and not in the published package yet (needs a source checkout; MNEMOM_AGENT_PLUGIN=1 does the same)").hideHelp())
+    .addOption(new Option("--no-plugin", "Do NOT load the Mnemom plugin even when MNEMOM_AGENT_PLUGIN=1").hideHelp())
     .addOption(new Option("--slack", "EXPERIMENTAL (`mnemom experimental enable slack`): attach the Slack channel — messages addressed to this session arrive in it, and it can reply (see `mnemom agent slack`)").hideHelp(hiddenUnless("slack")))
     .option("--context", "Force context folding ON for this launch even when launcher.toml (context = false) or MNEMOM_AGENT_CONTEXT turns it off")
     .option("--no-context", "Disable context folding for this launch (folding is on by default; tells the gateway to skip it for this session)")
@@ -366,6 +374,7 @@ const agentCmd = program
             trimMcp: opts.trimMcp,
             yolo: opts.yolo,
             contextHint: opts.contextHint,
+            plugin: opts.plugin,
             slack: opts.slack ?? cfg.slackListen,
             context: opts.context,
             contextProfile: opts.contextProfile,
@@ -1650,7 +1659,7 @@ const validateCmd = program
 validateCmd
     .command("safe-house")
     .description("Render Safe House harness state per lane (full/fast) — promotion-readiness signal")
-    .option("--against <env>", "Target environment ('staging' or 'production'; informational)", "staging")
+    .option("--against <env>", "Target environment ('test' or 'production'; informational)", "test")
     .option("--max-age <duration>", "Reject runs older than this (e.g. 30m, 2h, 24h, 1d)", "24h")
     .option("--lane <lane>", "Show only one lane ('full', 'fast', or 'both')", "both")
     .option("--strict", "Exit non-zero if any selected lane is stale or red")

package/dist/lib/api.d.ts

@@ -1305,6 +1305,29 @@ export interface AgentSessionVerdictTrailEntry {
     fence_breach: boolean | null;
     at: string;
 }
+/**
+ * The seal's lifecycle (MNE-8149 R2, MNE-8199 D9/R9, MNE-8234/mnemom-api#3541). `live`: a sealed
+ * contract currently governs — `mode` says whether a crossed guardrail only nudges or enforces
+ * (refuses the next request). `expired`: the prior seal lapsed (24h idle) and the next engaged
+ * request will seal afresh; no `mode` because nothing is being enforced.
+ */
+export interface AgentSessionSealLive {
+    state: "live";
+    version: number;
+    hash: string;
+    sealed_at: string;
+    reason: "first" | "after_expiry" | null;
+    expired_hash: string | null;
+    updated_from_hash: string | null;
+    mode: "nudge" | "enforce";
+}
+export interface AgentSessionSealExpired {
+    state: "expired";
+    version: number;
+    hash: string;
+    sealed_at: string;
+}
+export type AgentSessionSeal = AgentSessionSealLive | AgentSessionSealExpired;
 /** `GET /v1/agent/sessions/{conversationId}` 200 body. Nulls mean "nothing stored" — absence is data. */
 export interface AgentSessionResponse {
     conversation_id: string;
@@ -1319,6 +1342,24 @@ export interface AgentSessionResponse {
     guardrails: AgentSessionGuardrails | null;
     /** Absent on an older server (back-compat) — never shown then, never an empty-array assumption. */
     verdict_trail?: AgentSessionVerdictTrailEntry[];
+    /**
+     * MNE-8234: the seal's lifecycle, incl. `expired`. Absent on an older server (back-compat —
+     * never shown then). `null` means the API itself reports no seal: either none was ever made for
+     * this conversation, or the gateway sent a seal payload out of contract and the API dropped it
+     * rather than relay it half-trusted — the two are indistinguishable from this field alone.
+     */
+    seal?: AgentSessionSeal | null;
+    /**
+     * MNE-8166 R4 / MNE-8234: assistant turns under the current seal with no verdict (a cut-off/
+     * aborted response, a judge that failed or never ran, a non-streamed final turn). Absent on an
+     * older server (back-compat). `null` when no judge ledger counts under the current seal.
+     */
+    unjudged_turns?: number | null;
+    /**
+     * MNE-8166 R4 / MNE-8234: turns the judge memo graded (aligned by inheritance, no verdict
+     * stored). Absent on an older server (back-compat). `null` alongside `unjudged_turns`.
+     */
+    memoised_turns?: number | null;
 }
 /**
  * The live goal state of one `mnemom agent` session, read through mnemom-api

package/dist/lib/auth.d.ts

@@ -99,7 +99,9 @@ export declare function isLoggedIn(): Promise<boolean>;
  * loopback redirect (the `wrangler login` pattern). Persists the resulting
  * SCOPED tokens (plus the client_id needed to refresh) to ~/.mnemom/auth.json.
  */
-export declare function loginWithBrowser(): Promise<AuthTokens>;
+export declare function loginWithBrowser(opts?: {
+    inviteToken?: string;
+}): Promise<AuthTokens>;
 /**
  * Headless login: RFC 8628 device authorization grant. Shows a user_code +
  * verification_uri for the user to approve in any browser (possibly on another

package/dist/lib/auth.js

@@ -212,8 +212,8 @@ export async function isLoggedIn() {
  * loopback redirect (the `wrangler login` pattern). Persists the resulting
  * SCOPED tokens (plus the client_id needed to refresh) to ~/.mnemom/auth.json.
  */
-export async function loginWithBrowser() {
-    const { tokens, clientId } = await loginWithLoopback();
+export async function loginWithBrowser(opts = {}) {
+    const { tokens, clientId } = await loginWithLoopback(undefined, opts);
     const stored = fromOAuthTokens(tokens, clientId);
     saveAuthTokens(stored);
     return stored;