@mnemom/mnemom 0.17.11-next.0 → 0.17.11

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

@@ -9,11 +9,14 @@
  * Checks: settings file, coding-agent CLI, Anthropic key source, gateway health
  * (200 + the x-mnemom-verdict header that proves the governance pipeline is
  * live), Remote-Control capability (node + openssl + the --remote-control flag),
- * claude.ai login (informational — Remote Control needs it), and CLI auto-update status.
+ * claude.ai login (informational — Remote Control needs it), the agent's governance
+ * modes (off by default for new agents), and CLI auto-update status.
  */
 type Mark = "ok" | "warn" | "miss" | "info";
 export interface DoctorOptions {
     cli?: string;
+    /** The agent slug a launch would use (--agent / launcher.toml); default agent-<handle>. */
+    agent?: string;
 }
 /** Run the preflight and print the checklist. Sets process.exitCode on failure. */
 export declare function agentDoctorCommand(options?: DoctorOptions): Promise<void>;
@@ -21,6 +24,8 @@ export interface CodeAccessProbe {
     mark: Mark;
     text: string;
     hint?: string;
+    /** May this account use Remote Control? Only a determined `remote_control: true` says yes. */
+    remoteControl: boolean;
 }
 /**
  * The invited-cohort gate, as the doctor reports it. Signed out → info (we can't
@@ -29,4 +34,17 @@ export interface CodeAccessProbe {
  * anything inconclusive → info, never a MISS (the launch preamble fails open too).
  */
 export declare function probeCodeAccess(): Promise<CodeAccessProbe>;
+export interface GovernanceProbe {
+    mark: Mark;
+    text: string;
+    hint?: string;
+}
+/**
+ * The governance line: the composed (every layer, strictest wins) integrity and
+ * Safe House modes of the agent a launch would use. Signed out, no such agent,
+ * or an unreadable card → info with the off-by-default note, never a MISS
+ * (governance never blocks a launch). On → info naming the per-turn cost; the
+ * agent's own card says off but a stricter layer keeps it on → warn.
+ */
+export declare function probeGovernance(agent: string | undefined): Promise<GovernanceProbe>;
 export {};

package/dist/commands/agent-doctor.js

@@ -9,7 +9,8 @@
  * Checks: settings file, coding-agent CLI, Anthropic key source, gateway health
  * (200 + the x-mnemom-verdict header that proves the governance pipeline is
  * live), Remote-Control capability (node + openssl + the --remote-control flag),
- * claude.ai login (informational — Remote Control needs it), and CLI auto-update status.
+ * claude.ai login (informational — Remote Control needs it), the agent's governance
+ * modes (off by default for new agents), and CLI auto-update status.
  */
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -19,11 +20,12 @@ import { resolveAgentAuth } from "../lib/subscription-login.js";
 import { isProdGateway, resolveAnthropicDoor, resolveGatewayHost, singleCellError, } from "../lib/agent.js";
 import { getApiUrl, getGatewayUrl } from "../lib/config.js";
 import { LAUNCHER_CONFIG_PATH } from "../lib/launcher-config.js";
-import { getCodeEntitlement, MnemomApiError } from "../lib/api.js";
+import { getAgentByName, getCardSources, getCodeEntitlement, MnemomApiError } from "../lib/api.js";
 import { isLoggedIn } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.js";
-import { isCodeNotEnabled, sourceLabel } from "./agent-invite.js";
+import { isCodeNotEnabled, REQUEST_ACCESS_URL, sanitizeTerminalText, sourceLabel, withRequestAccess, } from "./agent-invite.js";
 import { probeUpdateStatus } from "../lib/update/doctor.js";
+import { describeModes, GOVERNANCE_OPT_IN_HINT, resolveDefaultSlug } from "./agent-setup.js";
 const MARK = { ok: "[ ok ]", warn: "[warn]", miss: "[MISS]", info: "[info]" };
 const out = (line = "") => console.log(line);
 /** Run the preflight and print the checklist. Sets process.exitCode on failure. */
@@ -94,27 +96,35 @@ export async function agentDoctorCommand(options = {}) {
     else {
         add("warn", `gateway: ${host} [${cell}] unreachable (${health.detail})`, "check the host (MNEMOM_AGENT_GATEWAY / `mnemom agent config set gateway <url>`) and your network");
     }
-    // ── Remote Control capability ──
-    if (cli) {
+    // ── Mnemom Agent access (invited cohort gate) ── probed here, before the Remote Control
+    // lines, because Remote Control is internal-only: an account the api does not entitle to it
+    // (every customer) never sees those lines at all.
+    const gate = await probeCodeAccess();
+    // ── Remote Control capability (entitled accounts only) ──
+    if (cli && gate.remoteControl) {
         const rc = checkRcCapability(cli);
         if (rc.ok)
             add("ok", "Remote Control: available (node + openssl + --remote-control)");
         else
             add("warn", `Remote Control: unavailable — ${rc.missing.join("; ")}`, "launches fall back to terminal-only until these are in place");
-        // ── claude.ai login (informational — RC needs it) ──
-        if (cli.name === "claude") {
-            const login = claudeLoggedIn(cli.bin);
-            if (login === true)
-                add("ok", "claude.ai login: logged in");
-            else if (login === false)
-                add("info", "claude.ai login: not logged in", "Remote Control needs a claude.ai login; the terminal-only shape does not");
-            else
-                add("info", "claude.ai login: could not determine");
-        }
     }
-    // ── Mnemom Agent access (invited cohort gate) ──
-    const gate = await probeCodeAccess();
+    // ── claude.ai login (informational) ── Remote Control needs it, and so does auth =
+    // subscription; a terminal launch on an Anthropic key does not, so nobody else sees it.
+    if (cli && cli.name === "claude" && (gate.remoteControl || auth === "subscription")) {
+        const login = claudeLoggedIn(cli.bin);
+        if (login === true)
+            add("ok", "claude.ai login: logged in");
+        else if (login === false)
+            add("info", "claude.ai login: not logged in", auth === "subscription"
+                ? "auth = subscription launches Claude Code on your claude.ai login — run `claude` and /login"
+                : "Remote Control needs a claude.ai login; the terminal-only shape does not");
+        else
+            add("info", "claude.ai login: could not determine");
+    }
     add(gate.mark, gate.text, gate.hint);
+    // ── governance (off by default for new agents) ──
+    const gov = await probeGovernance(options.agent);
+    add(gov.mark, gov.text, gov.hint);
     // ── CLI auto-update ──
     const upd = await probeUpdateStatus();
     add(upd.mark, upd.text, upd.hint);
@@ -187,7 +197,8 @@ export async function probeCodeAccess() {
         return {
             mark: "info",
             text: "Mnemom Agent access: sign in to check",
-            hint: "run `mnemom login`; @mnemom.ai accounts are enabled by default, others need an invitation (mnemom agent --invite <token>)",
+            hint: `run \`mnemom login\`; @mnemom.ai accounts are enabled by default, others need an invitation (mnemom agent --invite <token>) — request one at ${REQUEST_ACCESS_URL}`,
+            remoteControl: false,
         };
     }
     const org = getActiveOrg();
@@ -197,9 +208,7 @@ export async function probeCodeAccess() {
         return {
             mark: "ok",
             text: `Mnemom Agent access: enabled for ${orgLabel} (${sourceLabel(ent.source)})`,
-            hint: ent.remote_control
-                ? undefined
-                : "Remote Control (steer from claude.ai / the Claude app) is an internal feature — your sessions run terminal-only",
+            remoteControl: ent.remote_control === true,
         };
     }
     catch (err) {
@@ -208,12 +217,88 @@ export async function probeCodeAccess() {
             return {
                 mark: "miss",
                 text: `Mnemom Agent access: not enabled for ${orgLabel}`,
-                hint: typeof hint === "string" && hint
-                    ? hint
-                    : "redeem an invitation: mnemom agent --invite <token>",
+                hint: withRequestAccess(typeof hint === "string" && hint
+                    ? sanitizeTerminalText(hint)
+                    : "redeem an invitation: mnemom agent --invite <token>"),
+                remoteControl: false,
             };
         }
         const detail = err instanceof MnemomApiError || err instanceof Error ? err.message : String(err);
-        return { mark: "info", text: `Mnemom Agent access: could not determine (${detail})` };
+        return {
+            mark: "info",
+            text: `Mnemom Agent access: could not determine (${detail})`,
+            remoteControl: false,
+        };
+    }
+}
+const OPT_IN_HINT = GOVERNANCE_OPT_IN_HINT.trim();
+/**
+ * The governance line: the composed (every layer, strictest wins) integrity and
+ * Safe House modes of the agent a launch would use. Signed out, no such agent,
+ * or an unreadable card → info with the off-by-default note, never a MISS
+ * (governance never blocks a launch). On → info naming the per-turn cost; the
+ * agent's own card says off but a stricter layer keeps it on → warn.
+ */
+export async function probeGovernance(agent) {
+    const offByDefault = {
+        mark: "info",
+        text: "governance: off by default for new agents (AIP integrity analysis, Safe House screening)",
+        hint: `${OPT_IN_HINT} Agents set up before this default keep their cards.`,
+    };
+    if (!(await isLoggedIn()))
+        return offByDefault;
+    try {
+        const slug = agent?.trim() || (await resolveDefaultSlug());
+        const found = await getAgentByName(slug);
+        if (!found)
+            return offByDefault;
+        const [align, prot] = await Promise.all([
+            getCardSources("alignment", found.id),
+            getCardSources("protection", found.id),
+        ]);
+        const read = (s, layer, field) => {
+            const v = s?.[layer]?.card_json?.[field];
+            return typeof v === "string" && v ? v : undefined;
+        };
+        // A composed card without the field (or none composed yet) is unknown, not
+        // off: the data plane falls back to its own default (observe for integrity),
+        // so the doctor never claims governance is off when it can't see it.
+        const composed = {
+            integrity: read(align, "composed", "integrity_mode") ?? "unknown",
+            protection: read(prot, "composed", "mode") ?? "unknown",
+        };
+        const own = {
+            integrity: read(align, "agent", "integrity_mode"),
+            protection: read(prot, "agent", "mode"),
+        };
+        const text = `governance: ${slug} — ${describeModes(composed)}`;
+        const stricter = (mine, eff) => mine === "off" && eff !== "off" && eff !== "unknown";
+        const overridden = stricter(own.integrity, composed.integrity) || stricter(own.protection, composed.protection);
+        if (overridden) {
+            return {
+                mark: "warn",
+                text,
+                hint: "the agent's own card says off, but a stricter org, team or platform policy keeps it on — it still runs and is billed",
+            };
+        }
+        if (composed.integrity === "off" && composed.protection === "off") {
+            return { mark: "ok", text, hint: OPT_IN_HINT };
+        }
+        if (composed.integrity === "unknown" || composed.protection === "unknown") {
+            return {
+                mark: "info",
+                text,
+                hint: "no composed card yet for at least one feature — it reads once the agent's cards compose (re-run `mnemom agent doctor` in a minute)",
+            };
+        }
+        return {
+            mark: "info",
+            text,
+            hint: "each feature that is on is a model call per turn, billed at cost on top of the agent fee — `mnemom agent setup --no-governance` turns it off",
+        };
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return { ...offByDefault, text: `governance: could not read the agent's cards (${detail})` };
     }
 }

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

@@ -29,6 +29,13 @@ export declare class CodeNotEnabledError extends Error {
 /** `pinv_` + base64url — the product-invite token shape the api mints. */
 export declare const INVITE_TOKEN_RE: RegExp;
 export declare function looksLikeInviteToken(value: unknown): value is string;
+/**
+ * Where someone without an invitation (or a Mnemom contact) asks for access. Every
+ * locked-out message ends with it, so an uninvited customer is never at a dead end.
+ */
+export declare const REQUEST_ACCESS_URL = "https://www.mnemom.ai/contact";
+/** `hint`, plus the request-access pointer unless the hint already carries the URL. */
+export declare function withRequestAccess(hint: string): string;
 /** Drop control characters (ANSI escapes included) from an api-supplied string before
  *  it reaches the terminal — defense in depth; the value is first-party but printed raw. */
 export declare function sanitizeTerminalText(s: string): string;

package/dist/commands/agent-invite.js

@@ -39,6 +39,25 @@ export function looksLikeInviteToken(value) {
     return typeof value === "string" && INVITE_TOKEN_RE.test(value.trim());
 }
 const FALLBACK_HINT = "Ask your Mnemom contact for a Mnemom Agent invitation, then run: mnemom agent --invite <token>";
+/**
+ * Where someone without an invitation (or a Mnemom contact) asks for access. Every
+ * locked-out message ends with it, so an uninvited customer is never at a dead end.
+ */
+export const REQUEST_ACCESS_URL = "https://www.mnemom.ai/contact";
+/** Whether `hint` already names the request-access page, as a whole word (trailing
+ *  punctuation ignored) — a token match, not a substring one. */
+function mentionsRequestAccess(hint) {
+    return hint.split(/\s+/).some((w) => w.replace(/[.,;:!?)]+$/, "") === REQUEST_ACCESS_URL);
+}
+/** `hint`, plus the request-access pointer unless the hint already carries the URL. */
+export function withRequestAccess(hint) {
+    if (mentionsRequestAccess(hint))
+        return hint;
+    let end = hint.length;
+    while (end > 0 && (hint[end - 1] === "." || hint[end - 1].trim() === ""))
+        end--;
+    return `${hint.slice(0, end)}. No invitation yet? Request access at ${REQUEST_ACCESS_URL}`;
+}
 /** Drop control characters (ANSI escapes included) from an api-supplied string before
  *  it reaches the terminal — defense in depth; the value is first-party but printed raw. */
 export function sanitizeTerminalText(s) {
@@ -76,7 +95,7 @@ function printNotEnabled(orgLabel, hint) {
     say();
     say("    mnemom agent --invite <token>");
     say();
-    say(fmt.dim(`  ${hint}`));
+    say(fmt.dim(`  ${withRequestAccess(hint)}`));
 }
 /**
  * Enforce the Mnemom Agent gate for the org the launch targets. Blocks (prints

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

@@ -16,6 +16,9 @@
  *     screen_surfaces declared, ready for when it is turned on.
  *   - goal-alignment: nudge — sealed per-conversation via the goal contract
  *     (--goal …), graded and re-anchored by the gateway.
+ * `--governance [integrity,safe-house]` opts a setup in (observe-only, billed at
+ * cost on top of the agent fee); a refresh of an already-claimed agent keeps the
+ * modes its own cards carry unless a --governance / --no-governance flag says otherwise.
  *
  * A launch never runs on an unclaimed agent (operator 2026-10-03): an unclaimed agent lands in
  * the sandbox org and bills nobody. ensureClaimedServedAgent asks the gateway which agent it
@@ -26,6 +29,43 @@
  * reinventing it.
  */
 import { type CodeEntitlement } from "../lib/api.js";
+/** A card's governance mode as the CLI writes it: off, or observe-only. */
+export type GovernanceMode = "off" | "observe";
+/**
+ * The governance features a setup turns on. Each is a model call per turn that
+ * the customer pays for at cost, so both are off unless asked for.
+ */
+export interface GovernanceOptIn {
+    /** AIP integrity analysis (alignment card integrity_mode). */
+    integrity: boolean;
+    /** Safe House screening (protection card mode). */
+    safeHouse: boolean;
+}
+/** The feature names `--governance <list>` accepts (plus `all` / `none`). */
+export declare const GOVERNANCE_FEATURES: readonly ["integrity", "safe-house"];
+/**
+ * Parse the `--governance [features]` / `--no-governance` flag. undefined = not
+ * given (new agents get none; a refresh keeps the agent's current modes),
+ * true = every feature, false = none, a string = a comma-separated list of
+ * `integrity`, `safe-house`, `all` or `none`. Throws on an unknown name.
+ */
+export declare function parseGovernanceFlag(value: boolean | string | undefined): GovernanceOptIn | undefined;
+/**
+ * The modes a setup writes into the two cards: off/observe from the flag, or
+ * whatever an existing agent's own cards already carry (kept as-is on a refresh).
+ */
+export interface CardModes {
+    /** autonomy_mode — verification + policy. No model call, so not billed; kept as-is on a refresh. */
+    autonomy: string;
+    integrity: string;
+    protection: string;
+}
+/** One phrase for the posture line: "integrity off, Safe House off". */
+export declare function describeModes(m: Pick<CardModes, "integrity" | "protection">): string;
+/** The modes for a NEW agent: off unless --governance asks for a feature. */
+export declare function newAgentModes(governance?: GovernanceOptIn): CardModes;
+/** Printed when a setup ran without --governance: how to opt in, and what it costs. */
+export declare const GOVERNANCE_OPT_IN_HINT: string;
 /**
  * The default governed-agent slug for the current customer: `agent-<handle>`,
  * where <handle> is the local-part of their mnemom login email (sanitised), or
@@ -73,6 +113,12 @@ export interface ClaimedAgentOptions {
     orgLabel: string;
     /** true = --setup (re-ask the gateway, refresh the cards); false = --no-setup (no card writes). */
     setup?: boolean;
+    /**
+     * `--governance` / `--no-governance`: the modes the cards get. undefined = a new agent's are
+     * off, and a refresh keeps the agent's current modes. Given on a claimed agent, it also
+     * refreshes the cards (unless --no-setup).
+     */
+    governance?: GovernanceOptIn;
     /** Where the served-agent cache lives (defaults to ~/.mnemom). */
     cacheDir?: string;
 }
@@ -124,9 +170,10 @@ export declare function ensureClaimedServedAgent(opts: ClaimedAgentOptions): Pro
  * (`details.required_scope`). Never the token, never the body.
  */
 export declare function describeApiError(err: unknown): string;
-/** `mnemom agent setup [--agent <slug>]` — the explicit provisioning entry point. */
+/** `mnemom agent setup [--agent <slug>] [--governance …]` — the explicit provisioning entry point. */
 export declare function agentSetupCommand(opts?: {
     agent?: string;
+    governance?: GovernanceOptIn;
 }): Promise<void>;
 /** Thrown when the agent's org has no spendable MU balance. The user-facing
  *  top-up guidance is already printed when this is thrown — callers exit quietly. */
@@ -187,3 +234,5 @@ export declare function resolvePreflightedAccount(): Promise<{
     orgLabel: string;
     entitlement: CodeEntitlement | null;
 }>;
+export declare function buildCodeAlignmentCard(agentId: string, modes?: Pick<CardModes, "autonomy" | "integrity">): Record<string, unknown>;
+export declare function buildCodeProtectionCard(agentId: string, mode?: string): Record<string, unknown>;

package/dist/commands/agent-setup.js

@@ -16,6 +16,9 @@
  *     screen_surfaces declared, ready for when it is turned on.
  *   - goal-alignment: nudge — sealed per-conversation via the goal contract
  *     (--goal …), graded and re-anchored by the gateway.
+ * `--governance [integrity,safe-house]` opts a setup in (observe-only, billed at
+ * cost on top of the agent fee); a refresh of an already-claimed agent keeps the
+ * modes its own cards carry unless a --governance / --no-governance flag says otherwise.
  *
  * A launch never runs on an unclaimed agent (operator 2026-10-03): an unclaimed agent lands in
  * the sandbox org and bills nobody. ensureClaimedServedAgent asks the gateway which agent it
@@ -25,7 +28,7 @@
  * (agents.ts), claimAgent + putAlignmentCard/putProtectionCard (lib/api.ts) — rather than
  * reinventing it.
  */
-import { claimAgent, getAgent, getAgentByName, getMe, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
+import { claimAgent, getAgent, getAgentByName, getCardSources, getMe, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
 import { getAuthInfo, loginWithBrowser, loginWithDeviceFlow, resolveAuth } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.js";
 import { getApiUrl, getGatewayUrl, getWebsiteUrl, MNEMOM_DIR } from "../lib/config.js";
@@ -40,6 +43,102 @@ import { birthThroughGateway } from "./wrap.js";
 import { resolveAnthropicKey } from "./agent.js";
 import { assertCodeEnabled, CodeNotEnabledError } from "./agent-invite.js";
 const say = (line = "") => console.error(line);
+/** The feature names `--governance <list>` accepts (plus `all` / `none`). */
+export const GOVERNANCE_FEATURES = ["integrity", "safe-house"];
+/**
+ * Parse the `--governance [features]` / `--no-governance` flag. undefined = not
+ * given (new agents get none; a refresh keeps the agent's current modes),
+ * true = every feature, false = none, a string = a comma-separated list of
+ * `integrity`, `safe-house`, `all` or `none`. Throws on an unknown name.
+ */
+export function parseGovernanceFlag(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "boolean")
+        return { integrity: value, safeHouse: value };
+    const choice = { integrity: false, safeHouse: false };
+    const names = value
+        .split(",")
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    if (names.length === 0)
+        return { integrity: true, safeHouse: true };
+    for (const name of names) {
+        if (name === "all") {
+            choice.integrity = true;
+            choice.safeHouse = true;
+        }
+        else if (name === "none") {
+            // contributes nothing; `none` alone means both off
+        }
+        else if (name === "integrity") {
+            choice.integrity = true;
+        }
+        else if (name === "safe-house") {
+            choice.safeHouse = true;
+        }
+        else {
+            throw new Error(`--governance: unknown feature '${name}' — use ${GOVERNANCE_FEATURES.join(", ")}, all or none (comma-separated).`);
+        }
+    }
+    return choice;
+}
+const modeOf = (on) => (on ? "observe" : "off");
+/** One phrase for the posture line: "integrity off, Safe House off". */
+export function describeModes(m) {
+    return `integrity ${m.integrity}, Safe House ${m.protection}`;
+}
+/** The mode string a raw card carries in `field`, or undefined when absent/not a string. */
+function modeField(card, field) {
+    const v = card?.[field];
+    return typeof v === "string" && v ? v : undefined;
+}
+/**
+ * An existing agent's own (agent-layer) card, to keep its modes on a refresh.
+ * null = it has none. THROWS when the read fails: the caller then leaves the
+ * cards alone rather than guess a mode in either direction.
+ */
+async function existingAgentCard(kind, agentId) {
+    const sources = await getCardSources(kind, agentId);
+    return sources?.agent?.card_json ?? null;
+}
+/** The modes for a NEW agent: off unless --governance asks for a feature. */
+export function newAgentModes(governance) {
+    const integrity = modeOf(governance?.integrity ?? false);
+    return { autonomy: integrity, integrity, protection: modeOf(governance?.safeHouse ?? false) };
+}
+/**
+ * The modes for refreshing an EXISTING agent: an explicit --governance /
+ * --no-governance wins; else it keeps the modes its own cards carry. No agent-layer
+ * card → off (it never had one; new setups are off). A card with no mode field →
+ * observe (the prior CLI always wrote observe). A failed read → null: skip the refresh.
+ */
+async function existingAgentModes(agentId, governance) {
+    if (governance)
+        return newAgentModes(governance);
+    let align;
+    let prot;
+    try {
+        [align, prot] = await Promise.all([
+            existingAgentCard("alignment", agentId),
+            existingAgentCard("protection", agentId),
+        ]);
+    }
+    catch (err) {
+        say(fmt.warn(`mnemom agent: couldn't read ${agentId}'s current cards (${describeApiError(err)}) — leaving them unchanged.`));
+        say(fmt.dim("  Re-run `mnemom agent setup`, or pass --governance / --no-governance to set them."));
+        return null;
+    }
+    const integrity = align ? (modeField(align, "integrity_mode") ?? "observe") : "off";
+    return {
+        autonomy: align ? (modeField(align, "autonomy_mode") ?? "observe") : "off",
+        integrity,
+        protection: prot ? (modeField(prot, "mode") ?? "observe") : "off",
+    };
+}
+/** Printed when a setup ran without --governance: how to opt in, and what it costs. */
+export const GOVERNANCE_OPT_IN_HINT = "  Governance (AIP integrity analysis, Safe House screening) is off by default. Turn it on with " +
+    "`mnemom agent setup --governance` (or --governance integrity / safe-house); it is billed at cost on top of the agent fee.";
 /**
  * The default governed-agent slug for the current customer: `agent-<handle>`,
  * where <handle> is the local-part of their mnemom login email (sanitised), or
@@ -193,11 +292,18 @@ async function confirmClaimed(opts, anchorKey, fp) {
     const slug = opts.slug;
     const agentId = await resolveServedAgent(opts, fp);
     if (await isClaimed(slug, agentId)) {
-        if (opts.setup === true) {
+        if (opts.setup === true || (opts.governance && opts.setup !== false)) {
             // An explicit `mnemom agent setup` / --setup repairs or completes the cards (e.g. a
             // protection card that failed on a prior run before its one-time grant was minted).
             say(fmt.dim(`mnemom agent: '${slug}' is ${agentId}, already claimed — refreshing its cards.`));
-            await publishDefaultCards(agentId);
+            const modes = await existingAgentModes(agentId, opts.governance);
+            if (modes) {
+                if (!opts.governance) {
+                    say(fmt.dim(`  Keeping its current governance (${describeModes(modes)}). New agents default to off; ` +
+                        "`--governance` turns it on, `--no-governance` turns it off."));
+                }
+                await publishDefaultCards(agentId, modes);
+            }
             persistAgentSlug(slug);
         }
         else {
@@ -229,10 +335,14 @@ async function confirmClaimed(opts, anchorKey, fp) {
     }
     say(fmt.success(`mnemom agent: claimed '${slug}' (${agentId}) in ${opts.orgLabel}.`));
     await noteSameNamedAgent(slug, agentId);
-    // Publish the default (off) cards. A card write that can't complete does NOT undo the claim —
-    // the agent is claimed and governed on whatever landed; we warn how to finish it.
-    if (opts.setup !== false)
-        await publishDefaultCards(agentId);
+    // Publish the default cards (off unless --governance). A card write that can't complete does
+    // NOT undo the claim — the agent is claimed and governed on whatever landed; we warn how to
+    // finish it.
+    if (opts.setup !== false) {
+        await publishDefaultCards(agentId, newAgentModes(opts.governance));
+        if (!opts.governance)
+            say(fmt.dim(GOVERNANCE_OPT_IN_HINT));
+    }
     persistAgentSlug(slug);
     return { slug, agentId, claimedNow: true };
 }
@@ -354,9 +464,9 @@ async function tryPublishCard(name, write) {
     }
     return { name, ok: false, error: "unknown error" };
 }
-/** Publish both default (off) cards; never throws — warns on a card that can't be written. */
-async function publishDefaultCards(agentId) {
-    const align = await tryPublishCard("alignment", () => putAlignmentCard(agentId, JSON.stringify(buildCodeAlignmentCard(agentId)), "application/json"));
+/** Publish both default cards at `modes`; never throws — warns on a card that can't be written. */
+async function publishDefaultCards(agentId, modes) {
+    const align = await tryPublishCard("alignment", () => putAlignmentCard(agentId, JSON.stringify(buildCodeAlignmentCard(agentId, modes)), "application/json"));
     // Protection is the "locked door": it needs a one-time cards:write:protection
     // grant that the claim does NOT include (alignment rides a standing cap). Mint
     // it with our human login JWT — the human running `mnemom agent` (which claims
@@ -375,13 +485,13 @@ async function publishDefaultCards(agentId) {
             say(fmt.dim("  That agent is owned by an org other than your active one — `mnemom org use <org>` to switch, or set up under a different --agent."));
         }
     }
-    const prot = await tryPublishCard("protection", () => putProtectionCard(agentId, JSON.stringify(buildCodeProtectionCard(agentId)), "application/json"));
+    const prot = await tryPublishCard("protection", () => putProtectionCard(agentId, JSON.stringify(buildCodeProtectionCard(agentId, modes.protection)), "application/json"));
     if (align.ok && prot.ok) {
-        say(fmt.success("mnemom agent: default posture published (alignment + protection off until you turn them on; goal contracts nudge)."));
+        say(fmt.success(`mnemom agent: cards published (${describeModes(modes)}; goal contracts nudge).`));
         return;
     }
     if (align.ok)
-        say(fmt.success("mnemom agent: alignment card published (off)."));
+        say(fmt.success(`mnemom agent: alignment card published (integrity ${modes.integrity}).`));
     for (const c of [align, prot]) {
         if (c.ok)
             continue;
@@ -392,7 +502,7 @@ async function publishDefaultCards(agentId) {
         say(fmt.dim(`  The agent is claimed and running; finish it later with \`${publishCmd}\`.`));
     }
 }
-/** `mnemom agent setup [--agent <slug>]` — the explicit provisioning entry point. */
+/** `mnemom agent setup [--agent <slug>] [--governance …]` — the explicit provisioning entry point. */
 export async function agentSetupCommand(opts = {}) {
     const gatewayHost = resolveGatewayHost(process.env);
     const cellError = singleCellError({
@@ -427,6 +537,7 @@ export async function agentSetupCommand(opts = {}) {
         orgId: account.orgId,
         orgLabel: account.orgLabel,
         setup: true,
+        governance: opts.governance,
     });
 }
 function persistAgentSlug(slug) {
@@ -603,12 +714,15 @@ export async function resolvePreflightedAccount() {
     return { orgId: active?.org_id ?? entitlement?.org_id ?? "", orgLabel, entitlement };
 }
 // ── The default coding posture (cards off; goal contracts nudge) ─────────────
-function buildCodeAlignmentCard(agentId) {
+export function buildCodeAlignmentCard(agentId, modes = { autonomy: "off", integrity: "off" }) {
     return {
         card_version: "unified/2026-04-26",
         agent_id: agentId,
-        autonomy_mode: "off",
-        integrity_mode: "off",
+        // Integrity off ⇒ the gateway skips the AIP checkpoint and the observer skips
+        // its trace analysis: no model call, no charge. A new agent's autonomy
+        // (verification + policy) follows it; a refresh keeps the agent's own.
+        autonomy_mode: modes.autonomy,
+        integrity_mode: modes.integrity,
         principal: { type: "agent", identifier: agentId, relationship: "delegated_authority" },
         values: {
             declared: ["transparency", "safety", "honesty", "user_control", "harm_prevention"],
@@ -641,11 +755,11 @@ function buildCodeAlignmentCard(agentId) {
         audit: { retention_days: 30, queryable: false, trace_format: "otel" },
     };
 }
-function buildCodeProtectionCard(agentId) {
+export function buildCodeProtectionCard(agentId, mode = "off") {
     return {
         card_version: "protection/2026-04-26",
         agent_id: agentId,
-        mode: "off",
+        mode,
         thresholds: { warn: 0.6, quarantine: 0.8, block: 0.95 },
         screen_surfaces: {
             incoming: true,

package/dist/commands/agent.d.ts

@@ -29,6 +29,7 @@ import { type MnemomKeyDeps } from "../lib/subscription-login.js";
 import { type SessionRecord } from "../lib/agent-ledger.js";
 import { type ExperimentalId } from "../lib/experimental.js";
 import { type ConsoleKeyDeps } from "../lib/console-key.js";
+import { type GovernanceOptIn } from "./agent-setup.js";
 import { type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
@@ -102,6 +103,11 @@ export interface AgentOptions {
      * default cards, false (`--no-setup`) skips the card writes.
      */
     setup?: boolean;
+    /**
+     * `--governance` / `--no-governance`: the governance modes a provisioning (or
+     * `--setup` refresh) writes. undefined = off for a new agent, kept on a refresh.
+     */
+    governance?: GovernanceOptIn;
     /**
      * Where to source the Anthropic key (from ~/.mnemom/launcher.toml `key_source`).
      * Restricts the default env → store → prompt search: "env" uses env only,
@@ -339,6 +345,11 @@ export declare function logLaunch(ctx: {
     goalMode: string | null;
     cli: ResolvedCli;
 }): void;
+/**
+ * The agent a signed-out `--dry-run` shows when the caller named none: the real name is
+ * `agent-<handle>` from the Mnemom login, which a dry run (no sign-in) cannot know yet.
+ */
+export declare const DRY_RUN_SIGNED_OUT_AGENT = "agent-<your Mnemom login handle>";
 export declare function printPlan(ctx: {
     scenario: string;
     shape: LaunchShape;

package/dist/commands/agent.js

@@ -36,6 +36,7 @@ import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { createApiKey } from "../lib/api.js";
 import { MNEMOM_KEY_STORE_FIELD, resolveAgentAuth, resolveSubscriptionMnemomKey, subscriptionChildEnv, subscriptionShape, } from "../lib/subscription-login.js";
 import { LEDGER_FILE, appendSessionRecord, findResumeCandidate, readSessionRecords, resolveRetentionDays, resumedContextProfile, toLedgerContract, } from "../lib/agent-ledger.js";
+import { isLoggedIn } from "../lib/auth.js";
 import { loadCliConfig } from "../lib/cli-config.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { experimentalNotice } from "../lib/experimental.js";
@@ -261,20 +262,26 @@ export async function agentCommand(scenarioArg, options = {}) {
     // which we only know AFTER sign-in. The entitlement-aware decision
     // (`resolveRemoteControlShape`) happens below, right after
     // `ensureSessionAndBalance`. --dry-run prints the plan BEFORE sign-in, so it
-    // can't know the entitlement; it previews the shape the MACHINE is capable of
-    // (as the pre-gate behaviour did), then notes that the real launch applies the
-    // entitlement gate. `shape` itself stays the requested (ungated) shape.
+    // can't know the entitlement: it previews the REQUESTED shape (terminal unless
+    // --remote-control/--server or `launch` asked otherwise) and never the RC
+    // auto-upgrade, which only an entitled (internal) account gets. An explicit RC
+    // request gets the note that the real launch still applies the entitlement gate.
     if (options.dryRun) {
         const planCli = cli ?? {
             bin: "(not found — pass --cli <path> or `mnemom agent config set cli <path>`)",
             name: basename((options.cli || env.MNEMOM_AGENT_CLI || "claude").trim()),
         };
-        const previewShape = !shapeExplicit && shape === "terminal" && cli && checkRcCapability(cli).ok
-            ? "remote-control"
-            : shape;
+        // A defaulted slug is `agent-<handle>` from the login (resolved for real after
+        // sign-in, below). Signed in: show that name. Signed out, or no usable handle:
+        // say where it comes from rather than print the "agent-user" fallback as if it were it.
+        if (!options.agent?.trim()) {
+            agent =
+                ((await isLoggedIn()) && sanitizeAgentName(await resolveDefaultSlug())) ||
+                    DRY_RUN_SIGNED_OUT_AGENT;
+        }
         printPlan({
             scenario,
-            shape: previewShape,
+            shape,
             agent,
             // The org is only known after sign-in, so a dry run never offers a resume (IG5 #1).
             conversationId: resolveConversationId(options.conversationId),
@@ -298,8 +305,8 @@ export async function agentCommand(scenarioArg, options = {}) {
         }
         if (expNotice)
             say(expNotice);
-        if (previewShape === "remote-control") {
-            say("mnemom agent: the plan shows Remote Control because this machine can run it; the real launch uses it only if your account is entitled (internal Mnemom accounts), else terminal-only.");
+        if (shape !== "terminal") {
+            say("mnemom agent: the real launch uses this shape only if your account is entitled to it, else terminal-only.");
         }
         sayContextProfile(contextProfile);
         sayCompaction(contextProfile, compactionIntercept, compactAt, launchWindow(windowModelFor(options, cli)));
@@ -314,14 +321,6 @@ export async function agentCommand(scenarioArg, options = {}) {
     if (!cli) {
         cli = await promptForCliPath(options.cli, env, cliError);
     }
-    // ── resolve the Anthropic key (zero 1Password; never logged) ──
-    // Not on a subscription launch: Claude Code then sends its own claude.ai login instead.
-    // A Console launch uses the key Claude Code's Console login created, then runs as api-key.
-    const anthropicKey = auth === "subscription"
-        ? undefined
-        : auth === "console"
-            ? requireConsoleKey(defaultConsoleKeyDeps(env))
-            : await resolveAnthropicKey(env, { allowPrompt: true, keySource: options.keySource });
     // ── account + µ-balance gate (no free tier) ─────────────────────────────────
     // mnemom agent runs governed and on µ, so before we seal a contract or launch we
     // (1) ensure a Mnemom session — offering the try-me-style sign-in / sign-up when
@@ -342,6 +341,16 @@ export async function agentCommand(scenarioArg, options = {}) {
             process.exit(1); // guidance already printed
         throw err;
     }
+    // ── resolve the Anthropic key (zero 1Password; never logged) ──
+    // AFTER the account gate above: an account Mnemom Agent is not enabled for learns that
+    // (and how to get access) before it is asked for, or refused for want of, a key.
+    // Not on a subscription launch: Claude Code then sends its own claude.ai login instead.
+    // A Console launch uses the key Claude Code's Console login created, then runs as api-key.
+    const anthropicKey = auth === "subscription"
+        ? undefined
+        : auth === "console"
+            ? requireConsoleKey(defaultConsoleKeyDeps(env))
+            : await resolveAnthropicKey(env, { allowPrompt: true, keySource: options.keySource });
     // ── Remote-Control entitlement gate ─────────────────────────────────────────
     // Remote Control (a session steerable from claude.ai / the Claude app) is
     // internal-only. Now that we know the org's entitlement, resolve the final
@@ -402,6 +411,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         orgId: account.orgId,
         orgLabel: account.orgLabel,
         setup: options.setup,
+        governance: options.governance,
     });
     // ── conversation id ── an implicit relaunch continues its earlier conversation (IG5 #1, D1)
     // so the goal the gateway inferred there is still the one it steers by. Resolved here, after
@@ -1584,6 +1594,11 @@ export function logLaunch(ctx) {
         say(`mnemom agent: goal mode: ${ctx.goalMode} (inferred from your messages; watch x-mnemom-goal-revision / x-mnemom-goal-steer on each response)`);
     }
 }
+/**
+ * The agent a signed-out `--dry-run` shows when the caller named none: the real name is
+ * `agent-<handle>` from the Mnemom login, which a dry run (no sign-in) cannot know yet.
+ */
+export const DRY_RUN_SIGNED_OUT_AGENT = "agent-<your Mnemom login handle>";
 export function printPlan(ctx) {
     const L = [];
     L.push("mnemom agent — launch plan (dry run)");

package/dist/commands/experimental.d.ts

@@ -16,3 +16,5 @@ export declare function experimentalEnableCommand(id: string | undefined, deps?:
 export declare function experimentalDisableCommand(id: string | undefined, deps?: ExperimentalDeps): void;
 /** The one-time migration (lib/experimental.ts migrateExperimental) against the real files. */
 export declare function runExperimentalMigration(): void;
+/** Does `dir` exist with anything in it? Unreadable counts as yes (an upgrader keeps the notice). */
+export declare function hasPriorState(dir: string): boolean;

package/dist/commands/experimental.js

@@ -2,8 +2,10 @@
  * `mnemom experimental list [--json] | enable <id> | disable <id>` — turn experimental
  * features on and off (registry: lib/experimental.ts; stored in ~/.mnemom/config.json).
  */
+import { existsSync, readdirSync } from "node:fs";
 import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
 import { loadCliConfig, setExperimentalEnabled } from "../lib/cli-config.js";
+import { MNEMOM_DIR } from "../lib/config.js";
 import { launcherEntries, loadLauncherConfig } from "../lib/launcher-config.js";
 function defaultDeps() {
     return {
@@ -74,5 +76,15 @@ export function runExperimentalMigration() {
         launcherEntries: () => launcherEntries(loadLauncherConfig()),
         persist: (ids) => setExperimentalEnabled(ids),
         writeErr: (line) => void process.stderr.write(line),
+        priorInstall: () => hasPriorState(MNEMOM_DIR),
     });
 }
+/** Does `dir` exist with anything in it? Unreadable counts as yes (an upgrader keeps the notice). */
+export function hasPriorState(dir) {
+    try {
+        return existsSync(dir) && readdirSync(dir).length > 0;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/index.js

@@ -26,7 +26,7 @@ import { agentCommand } from "./commands/agent.js";
 import { agentConfigCommand } from "./commands/agent-config.js";
 import { agentSlackCommand } from "./commands/agent-slack.js";
 import { agentDoctorCommand } from "./commands/agent-doctor.js";
-import { agentSetupCommand } from "./commands/agent-setup.js";
+import { agentSetupCommand, parseGovernanceFlag } from "./commands/agent-setup.js";
 import { agentInviteCommand, runAgentInvocation } from "./commands/agent-invite.js";
 import { agentFirstRunCommand, offerFirstRunOnLaunch } from "./commands/agent-first-run.js";
 import { applyConfigToEnv, launcherEntries, loadLauncherConfig, withoutDisabledExperimental, } from "./lib/launcher-config.js";
@@ -155,8 +155,11 @@ const agentCmd = program
     .option("--conversation-id <id>", "x-mnemom-conversation-id (default: auto-generated)")
     .option("--cli <name|path>", "Coding-agent CLI to launch: a name or full path (default: claude)")
     .option("--gateway <url>", "Gateway host override — must be the same cell as the rest of the CLI (default: that cell's gateway; or MNEMOM_AGENT_GATEWAY)")
-    .option("--remote-control", "Interactive Remote Control session in THIS terminal (behind a local proxy)")
-    .option("--server", "Headless `claude remote-control` dispatcher (behind a local proxy)")
+    // Remote Control is internal-only (the launch gates it on the org's entitlement and runs a
+    // customer terminal-only), so its two shapes stay out of --help for everyone. The help is
+    // built at load, before any sign-in, so it cannot ask the entitlement; the flags still parse.
+    .addOption(new Option("--remote-control", "Interactive Remote Control session in THIS terminal (behind a local proxy)").hideHelp())
+    .addOption(new Option("--server", "Headless `claude remote-control` dispatcher (behind a local proxy)").hideHelp())
     .option("--auth <mode>", "How Claude Code authenticates: api-key (default) | subscription (your Claude Team/Enterprise login) | console (the API key your Claude Code Anthropic Console login created)")
     .option("--model <alias|id>", "Model to launch (CLI alias or concrete id)")
     .addOption(new Option("--effort <level>", "Reasoning effort").choices([
@@ -170,6 +173,8 @@ const agentCmd = program
     .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")
     .option("--no-setup", "Skip the default-card writes (the agent is still confirmed and claimed)")
+    .option("--governance [features]", "Turn governance ON for the agent's cards: AIP integrity analysis + Safe House screening, observe-only (default: off for new agents). Pick features with a comma list: integrity, safe-house. Billed at cost on top of the agent fee")
+    .option("--no-governance", "Turn governance OFF for the agent's cards (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")
     .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")))
@@ -299,13 +304,15 @@ const agentCmd = program
             return;
         }
         if (scenario === "doctor") {
-            await agentDoctorCommand({ cli: opts.cli });
+            await agentDoctorCommand({ cli: opts.cli, agent: program.opts().agent ?? cfg.agent });
             return;
         }
+        // Validated up front so a typo fails before any sign-in or provisioning.
+        const governance = parseGovernanceFlag(opts.governance);
         // Sub-verb: `mnemom agent setup` provisions/claims the governed agent and
         // never launches. The agent slug follows the same precedence as a launch.
         if (scenario === "setup") {
-            await agentSetupCommand({ agent: program.opts().agent ?? cfg.agent });
+            await agentSetupCommand({ agent: program.opts().agent ?? cfg.agent, governance });
             return;
         }
         const numToStr = (n) => n === undefined ? undefined : String(n);
@@ -367,6 +374,7 @@ const agentCmd = program
                 : false,
             experimental,
             setup: opts.setup,
+            governance,
             keySource: cfg.keySource,
             passthrough,
             dryRun: opts.dryRun,

package/dist/lib/api.d.ts

@@ -630,6 +630,27 @@ export declare const PROTECTION_CARD_MAX_BYTES: number;
 export declare function putProtectionCard(agentId: string, body: string, contentType?: "text/yaml" | "application/json", opts?: {
     idempotencyKey?: string;
 }): Promise<PublishedCardResponse>;
+/**
+ * The per-layer view of an agent's card (ADR-053 `?include=sources`): the raw
+ * card the agent layer itself carries, next to the composed card every layer
+ * produced. We type the two rows we read; the platform/org/teams rows ride along.
+ */
+export interface CardSources {
+    agent: {
+        card_json: Record<string, unknown> | null;
+        available: boolean;
+    };
+    composed: {
+        card_json: Record<string, unknown> | null;
+        available: boolean;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Fetch an agent's alignment or protection card sources envelope. Returns null
+ * when the agent has no canonical card yet (404).
+ */
+export declare function getCardSources(kind: "alignment" | "protection", agentId: string): Promise<CardSources | null>;
 export interface CardPreviewResult {
     /** true ⇔ the server accepted+composed the card (HTTP 200). */
     valid: boolean;

package/dist/lib/api.js

@@ -841,6 +841,22 @@ export async function putProtectionCard(agentId, body, contentType = "text/yaml"
     }
     return response.json();
 }
+/**
+ * Fetch an agent's alignment or protection card sources envelope. Returns null
+ * when the agent has no canonical card yet (404).
+ */
+export async function getCardSources(kind, agentId) {
+    const url = validateUrl(`${API_BASE}/v1/${kind}/agent/${encodeURIComponent(agentId)}?include=sources`);
+    const response = await mnemomFetch(url, {
+        headers: { Accept: "application/json", ...(await authHeaders()) },
+    });
+    if (!response.ok) {
+        if (response.status === 404)
+            return null;
+        throw await readApiError(response, `Failed to fetch ${kind} card sources`);
+    }
+    return response.json();
+}
 /**
  * Dry-run validate + compose a card body against the server's authoritative
  * pipeline. Returns a structured result — a 422/400 validation failure is an

package/dist/lib/experimental.d.ts

@@ -98,6 +98,11 @@ export interface MigrationDeps {
     launcherEntries(): Array<[string, string]>;
     persist(ids: ExperimentalId[]): void;
     writeErr(line: string): void;
+    /**
+     * Did this machine run the CLI before this invocation (~/.mnemom already held something)?
+     * A brand-new install never had implicit on, so it gets no "it used to be on" notice.
+     */
+    priorInstall(): boolean;
 }
 /** One-time notice for users who had implicit goal alignment by default (no goal_mode set). */
 export declare const IMPLICIT_NOW_OFF_NOTICE: string;

package/dist/lib/experimental.js

@@ -213,6 +213,7 @@ export function migrateExperimental(deps) {
     try {
         if (deps.stored() !== undefined)
             return null;
+        const upgrading = deps.priorInstall();
         const entries = deps.launcherEntries();
         const ids = featuresInUse(entries);
         deps.persist(ids);
@@ -220,9 +221,10 @@ export function migrateExperimental(deps) {
             deps.writeErr(`mnemom: ${ids.join(", ")} ${ids.length === 1 ? "is" : "are"} now experimental and kept on because your launcher.toml uses ${ids.length === 1 ? "it" : "them"} — see \`mnemom experimental list\`.\n`);
         }
         // Implicit was the unconfigured DEFAULT, so most users relied on it without a
-        // goal_mode entry. Don't let it switch off silently for them: say so once.
+        // goal_mode entry. Don't let it switch off silently for them: say so once. A fresh
+        // install had no default to lose, so it is told nothing.
         const optedOut = entries.some(([k, v]) => k === "goal_mode" && v === "off");
-        if (!ids.includes("implicit") && !optedOut)
+        if (upgrading && !ids.includes("implicit") && !optedOut)
             deps.writeErr(IMPLICIT_NOW_OFF_NOTICE);
         return ids;
     }

package/dist/lib/launcher-config.js

@@ -135,7 +135,7 @@ export const CONFIG_KEYS = [
     },
     {
         key: "launch",
-        describe: `Launch shape (${LAUNCH_SHAPES.join("|")})`,
+        describe: "Launch shape (terminal)",
         get: (c) => c.launch,
         set: (c, v) => {
             c.launch = coerceLaunch(v);

package/dist/lib/version-gate.js

@@ -74,8 +74,7 @@ export function enforceMinCliVersion(response, exit = process.exit, write = (chu
         write(`\n✓ Updated the Mnemom CLI (was v${CLI_VERSION}; server minimum v${floor}). Re-run your command.\n\n`);
         exit(1);
     }
-    write(`\n✖ Your Mnemom CLI (v${CLI_VERSION}) is too old for this server (minimum v${floor}).\n` +
-        `  Old CLIs can silently drop newer request fields — e.g. \`--org\` on \`mnemom agent claim\`.\n\n` +
+    write(`\n✖ Your Mnemom CLI (v${CLI_VERSION}) is too old for this server (minimum v${floor}).\n\n` +
         `  Upgrade:  npm i -g @mnemom/mnemom@latest\n\n`);
     exit(1);
 }

package/package.json

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