@mnemom/mnemom 0.14.5 → 0.15.0

package/dist/commands/activity.d.ts

@@ -0,0 +1,2 @@
+export declare function activityCommand(agentName?: string): Promise<void>;
+export declare const integrityCommand: typeof activityCommand;

package/dist/commands/{integrity.js → activity.js}

@@ -1,6 +1,7 @@
 import { resolveAgentId, getIntegrity, MnemomApiError } from "../lib/api.js";
 import { fmt } from "../lib/format.js";
-export async function integrityCommand(agentName) {
+import { TRACES_PENDING_NOTE } from "../lib/onboarding.js";
+export async function activityCommand(agentName) {
     const agentId = await resolveAgentId(agentName);
     console.log("\nFetching agent activity...\n");
     try {
@@ -18,7 +19,8 @@ export async function integrityCommand(agentName) {
             console.log("\n" + fmt.warn("You have integrity violations. Run `mnemom logs` to investigate.") + "\n");
         }
         else if (integrity.total_traces === 0) {
-            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.\n");
+            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.");
+            console.log("\n" + fmt.dim(TRACES_PENDING_NOTE) + "\n");
         }
         else {
             console.log("\n" + fmt.success("Your agent has a clean integrity record!") + "\n");
@@ -35,7 +37,8 @@ export async function integrityCommand(agentName) {
             console.log(`  ${fmt.label("Total:     ", "0 traces")}`);
             console.log(`  ${fmt.label("Verified:  ", "0")}`);
             console.log(`  ${fmt.label("Violations:", " 0")}`);
-            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.\n");
+            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.");
+            console.log("\n" + fmt.dim(TRACES_PENDING_NOTE) + "\n");
         }
         else {
             const message = error instanceof Error ? error.message : String(error);
@@ -44,6 +47,9 @@ export async function integrityCommand(agentName) {
         }
     }
 }
+// `mnemom integrity` is retained as a deprecated alias of `mnemom activity`
+// (AAP = Activity). It still works and prints a deprecation notice; no breaking change.
+export const integrityCommand = activityCommand;
 function generateScoreBar(score) {
     const filled = Math.round(score * 10);
     const empty = 10 - filled;

package/dist/commands/agents.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { listAgents, listOrgAgents, listMyOrgs, getAgentByName, claimAgent, MnemomApiError, } from "../lib/api.js";
+import { listAgents, listOrgAgents, listMyOrgs, getAgent, getAgentByName, claimAgent, MnemomApiError, } from "../lib/api.js";
 import { requireAuth } from "../lib/auth.js";
 import { fmt } from "../lib/format.js";
 export async function agentsListCommand(options = {}) {
@@ -66,7 +66,7 @@ const FULL_PROOF_RE = /^[0-9a-f]{64}$/;
 // digest and break the claim handshake entirely, so SHA-256 is mandated by the
 // protocol — the "insufficient computational effort" alert is a false positive.
 function sha256Hex(input) {
-    // lgtm[js/insufficient-password-hash] — protocol proof, not password storage (see note above)
+    // codeql[js/insufficient-password-hash] — protocol proof, not password storage; see block comment above
     return createHash("sha256").update(input, "utf8").digest("hex"); // codeql[js/insufficient-password-hash]
 }
 /**
@@ -152,6 +152,15 @@ export async function agentsClaimCommand(idOrName, options = {}) {
             return;
         }
     }
+    else if (!derivationName && options.key && !options.hashProof) {
+        // ID given, no --name, --key will be used for proof derivation: try to
+        // auto-resolve the agent's provisioned name so `claim <id> --key <k>`
+        // works on the first try without requiring an explicit --name.
+        const found = await getAgent(idOrName).catch(() => null);
+        if (found?.name) {
+            derivationName = found.name;
+        }
+    }
     // 2. Establish the hash proof: --hash-proof (raw) takes precedence, else
     //    derive from --key. Exactly one source is needed.
     let hashProof;
@@ -242,6 +251,22 @@ export async function agentsClaimCommand(idOrName, options = {}) {
             process.exit(1);
             return;
         }
+        if (err instanceof MnemomApiError &&
+            err.effectiveStatus === 403 &&
+            (err.code === "invalid_hash_proof" || /hash[ _]?proof/i.test(err.message))) {
+            // The proof derived from --key (and the agent's name) didn't match the
+            // agent's stored proof. Name the real cause instead of the bare "Invalid
+            // hash proof": verify the key, and let the user supply the name when it
+            // couldn't be auto-resolved from the id. Ordered AFTER the not-a-member
+            // 403 (also a 403, distinguished by isNotAMemberError) so it doesn't
+            // shadow the org-teaching path.
+            console.log(fmt.error("Failed to claim agent: the --key (and agent name) didn't match the agent's stored proof (invalid hash proof)."));
+            console.log(fmt.dim(`  Confirm --key is the exact provider key the agent runs with.\n` +
+                `  If the name couldn't be auto-resolved from the id, pass it explicitly:\n` +
+                `    mnemom agents claim ${agentId} --key <key> --name <provisioned-name>`) + "\n");
+            process.exit(1);
+            return;
+        }
         const msg = err instanceof Error ? err.message : String(err);
         console.log(fmt.error(`Failed to claim agent: ${msg}`) + "\n");
         process.exit(1);
@@ -264,8 +289,25 @@ export async function agentsClaimCommand(idOrName, options = {}) {
     }
     console.log(fmt.success(`Claimed ${result.agent_id}.`));
     console.log(fmt.label("  Landed in:", where));
+    if (derivationName) {
+        console.log(fmt.label("  Name:", derivationName));
+    }
     if (result.claimed_at) {
         console.log(fmt.label("  Claimed at:", new Date(result.claimed_at).toLocaleString()));
     }
+    // Bridge to the next step (MNE-610). The dogfood dead-end was: claim with a
+    // friendly --name, then `mnemom card publish --agent <name>` returns an
+    // opaque "agent not found" while the freshly-claimed agent propagates into
+    // the listing the name-resolver reads. Always surface a ready-to-paste
+    // command keyed on the CANONICAL agent id, which `resolveAgentId` accepts
+    // verbatim (no list lookup) — so the publish step never dead-ends regardless
+    // of listing propagation. The friendly name is shown as the eventual
+    // shorthand, not the recommended first move.
+    console.log();
+    console.log(fmt.dim("  Next — publish your alignment card with the canonical id:"));
+    console.log(fmt.dim(`    mnemom card publish <file.yaml> --agent ${result.agent_id}`));
+    if (derivationName) {
+        console.log(fmt.dim(`  Once it appears in \`mnemom agents\`, you can use the name instead: --agent ${derivationName}`));
+    }
     console.log();
 }

package/dist/commands/api-key.js

@@ -64,7 +64,11 @@ function formatRow(key) {
 }
 // ─── mnemom api-key list ─────────────────────────────────────────────────
 export async function apiKeyListCommand(opts) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        console.log(fmt.warn("API keys are agent-scoped; run mnemom login to manage personal API keys"));
+        return;
+    }
     let keys;
     try {
         keys = await listApiKeys();
@@ -92,7 +96,11 @@ export async function apiKeyListCommand(opts) {
 }
 // ─── mnemom api-key create ───────────────────────────────────────────────
 export async function apiKeyCreateCommand(opts) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        console.log(fmt.warn("API keys are agent-scoped; run mnemom login to manage personal API keys"));
+        return;
+    }
     if (!opts.name || opts.name.trim() === "") {
         console.error(fmt.error("--name is required. Example: --name 'ci-prod'"));
         process.exit(1);
@@ -133,7 +141,11 @@ export async function apiKeyCreateCommand(opts) {
 }
 // ─── mnemom api-key rotate ───────────────────────────────────────────────
 export async function apiKeyRotateCommand(keyId, opts) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        console.log(fmt.warn("API keys are agent-scoped; run mnemom login to manage personal API keys"));
+        return;
+    }
     if (!keyId) {
         console.error(fmt.error("Usage: mnemom api-key rotate <key_id>"));
         process.exit(1);
@@ -163,7 +175,11 @@ export async function apiKeyRotateCommand(keyId, opts) {
 }
 // ─── mnemom api-key revoke ───────────────────────────────────────────────
 export async function apiKeyRevokeCommand(keyId) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        console.log(fmt.warn("API keys are agent-scoped; run mnemom login to manage personal API keys"));
+        return;
+    }
     if (!keyId) {
         console.error(fmt.error("Usage: mnemom api-key revoke <key_id>"));
         process.exit(1);

package/dist/commands/auth.js

@@ -1,29 +1,13 @@
-import { getAuthInfo, clearAuthTokens, loginWithBrowser, loginWithPassword } from "../lib/auth.js";
+import { getAuthInfo, clearAuthTokens, loginWithBrowser, loginWithDeviceFlow, resolveAuth, } from "../lib/auth.js";
 import { fmt } from "../lib/format.js";
-import { askInput } from "../lib/prompt.js";
 export async function loginCommand(options = {}) {
     try {
-        let tokens;
-        if (options.noBrowser) {
-            const email = await askInput("Email:");
-            if (!email) {
-                console.log(fmt.error("Email is required."));
-                process.exit(1);
-            }
-            const password = await askInput("Password:", true);
-            if (!password) {
-                console.log(fmt.error("Password is required."));
-                process.exit(1);
-            }
-            tokens = await loginWithPassword(email, password);
-        }
-        else {
-            tokens = await loginWithBrowser();
-        }
+        // --no-browser → RFC 8628 device flow (headless / SSH / no local browser).
+        // Default → OAuth 2.1 authorization-code + PKCE with a loopback redirect.
+        const tokens = options.noBrowser ? await loginWithDeviceFlow() : await loginWithBrowser();
         console.log();
         console.log(fmt.success("Logged in successfully!"));
-        console.log(fmt.label("  Email:  ", ` ${tokens.email}`));
-        console.log(fmt.label("  User ID:", ` ${tokens.userId}`));
+        printGrant(tokens);
         console.log();
     }
     catch (error) {
@@ -32,11 +16,37 @@ export async function loginCommand(options = {}) {
         process.exit(1);
     }
 }
+/**
+ * Print what the issued token actually grants. OAuth access tokens are scoped
+ * and (deliberately) carry no user identity, so we show scope + expiry rather
+ * than fabricating an email/user id we don't have.
+ */
+function printGrant(tokens) {
+    if (tokens.email)
+        console.log(fmt.label("  Email:  ", ` ${tokens.email}`));
+    if (tokens.scope)
+        console.log(fmt.label("  Scope:  ", ` ${tokens.scope}`));
+    const expiresDate = new Date(tokens.expiresAt * 1000).toISOString();
+    console.log(fmt.label("  Expires:", ` ${expiresDate}`));
+}
 export async function logoutCommand() {
     clearAuthTokens();
     console.log(fmt.success("Logged out."));
 }
 export async function whoamiCommand() {
+    const cred = await resolveAuth();
+    if (cred.type === "none") {
+        console.log("\nNot logged in. Run `mnemom login` to authenticate.\n");
+        return;
+    }
+    if (cred.type === "api-key") {
+        console.log(fmt.header("Auth Status"));
+        console.log();
+        console.log(fmt.label("  Credential Type:", " API key"));
+        console.log(fmt.label("  Status:         ", " valid (no expiry)"));
+        console.log();
+        return;
+    }
     const auth = getAuthInfo();
     if (!auth) {
         console.log("\nNot logged in. Run `mnemom login` to authenticate.\n");
@@ -47,8 +57,14 @@ export async function whoamiCommand() {
     const expiresDate = new Date(auth.expiresAt * 1000).toISOString();
     console.log(fmt.header("Auth Status"));
     console.log();
-    console.log(fmt.label("  Email:  ", ` ${auth.email}`));
-    console.log(fmt.label("  User ID:", ` ${auth.userId}`));
+    // OAuth access tokens are opaque and carry no identity; legacy sessions may
+    // still have email/userId. Show whatever the stored grant actually has.
+    if (auth.email)
+        console.log(fmt.label("  Email:  ", ` ${auth.email}`));
+    if (auth.userId)
+        console.log(fmt.label("  User ID:", ` ${auth.userId}`));
+    if (auth.scope)
+        console.log(fmt.label("  Scope:  ", ` ${auth.scope}`));
     console.log(fmt.label("  Token:  ", expired ? " expired" : ` valid until ${expiresDate}`));
     console.log();
 }

package/dist/commands/card.js

@@ -654,8 +654,23 @@ export async function cardPublishCommand(file, agentName, options = {}) {
         console.log();
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.log("\n" + fmt.error(`Failed to publish card: ${message}`) + "\n");
+        if (error instanceof MnemomApiError) {
+            if (error.effectiveStatus === 404) {
+                console.log("\n" +
+                    fmt.error("Agent found but not writable: you can see this agent locally, but cannot publish to it in its current organization context.") +
+                    "\n");
+            }
+            else if (error.effectiveStatus === 401) {
+                console.log("\n" + fmt.error(`Authentication failed: ${error.message}`) + "\n");
+            }
+            else {
+                console.log("\n" + fmt.error(`Failed to publish card: ${error.message}`) + "\n");
+            }
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log("\n" + fmt.error(`Failed to publish card: ${message}`) + "\n");
+        }
         process.exit(1);
     }
 }

package/dist/commands/logs.js

@@ -1,6 +1,7 @@
 import { resolveAgentId, getTraces, MnemomApiError, } from "../lib/api.js";
 import { getGatewayUrl, getWebsiteUrl } from "../lib/config.js";
 import { fmt } from "../lib/format.js";
+import { TRACES_PENDING_NOTE, gatewayIntegrationHelp } from "../lib/onboarding.js";
 export async function logsCommand(options = {}) {
     const agentId = await resolveAgentId(options.agentName);
     const gatewayUrl = getGatewayUrl();
@@ -10,9 +11,8 @@ export async function logsCommand(options = {}) {
         const traces = await getTraces(agentId, limit);
         if (traces.length === 0) {
             console.log(fmt.header("No traces found"));
-            console.log("\nStart using Claude to generate traces.\n");
-            console.log("Make sure ANTHROPIC_BASE_URL is set correctly:\n");
-            console.log(`  export ANTHROPIC_BASE_URL="${gatewayUrl}/v1/proxy/${agentId}"\n`);
+            console.log("\n" + TRACES_PENDING_NOTE + "\n");
+            console.log(gatewayIntegrationHelp(gatewayUrl, options.agentName) + "\n");
             return;
         }
         console.log(fmt.header(`Recent Traces (${traces.length})`));
@@ -29,7 +29,8 @@ export async function logsCommand(options = {}) {
         // effectiveStatus surfaces the true status (=== status when documented).
         if (error instanceof MnemomApiError && error.effectiveStatus === 404) {
             console.log(fmt.header("No traces found"));
-            console.log("\nStart using Claude to generate traces.\n");
+            console.log("\n" + TRACES_PENDING_NOTE + "\n");
+            console.log(gatewayIntegrationHelp(gatewayUrl, options.agentName) + "\n");
         }
         else {
             const message = error instanceof Error ? error.message : String(error);
@@ -51,8 +52,15 @@ function displayTrace(trace) {
     // shape); fall back to the action type, then a dash.
     const actionLabel = trace.action?.name ?? trace.action?.type ?? "—";
     console.log(`  ${fmt.label("Action:", ` ${actionLabel}`)}`);
+    // A pure-LLM inference turn carries category "escalation_trigger" on the wire
+    // (it is the *point at which* an escalation could fire, not a turn that demanded
+    // one). Rendering that raw reads as if every benign turn escalated, so present a
+    // friendly label instead. Presentation-only — the underlying category is unchanged.
     if (trace.action?.category) {
-        console.log(`  ${fmt.label("Type:  ", ` ${trace.action.category}`)}`);
+        const categoryLabel = trace.action.category === "escalation_trigger" && trace.action.name === "inference"
+            ? "inference (no tool)"
+            : trace.action.category;
+        console.log(`  ${fmt.label("Type:  ", ` ${categoryLabel}`)}`);
     }
     const reasoning = trace.decision?.selection_reasoning;
     if (reasoning) {

package/dist/commands/org.js

@@ -10,7 +10,11 @@ import { fmt } from "../lib/format.js";
  * machine-readable output.
  */
 export async function orgListCommand(opts) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        console.log(fmt.warn("API keys are agent-scoped; run mnemom login for org/key management"));
+        return;
+    }
     let orgs;
     try {
         orgs = await listMyOrgs();
@@ -56,7 +60,16 @@ export async function orgListCommand(opts) {
  * exactly one membership, that one).
  */
 export async function orgShowCommand(orgIdArg, opts) {
-    await requireAuth();
+    const cred = await requireAuth();
+    if (cred.type === "api-key") {
+        if (opts.personal || orgIdArg) {
+            console.log(fmt.warn("API keys cannot filter by organization. Run mnemom login to authenticate as a user and list org-scoped agents."));
+        }
+        else {
+            console.log(fmt.warn("API keys are agent-scoped; run mnemom login for org/key management"));
+        }
+        return;
+    }
     let target;
     try {
         if (opts.personal) {

package/dist/commands/protection.d.ts

@@ -9,7 +9,8 @@ export interface ValidationCheck {
  * Required: card_version, agent_id, mode (off|observe|nudge|enforce).
  * Optional: thresholds (warn ≤ quarantine ≤ block, all in [0,1]),
  *           screen_surfaces (object of bools with the four named keys),
- *           trusted_sources (object of typed buckets, per-bucket deny-lists).
+ *           trusted_sources (object of typed buckets, per-bucket deny-lists),
+ *           protected_surface (org-declared asset policy — MNE-830/833).
  */
 export declare function validateProtectionCard(card: Record<string, unknown>): ValidationCheck[];
 export declare function protectionShowCommand(agentName?: string): Promise<void>;

package/dist/commands/protection.js

@@ -9,6 +9,8 @@ import { fmt } from "../lib/format.js";
 import { askYesNo, isInteractive } from "../lib/prompt.js";
 const PROTECTION_MODES = ["off", "observe", "nudge", "enforce"];
 const SURFACE_KEYS = ["incoming", "outgoing", "tool_calls", "tool_responses"];
+// Mirrors mnemom-api/src/composition/validate.ts OP_SEVERITIES (MNE-833).
+const OP_SEVERITIES = ["low", "medium", "high", "critical"];
 // Per ADR-037 Decision 4: deny public LLM endpoints + public DNS providers,
 // and the any-host CIDRs, at write time.
 // T8-4 (2026-05-19) extended the corpus per
@@ -133,13 +135,152 @@ function validateTrustedBucket(name, bucket, checks, perEntry) {
         });
     }
 }
+// ── protected_surface helpers (MNE-833) ─────────────────────────────────────
+// Mirrors mnemom-api/src/composition/validate.ts validateProtectedSurface +
+// validateOpArray. Both codebases live in different repos; keep in sync.
+function validateOpArray(name, value, checks, withSeverity) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value)) {
+        checks.push({
+            name: `protected_surface.${name}`,
+            passed: false,
+            message: `protected_surface.${name} must be an array.`,
+        });
+        return;
+    }
+    value.forEach((entry, i) => {
+        if (!isObject(entry)) {
+            checks.push({
+                name: `protected_surface.${name}[${i}]`,
+                passed: false,
+                message: `each protected_surface.${name} entry must be an object.`,
+            });
+            return;
+        }
+        const op = entry;
+        if (typeof op.pattern !== "string" || op.pattern.length === 0) {
+            checks.push({
+                name: `protected_surface.${name}[${i}].pattern`,
+                passed: false,
+                message: `protected_surface.${name}[].pattern is required (non-empty string).`,
+            });
+        }
+        if (op.applies_to !== undefined) {
+            if (!Array.isArray(op.applies_to)) {
+                checks.push({
+                    name: `protected_surface.${name}[${i}].applies_to`,
+                    passed: false,
+                    message: `protected_surface.${name}[].applies_to must be an array of asset-identity strings.`,
+                });
+            }
+            else if (!op.applies_to.every((x) => typeof x === "string")) {
+                checks.push({
+                    name: `protected_surface.${name}[${i}].applies_to`,
+                    passed: false,
+                    message: `protected_surface.${name}[].applies_to entries must be strings.`,
+                });
+            }
+        }
+        if (withSeverity &&
+            op.severity !== undefined &&
+            !OP_SEVERITIES.includes(String(op.severity))) {
+            checks.push({
+                name: `protected_surface.${name}[${i}].severity`,
+                passed: false,
+                message: `protected_surface.${name}[].severity must be one of: ${OP_SEVERITIES.join(", ")}.`,
+            });
+        }
+        if (op.reason !== undefined && typeof op.reason !== "string") {
+            checks.push({
+                name: `protected_surface.${name}[${i}].reason`,
+                passed: false,
+                message: `protected_surface.${name}[].reason must be a string.`,
+            });
+        }
+    });
+}
+function validateProtectedSurface(input, checks) {
+    if (!isObject(input)) {
+        checks.push({
+            name: "protected_surface",
+            passed: false,
+            message: "protected_surface must be an object with assets, forbidden_operations, escalation_required arrays.",
+        });
+        return;
+    }
+    const ps = input;
+    // assets[] — each needs a non-empty string kind + selector (intrinsic identity).
+    if (ps.assets !== undefined) {
+        if (!Array.isArray(ps.assets)) {
+            checks.push({
+                name: "protected_surface.assets",
+                passed: false,
+                message: "protected_surface.assets must be an array.",
+            });
+        }
+        else {
+            ps.assets.forEach((entry, i) => {
+                if (!isObject(entry)) {
+                    checks.push({
+                        name: `protected_surface.assets[${i}]`,
+                        passed: false,
+                        message: "each protected_surface.assets entry must be an object.",
+                    });
+                    return;
+                }
+                const a = entry;
+                if (typeof a.kind !== "string" || a.kind.length === 0) {
+                    checks.push({
+                        name: `protected_surface.assets[${i}].kind`,
+                        passed: false,
+                        message: "protected_surface.assets[].kind is required (non-empty string).",
+                    });
+                }
+                if (typeof a.selector !== "string" || a.selector.length === 0) {
+                    checks.push({
+                        name: `protected_surface.assets[${i}].selector`,
+                        passed: false,
+                        message: "protected_surface.assets[].selector is required (non-empty string).",
+                    });
+                }
+                if (a.label !== undefined && typeof a.label !== "string") {
+                    checks.push({
+                        name: `protected_surface.assets[${i}].label`,
+                        passed: false,
+                        message: "protected_surface.assets[].label must be a string.",
+                    });
+                }
+                if (a.reason !== undefined && typeof a.reason !== "string") {
+                    checks.push({
+                        name: `protected_surface.assets[${i}].reason`,
+                        passed: false,
+                        message: "protected_surface.assets[].reason must be a string.",
+                    });
+                }
+            });
+        }
+    }
+    validateOpArray("forbidden_operations", ps.forbidden_operations, checks, /* withSeverity */ true);
+    validateOpArray("escalation_required", ps.escalation_required, checks, /* withSeverity */ false);
+    for (const key of Object.keys(ps)) {
+        if (!["assets", "forbidden_operations", "escalation_required"].includes(key)) {
+            checks.push({
+                name: `protected_surface.${key}`,
+                passed: false,
+                message: `protected_surface.${key} is not a recognized key (allowed: assets, forbidden_operations, escalation_required).`,
+            });
+        }
+    }
+}
 /**
  * Validate a protection card against ADR-037 canonical form.
  *
  * Required: card_version, agent_id, mode (off|observe|nudge|enforce).
  * Optional: thresholds (warn ≤ quarantine ≤ block, all in [0,1]),
  *           screen_surfaces (object of bools with the four named keys),
- *           trusted_sources (object of typed buckets, per-bucket deny-lists).
+ *           trusted_sources (object of typed buckets, per-bucket deny-lists),
+ *           protected_surface (org-declared asset policy — MNE-830/833).
  */
 export function validateProtectionCard(card) {
     const checks = [];
@@ -324,6 +465,10 @@ export function validateProtectionCard(card) {
             }
         }
     }
+    // ── protected_surface (optional, MNE-830/833) ──
+    if (card.protected_surface !== undefined) {
+        validateProtectedSurface(card.protected_surface, checks);
+    }
     return checks;
 }
 // ============================================================================
@@ -438,8 +583,23 @@ export async function protectionPublishCommand(file, agentName, options = {}) {
         console.log();
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.log("\n" + fmt.error(`Failed to publish protection card: ${message}`) + "\n");
+        if (error instanceof MnemomApiError) {
+            if (error.effectiveStatus === 404) {
+                console.log("\n" +
+                    fmt.error("Agent found but not writable: you can see this agent locally, but cannot publish to it in its current organization context.") +
+                    "\n");
+            }
+            else if (error.effectiveStatus === 401) {
+                console.log("\n" + fmt.error(`Authentication failed: ${error.message}`) + "\n");
+            }
+            else {
+                console.log("\n" + fmt.error(`Failed to publish protection card: ${error.message}`) + "\n");
+            }
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log("\n" + fmt.error(`Failed to publish protection card: ${message}`) + "\n");
+        }
         process.exit(1);
     }
 }

package/dist/commands/status.js

@@ -2,6 +2,7 @@ import { getGatewayUrl, getWebsiteUrl } from "../lib/config.js";
 import { resolveAgentId, getAgent, getIntegrity, getTraces, MnemomApiError } from "../lib/api.js";
 import { isLoggedIn, getAuthInfo } from "../lib/auth.js";
 import { fmt } from "../lib/format.js";
+import { TRACES_PENDING_NOTE } from "../lib/onboarding.js";
 export async function statusCommand(agentName) {
     console.log(fmt.header("mnemom status"));
     console.log();
@@ -63,10 +64,13 @@ async function checkAuthStatus() {
     }
     const auth = getAuthInfo();
     if (auth) {
+        // OAuth tokens carry no identity; fall back to the granted scope (or a
+        // generic message) rather than printing "Logged in as undefined".
+        const who = auth.email ?? (auth.scope ? `scope ${auth.scope}` : "OAuth session");
         return {
             name: "Authentication",
             status: "ok",
-            message: `Logged in as ${auth.email}`,
+            message: `Logged in as ${who}`,
         };
     }
     // API key auth (no email available)
@@ -195,6 +199,8 @@ async function showTraceSummary(agentId) {
         }
         else {
             console.log("\nLast Activity:   None");
+            // Eventual consistency: don't let a just-sent request read as "broken".
+            console.log("\n" + fmt.dim(TRACES_PENDING_NOTE));
         }
     }
     catch {