@mnemom/mnemom 0.17.25 → 0.17.27

package/dist/commands/agent-config.js

@@ -175,6 +175,9 @@ function deleteKey(cfg, key) {
         case "agent":
             delete cfg.agent;
             break;
+        case "agent_id":
+            delete cfg.agentId;
+            break;
         case "effort":
             delete cfg.effort;
             break;
@@ -217,6 +220,12 @@ function deleteKey(cfg, key) {
         case "slack_allow":
             delete cfg.slackAllow;
             break;
+        case "slack_aliases":
+            delete cfg.slackAliases;
+            break;
+        case "slack_sticky_threads":
+            delete cfg.slackStickyThreads;
+            break;
         default:
             requireSpec(key); // throws the known-keys message for anything unknown
     }

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

@@ -43,8 +43,9 @@ export interface GovernanceProbe {
  * 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.
+ * (governance never blocks a launch). On → info naming the per-turn cost; a
+ * stricter layer outranks the agent's own card (any rung up the ladder off <
+ * observe < nudge < enforce, MNE-8612) → warn naming the layer.
  */
 export declare function probeGovernance(agent: string | undefined): Promise<GovernanceProbe>;
 export {};

package/dist/commands/agent-doctor.js

@@ -24,7 +24,7 @@ import { isLoggedIn } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.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";
+import { describeModes, GOVERNANCE_OPT_IN_HINT, layersSettingMode, outranksAgentCard, 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. */
@@ -71,16 +71,17 @@ export async function agentDoctorCommand(options = {}) {
         else
             add("miss", "Anthropic key: none found", "export MNEMOM_AGENT_ANTHROPIC_KEY=sk-ant-… (or ANTHROPIC_API_KEY), or run `mnemom agent` once and accept the save prompt");
     }
-    // ── one cell: the launch door must be the CLI's own cell ──
+    // ── one cell: the launch door and the gateway host must be the CLI's own cell ──
+    const host = resolveGatewayHost(env);
     const cellError = singleCellError({
         door: resolveAnthropicDoor(env),
+        gateway: host,
         apiUrl: getApiUrl(),
         cellGateway: getGatewayUrl(),
     });
     if (cellError)
         add("miss", "cell: mixed — a launch would be refused", cellError);
     // ── gateway health ──
-    const host = resolveGatewayHost(env);
     const cell = isProdGateway(env) ? "us-2/prod" : "custom";
     const health = await probeGateway(host);
     if (health.ok && health.verdictHeader) {
@@ -232,8 +233,9 @@ 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.
+ * (governance never blocks a launch). On → info naming the per-turn cost; a
+ * stricter layer outranks the agent's own card (any rung up the ladder off <
+ * observe < nudge < enforce, MNE-8612) → warn naming the layer.
  */
 export async function probeGovernance(agent) {
     const offByDefault = {
@@ -268,13 +270,27 @@ export async function probeGovernance(agent) {
             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) {
+        // A stricter layer outranks the agent's own card on the ladder off < observe <
+        // nudge < enforce: name the feature, the mode that runs, and the layer that set it,
+        // and point only at the show command for a feature that was outranked.
+        const raised = [];
+        const shows = [];
+        const raise = (feature, mine, eff, sources, field, platformIsFloor, show) => {
+            if (!outranksAgentCard(mine, eff))
+                return;
+            const layers = layersSettingMode(sources, field, eff, { platform: platformIsFloor });
+            const from = layers.length > 0 ? ` from ${layers.join(" and ")}` : "";
+            raised.push(`${feature} ${eff}${from} (agent card: ${mine})`);
+            shows.push(show);
+        };
+        raise("integrity", own.integrity, composed.integrity, align, "integrity_mode", false, "`mnemom card show` prints the composed alignment card (integrity_mode).");
+        raise("Safe House", own.protection, composed.protection, prot, "mode", true, "`mnemom protection show` prints the composed Safe House card.");
+        if (raised.length > 0) {
             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",
+                hint: `a stricter org, team or platform policy outranks the agent's own card: ${raised.join(", ")}. ` +
+                    `The stricter mode is the one that runs and is billed. Change it at that layer. ${shows.join(" ")}`,
             };
         }
         if (composed.integrity === "off" && composed.protection === "off") {

package/dist/commands/agent-goal.js

@@ -27,9 +27,14 @@ import { localGoalFlag, resolveSessionRef } from "./agent-sessions.js";
  * for. Lazy import: commands/agent.ts is the launcher and carries a heavy import graph.
  */
 export async function resolveLaunchCreds() {
-    const { resolveAnthropicKey } = await import("./agent.js");
+    const { defaultMnemomKeyDeps, resolveAnthropicKey } = await import("./agent.js");
+    const { readMnemomKey } = await import("../lib/subscription-login.js");
     try {
-        return { anthropicKey: await resolveAnthropicKey(process.env, { allowPrompt: false }) };
+        const anthropicKey = await resolveAnthropicKey(process.env, { allowPrompt: false });
+        // The Mnemom key the launch sent beside it (env, else the store; never minted here) — a
+        // pinned session's control calls need it, and every call is then asked as the launch was.
+        const mnemomKey = readMnemomKey(defaultMnemomKeyDeps());
+        return mnemomKey ? { anthropicKey, mnemomKey } : { anthropicKey };
     }
     catch {
         throw new Error("no Anthropic key in env (MNEMOM_AGENT_ANTHROPIC_KEY / ANTHROPIC_API_KEY) or ~/.mnemom/launcher.json — " +

package/dist/commands/agent-sessions.js

@@ -329,7 +329,8 @@ export function buildShowView(local, remote, reason) {
     if (local.cc_session_id && local.launch_shape !== "server") {
         L.push(fmt.label("resume:       ", resumeCommand({
             scenario: local.session,
-            agent: local.agent_slug,
+            // A pinned launch resumes pinned (its served id), never by a name that could birth.
+            agent: local.agent_pinned && local.agent_id ? local.agent_id : local.agent_slug,
             ccSessionId: local.cc_session_id,
         })));
     }

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

@@ -11,11 +11,15 @@
  * on); governance that costs none stays ON (operator 2026-10-03: autonomy is
  * rules-only verification + policy). The goal contract is what nudges (re-anchor
  * on drift). Specifically:
- *   - alignment card: autonomy_mode = observe, integrity_mode = off,
- *     principal.relationship = delegated_authority, coding bounded/forbidden
- *     actions, escalate-on-irreversible;
- *   - protection card: mode = off, thresholds 0.60/0.80/0.95 and all four
- *     screen_surfaces declared, ready for when it is turned on.
+ *   - alignment card: autonomy_mode = observe, integrity_mode = off, the agent's
+ *     org as principal (delegated_authority), Claude Code tool names as bounded
+ *     actions, coding forbidden actions, defined values, grace 0, and no default
+ *     escalation trigger for irreversible operations (the customer adds their own);
+ *   - protection card: mode = off, thresholds 0.60/0.80/0.95, all four
+ *     screen_surfaces and a credential-store protected_surface declared, ready for
+ *     when it is turned on.
+ *   Both carry content_version (CODE_CARD_CONTENT_VERSION); a refresh upgrades an
+ *   older default's content and keeps the agent's modes.
  *   - 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
@@ -31,7 +35,7 @@
  * (agents.ts), claimAgent + putAlignmentCard/putProtectionCard (lib/api.ts) — rather than
  * reinventing it.
  */
-import { type CodeEntitlement } from "../lib/api.js";
+import { type CardSources, 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";
 /**
@@ -80,11 +84,62 @@ export interface CardModes {
 }
 /** One phrase for the posture line: "integrity off, Safe House off". */
 export declare function describeModes(m: Pick<CardModes, "integrity" | "protection">): string;
+/**
+ * The governance mode ladder, weakest first. The same order mnemom-api composes
+ * on (compose.ts ALIGNMENT_MODE_ORDER and PROTECTION_MODE_ORDER): strictest wins.
+ */
+export declare const MODE_LADDER: readonly ["off", "observe", "nudge", "enforce"];
+/** A mode's rung on MODE_LADDER, or -1 when it is not on the ladder (absent, "unknown"). */
+export declare function modeRank(mode: string | undefined): number;
+/**
+ * True when the composed mode sits on a higher rung than the agent's own card, so a
+ * stricter layer decides the mode that runs. An agent card that sets no mode, or a
+ * composed mode that is not on the ladder, is never an outrank.
+ */
+export declare function outranksAgentCard(own: string | undefined, effective: string): boolean;
+/**
+ * The upstream layers of a sources envelope whose own card sets `field` to `mode`,
+ * named for a person (`team "Lane Leads"`, `org "Acme"`, `platform`), in cascade
+ * order. Those are the layers that put the composed mode where it is. `platform`
+ * is asked for only where the platform card is a floor (protection mode); for
+ * integrity_mode it is only a default, so it never outranks an agent card that
+ * sets one. Empty when no layer row matches (an older api without the rows, or a
+ * composed card older than a template edit).
+ */
+export declare function layersSettingMode(sources: CardSources | null, field: string, mode: string, opts: {
+    platform: boolean;
+}): string[];
+/**
+ * The composed Safe House (protection) mode for the launch summary, naming the
+ * layer that set it when the agent's own card says something else:
+ * `enforce (from team "Lane Leads"; agent card: observe)`. Same mode as the
+ * agent card prints the mode alone. No composed card reads `unknown`.
+ */
+export declare function describeComposedProtection(sources: CardSources | null): string;
+/**
+ * How long the launch waits for the protection card sources before printing the
+ * line without them. An object so tests can shorten it, like TWIN_LISTING.
+ */
+export declare const PROTECTION_READ: {
+    timeoutMs: number;
+};
+/**
+ * The launch summary's protection phrase for `agentId`: one `getCardSources`
+ * read (`GET /v1/protection/agent/:id?include=sources`, the same read the doctor
+ * makes), which carries both the composed card and every layer's own card. Best
+ * effort: it never throws, so the caller can start it early and await it later,
+ * and a failed or slow read prints `unknown` rather than holding up the launch.
+ */
+export declare function readComposedProtection(agentId: string): Promise<string>;
 /**
  * The modes for a NEW agent: autonomy observe (rules only, no model call) unless
  * --no-governance; integrity and Safe House off unless --governance asks for them.
  */
 export declare function newAgentModes(governance?: GovernanceOptIn): CardModes;
+interface ExistingCards {
+    align: Record<string, unknown> | null;
+    prot: Record<string, unknown> | null;
+}
 /** Printed when a setup ran without --governance: how to opt in, and what it costs. */
 export declare const GOVERNANCE_OPT_IN_HINT: string;
 /**
@@ -122,8 +177,18 @@ export interface ClaimedAgentOptions {
     slug: string;
     /** Anthropic-key launch: the key that anchors the gateway identity. Never logged. */
     anthropicKey?: string;
-    /** Subscription launch: the Mnemom API key that anchors the gateway identity. Never logged. */
+    /**
+     * The Mnemom API key: on a subscription launch it anchors the gateway identity; on an api-key
+     * launch (beside `anthropicKey`) it rides along as the key principal, and the identity stays
+     * hash(Anthropic key, name). Required with `pin`. Never logged.
+     */
     mnemomKey?: string;
+    /**
+     * The agent id this launch pins (`--agent mnm-<uuid>` / launcher.toml `agent_id`). The gateway
+     * must serve exactly this agent (identity route `resolved_by: "pin"`) or the launch refuses;
+     * a pinned launch never claims and never births.
+     */
+    pin?: string;
     /** Gateway host the launch targets (the probe goes to the same cell). */
     gatewayHost: string;
     /**
@@ -156,6 +221,11 @@ export interface ClaimedAgentResult {
     agentId: string;
     /** true only when this call claimed it. */
     claimedNow: boolean;
+    /**
+     * The gateway rejected the Mnemom key an api-key launch offered alongside its Anthropic key;
+     * the agent was confirmed without it, and the launch must not send it either.
+     */
+    mnemomKeyRejected?: boolean;
 }
 /**
  * A failure worth retrying, and that an outage fallback may cover: no answer at all (network,
@@ -183,17 +253,76 @@ export declare function isTransient(err: unknown): boolean;
  * Interactive and non-interactive runs behave the same: there is no prompt to decline.
  * MNE-7650: the name is client-controlled, so a same-named org agent proves nothing — only the
  * served id counts.
+ *
+ * A PINNED launch (`opts.pin`, from `--agent mnm-<uuid>` / launcher.toml `agent_id`) takes a
+ * separate path (ensurePinnedAgent): the gateway must serve exactly the pin, and it never claims.
+ *
+ * An api-key launch that also carries a Mnemom key (`opts.mnemomKey` beside `opts.anthropicKey`)
+ * asks the probe with it too, so the answer is the one its requests will get. If the gateway
+ * rejects that key, the launch continues without it (result.mnemomKeyRejected) rather than fail.
  */
 export declare function ensureClaimedServedAgent(opts: ClaimedAgentOptions): Promise<ClaimedAgentResult>;
+/**
+ * How long the anti-twin listing may take before it is treated as failed (best effort). An
+ * object so tests can shorten it, like CONFIRM_RETRY_DELAYS_MS.
+ */
+export declare const TWIN_LISTING: {
+    timeoutMs: number;
+};
+/**
+ * The ids of the caller's OTHER live, claimed agents named `slug` in `orgId` — the same set the
+ * gateway's principal resolution picks from (claimed_by = the caller). Reads the caller's own
+ * agents (`GET /v1/agents?scope=all`), then each same-named one's full record for its claim and
+ * org; a tombstoned one (404) is skipped. Throws when the listing can't be completed in
+ * TWIN_LISTING.timeoutMs — every caller treats that as "unknown", never as "none".
+ */
+export declare function claimedSameNamedAgents(slug: string, excludeId: string, orgId: string): Promise<string[]>;
+/** The refusal when an unclaimed served agent would become a same-named twin. */
+export declare function twinRefusal(slug: string, servedId: string, twins: readonly string[], orgLabel: string): string;
+/**
+ * Resolve a pin before launch: the agent must be visible to the caller (the org-member view) and
+ * claimed; its name becomes the launch's slug (`x-mnemom-agent`, which the gateway checks against
+ * the pin). Any failure refuses — a pinned launch never falls back to a name.
+ */
+export declare function resolvePinnedAgent(id: string): Promise<{
+    id: string;
+    slug: string;
+}>;
 /**
  * One line for an api failure that keeps the parts an operator can act on: the
  * message, the error code, and the scope the endpoint said it needed
  * (`details.required_scope`). Never the token, never the body.
  */
 export declare function describeApiError(err: unknown): string;
-/** `mnemom agent setup [--agent <slug>] [--governance …]` — the explicit provisioning entry point. */
+/**
+ * Options for publishDefaultCards: `orgId` is the principal for a card that gets the
+ * default content (the agent's own org, else the launch's); `ownOrg` is the agent's own
+ * org when it could be read (agentOrgId), which a kept card's principal follows.
+ */
+interface PublishOpts {
+    orgId?: string;
+    ownOrg?: string;
+    existing?: ExistingCards;
+}
+/**
+ * The principal a kept (already-current) card is published with. An organization
+ * principal follows the agent's CURRENT org: a re-claim into another org moves it, and
+ * a stale one would be carried forward verbatim on every refresh otherwise (the keep
+ * branch is the steady state once a card is at this version). Any other declared
+ * principal is the customer's and is kept. No principal (a gateway birth whose org the
+ * api didn't know) gets the org principal: a published card must declare one. When
+ * the agent's org could not be read, the declared principal is kept as it is (never
+ * replaced by the launch org, which may not be the agent's).
+ */
+export declare function keptPrincipal(own: unknown, opts: Pick<PublishOpts, "orgId" | "ownOrg">): Record<string, unknown>;
+/**
+ * `mnemom agent setup [--agent <slug|mnm-id>] [--governance …]` — the explicit provisioning entry
+ * point. An id (`--agent mnm-<uuid>`, or launcher.toml `agent_id`) refreshes that pinned agent's
+ * cards and never claims or births; a malformed `mnm-…` refuses.
+ */
 export declare function agentSetupCommand(opts?: {
     agent?: string;
+    agentId?: string;
     governance?: GovernanceOptIn;
 }): Promise<void>;
 /** Thrown when the agent's org has no spendable MU balance. The user-facing
@@ -256,5 +385,33 @@ export declare function resolvePreflightedAccount(): Promise<{
     orgLabel: string;
     entitlement: CodeEntitlement | null;
 }>;
-export declare function buildCodeAlignmentCard(agentId: string, modes?: Pick<CardModes, "autonomy" | "integrity" | "allowUnmappedTools">): Record<string, unknown>;
+/**
+ * Which default the two cards carry, stamped top-level on both. Semver within the
+ * `mnemom-agent-default/` lineage: a refresh upgrades a card whose content_version is
+ * 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";
+/**
+ * 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.
+ * A card at this version or newer is kept, and so is one stamped by another lineage (its
+ * author versions their own content).
+ */
+export declare function needsContentUpgrade(card: Record<string, unknown>): boolean;
+/** The alignment card's principal: who the agent acts for. */
+export interface CardPrincipal {
+    type: "organization" | "unspecified";
+    identifier?: string;
+    relationship: "delegated_authority";
+}
+/**
+ * The principal for a default card: the org the agent belongs to, else `unspecified`
+ * (never a typed principal with an empty identifier: the API rejects that). Never the
+ * launching user's id: the public A2A card copies the principal, and the identifier
+ * 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 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 {};