@mnemom/mnemom 0.17.0-next.3 → 0.17.0-next.4

package/dist/commands/code-setup.js

@@ -23,7 +23,7 @@
  * birthThroughGateway (wrap.ts), deriveHashProof (agents.ts), claimAgent +
  * putAlignmentCard/putProtectionCard (lib/api.ts) — rather than reinventing it.
  */
-import { claimAgent, getAgentByName, getMuBalance, getMyPersonalOrg, MnemomApiError, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
+import { claimAgent, getAgentByName, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
 import { getAuthInfo, isLoggedIn, loginWithBrowser, loginWithDeviceFlow, resolveAuth, } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.js";
 import { getWebsiteUrl } from "../lib/config.js";
@@ -63,8 +63,18 @@ export async function ensureGovernedAgent(opts) {
     const loggedIn = await isLoggedIn();
     if (loggedIn) {
         const existing = await getAgentByName(slug).catch(() => null);
-        if (existing)
+        if (existing) {
+            // On an EXPLICIT `mnemom code setup`, repair/complete the cards on the
+            // already-claimed agent (e.g. a protection card that failed on a prior run
+            // before we minted its one-time grant). A bare launch leaves it alone.
+            if (opts.setup === true) {
+                say(fmt.dim(`mnemom code: '${slug}' is already claimed — refreshing its cards.`));
+                await publishDefaultCards(existing.id);
+                persistAgentSlug(slug);
+                return { slug, provisioned: true };
+            }
             return { slug, provisioned: false };
+        }
     }
     // 2. Are we allowed to provision here?
     const canProvision = opts.setup === true || (opts.setup !== false && interactive);
@@ -138,6 +148,18 @@ async function tryPublishCard(name, write) {
 /** Publish both default observe-only 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"));
+    // 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 "Provision and claim?" confirm is the
+    // explicit human approval, and the mint endpoint accepts a human operator (only
+    // agent OAuth principals are rejected). The next write consumes the grant. A
+    // mint failure falls through to the write's retry + graceful degrade.
+    try {
+        await mintProtectionCapability(agentId);
+    }
+    catch {
+        // best effort — the protection write below surfaces the real, actionable error
+    }
     const prot = await tryPublishCard("protection", () => putProtectionCard(agentId, JSON.stringify(buildCodeProtectionCard(agentId)), "application/json"));
     if (align.ok && prot.ok) {
         say(fmt.success("mnemom code: observe posture published (alignment + protection observe; goal contracts nudge)."));
@@ -148,7 +170,9 @@ async function publishDefaultCards(agentId) {
     for (const c of [align, prot]) {
         if (c.ok)
             continue;
-        const publishCmd = c.name === "alignment" ? "mnemom card publish" : "mnemom protection publish";
+        // Alignment rides a standing cap, so `mnemom card publish` finishes it; the
+        // protection grant is one-time, so re-running setup (which re-mints) is the fix.
+        const publishCmd = c.name === "alignment" ? "mnemom card publish" : "mnemom code setup";
         say(fmt.warn(`mnemom code: couldn't publish the ${c.name} card — ${c.error}`));
         say(fmt.dim(`  The agent is claimed and running; finish it later with \`${publishCmd}\`.`));
     }

package/dist/lib/api.d.ts

@@ -394,6 +394,16 @@ export interface MuBalance {
     enforcementPausedReason?: string | null;
 }
 export declare function getMuBalance(orgId?: string): Promise<MuBalance>;
+/**
+ * Mint the one-time `cards:write:protection` capability for an agent — the
+ * "locked door" that a plain claim does NOT grant (alignment is a standing cap;
+ * protection is one-time, 15-min TTL, single-use). `POST
+ * /v1/agents/:id/protection-capability` (MNE-876) requires a HUMAN operator
+ * (rejects agent OAuth principals) with org co-manage of the agent, so the CLI's
+ * own login JWT can mint it — no browser grant needed. Consumed by the very next
+ * protection-card write.
+ */
+export declare function mintProtectionCapability(agentId: string): Promise<void>;
 export interface TeamListItem {
     team_id: string;
     name: string;

package/dist/lib/api.js

@@ -379,6 +379,18 @@ export async function getMuBalance(orgId) {
     const q = orgId ? `?org_id=${encodeURIComponent(orgId)}` : "";
     return gFetch(`/v1/billing/mu${q}`, {}, { fallback: "Could not read MU balance" });
 }
+/**
+ * Mint the one-time `cards:write:protection` capability for an agent — the
+ * "locked door" that a plain claim does NOT grant (alignment is a standing cap;
+ * protection is one-time, 15-min TTL, single-use). `POST
+ * /v1/agents/:id/protection-capability` (MNE-876) requires a HUMAN operator
+ * (rejects agent OAuth principals) with org co-manage of the agent, so the CLI's
+ * own login JWT can mint it — no browser grant needed. Consumed by the very next
+ * protection-card write.
+ */
+export async function mintProtectionCapability(agentId) {
+    await gFetch(`/v1/agents/${encodeURIComponent(agentId)}/protection-capability`, { method: "POST" }, { fallback: "Could not mint the protection capability" });
+}
 /**
  * GET /v1/orgs/:org_id/teams for every org the user is a member of,
  * concatenated. The CLI consumer that just wants "every team I can see"

package/package.json

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