@mnemom/mnemom 0.14.6 → 0.15.1-next.0

package/dist/commands/try-me.js

@@ -0,0 +1,374 @@
+/**
+ * `mnemom try-me <token>` — the universal, deterministic Dojo-onboarding runner
+ * (MNE-934, epic MNE-931).
+ *
+ * Executes the shipped v5.0 briefing manifest's flow so an arbitrary agent/human
+ * on a fresh machine doesn't have to improvise it: resolve → name → be born →
+ * hand off (human claims in the browser) → set alignment → open a one-time grant
+ * (human approves in the browser) → set protection → hand off to the Dojo.
+ *
+ * DEMO-SAFE BY CONSTRUCTION:
+ *   - Additive: a NEW verb; it modifies no existing command and touches no
+ *     backend/website. It consumes Alex's shipped endpoints READ-ONLY (resolve,
+ *     gateway birth, public claim poll) + the canonical card-write client.
+ *   - The two privileged human acts stay in the human's browser: the claim
+ *     sign-in (step 4) and the one-time protection grant (step 6). The command
+ *     only orchestrates + polls — it never forges the human's session.
+ *
+ * AUTH MODEL (see the runner report / MNE-934): the canonical card-write PUTs
+ * (`/v1/{alignment,protection}/agent/:id`) authorize on the human's ORG
+ * MEMBERSHIP (ADR-062) and accept the human's `mnemom login` JWT or
+ * `MNEMOM_API_KEY` — NOT the birth token. So before the card writes the runner
+ * ensures a CLI session (offering `mnemom login`, one-click after the claim
+ * sign-in). That session IS the human's own — it is the headless twin of the
+ * host-connector authorization in the MCP flow, not a forged credential.
+ */
+import { resolveBriefing, birthAgent, fetchAgentClaimed, buildClaimUrl, buildGrantUrl, buildDojoDeepLink, claimProof, isTokenMode, looksLikeTryMeToken, sleep, } from "../lib/try-me.js";
+import { putAlignmentCard, putProtectionCard, MnemomApiError } from "../lib/api.js";
+import { resolveAuth, loginWithBrowser, loginWithDeviceFlow } from "../lib/auth.js";
+import { openBrowser } from "../lib/oauth.js";
+import { askSelect, askInput, askYesNo, isInteractive } from "../lib/prompt.js";
+import { getApiUrl } from "../lib/config.js";
+import { fmt } from "../lib/format.js";
+const POLL_INTERVAL_MS = 3000;
+/**
+ * Entry point for `mnemom try-me <token>`. Throws on fatal misconfiguration
+ * (caught by the index.ts wrapper, which prints + exits non-zero); soft failures
+ * are surfaced as human guidance.
+ */
+export async function tryMeCommand(token, options = {}) {
+    const json = !!options.json;
+    // JSON output is only coherent non-interactively — no prompts can be shown.
+    const nonInteractive = !!options.yes || json || !isInteractive();
+    // The name pick is a deliberate human-handoff checkpoint (the manifest marks
+    // it human_handoff:true). It must fire on EVERY real run — agent-driven,
+    // piped, and inherited-stdin runs all report isTTY=false yet can still answer
+    // a prompt — so it is auto-skipped ONLY on an explicit non-interactive
+    // request: --yes, --json, or --name (the last handled inside pickName). It is
+    // intentionally NOT gated on isInteractive(), unlike the open/login prompts.
+    const skipNamePrompt = !!options.yes || json;
+    const autoOpen = options.open !== false; // --no-open → false
+    const result = { token, version: "", dry_run: !!options.dryRun, steps: [] };
+    // A human-facing log that is silenced in --json mode (the JSON is the output).
+    const say = (line = "") => {
+        if (!json)
+            console.log(line);
+    };
+    if (!looksLikeTryMeToken(token)) {
+        throw new Error(`'${token}' doesn't look like a try-me token (expected e.g. tryme_…). ` +
+            "Copy the token from your Dojo /try-me invite.");
+    }
+    // ── State: resolve ────────────────────────────────────────────────────────
+    say(fmt.header("Mnemom Dojo — try-me"));
+    say();
+    say(fmt.dim(`Resolving briefing for token ${token}…`));
+    const manifest = await resolveBriefing(token, { apiBase: options.api });
+    result.version = manifest.version;
+    result.steps.push({ step: "resolve", status: "ok", detail: `manifest v${manifest.version}` });
+    if (options.dryRun) {
+        if (json) {
+            console.log(JSON.stringify(buildDryRunJson(manifest), null, 2));
+        }
+        else {
+            console.log(renderPlan(manifest));
+        }
+        return;
+    }
+    const apiBase = (options.api ?? getApiUrl()).replace(/\/$/, "");
+    // ── State: name (human checkpoint) ──────────────────────────────────────────
+    const name = await pickName(manifest, options, skipNamePrompt, say);
+    result.steps.push({ step: "name", status: "ok", detail: name });
+    // ── State: birth ────────────────────────────────────────────────────────────
+    let agentId;
+    if (options.agent) {
+        agentId = options.agent;
+        result.steps.push({ step: "birth", status: "skipped", detail: `using --resume ${agentId}` });
+        say(fmt.dim(`Skipping birth — resuming with agent ${agentId}.`));
+    }
+    else {
+        say();
+        say(`${fmt.badge("birth", "cyan")} Registering your identity with Mnemom (your first model call)…`);
+        const born = await birthAgent(manifest, name);
+        agentId = born.agentId;
+        result.agent_id = agentId;
+        result.steps.push({ step: "birth", status: "ok", detail: agentId });
+        say(fmt.success(`Born as ${fmt.badge(name, "magenta")} → ${agentId}`));
+    }
+    result.agent_id = agentId;
+    // ── State: claim (human handoff, then poll) ─────────────────────────────────
+    const proof = isTokenMode(manifest) ? claimProof(manifest) : missingLegacyProof(); // token mode is the shipped reality; legacy is unsupported here
+    const claimUrl = buildClaimUrl(manifest, agentId, proof);
+    say();
+    say(`${fmt.badge("claim", "cyan")} Your turn — sign in and claim ${name} into your org.`);
+    await offerToOpen(claimUrl, "the claim page", { nonInteractive, autoOpen, say });
+    say(fmt.dim(`(Brand new? You can create your account at ${manifest.handoff.signup_url}.)`));
+    say(fmt.dim("Waiting for you to finish signing in / creating your account…"));
+    const claimed = await pollUntilClaimed(apiBase, agentId, options.pollTimeout ?? 600, say);
+    if (!claimed) {
+        result.steps.push({ step: "claim", status: "pending", detail: "not claimed before timeout" });
+        if (json)
+            console.log(JSON.stringify(result, null, 2));
+        throw new Error(`${agentId} wasn't claimed in time. Finish the claim at the link above, then re-run with ` +
+            `--resume ${agentId} to resume (your birth credential is reusable within the manifest window).`);
+    }
+    result.claimed = true;
+    result.steps.push({ step: "claim", status: "ok", detail: agentId });
+    say(fmt.success("Claimed — you now own this agent."));
+    // ── Ensure a CLI session for the card writes (the human's own login) ────────
+    await ensureSession({ nonInteractive, autoOpen, agentId, say });
+    // ── State: alignment (set directly with the post-claim session) ─────────────
+    say();
+    say(`${fmt.badge("alignment", "cyan")} Publishing your alignment card — your signed, public statement of intent…`);
+    await writeCardWithRetry("alignment", agentId, manifest.declare.alignment_card, options.pollTimeout ?? 600, say);
+    result.alignment = "set";
+    result.steps.push({ step: "alignment", status: "ok" });
+    say(fmt.success("Alignment card set."));
+    // ── State: protection (one-time grant in the browser, then write) ───────────
+    say();
+    say(`${fmt.badge("protection", "cyan")} Your protection card needs a one-time grant (the CISO moment).`);
+    const grantUrl = buildGrantUrl(manifest, agentId);
+    await offerToOpen(grantUrl, "the one-time protection-grant page", {
+        nonInteractive,
+        autoOpen,
+        say,
+    });
+    say(fmt.dim("Waiting for your approval, then setting the protection card…"));
+    await writeCardWithRetry("protection", agentId, manifest.declare.protection_card, options.pollTimeout ?? 600, say);
+    result.protection = "set";
+    result.steps.push({ step: "protection", status: "ok" });
+    say(fmt.success("Protection card set."));
+    // ── State: hand off to the Dojo ─────────────────────────────────────────────
+    const dojoUrl = buildDojoDeepLink(manifest, agentId);
+    result.dojo_url = dojoUrl;
+    say();
+    say(`${fmt.badge("dojo", "cyan")} You're verified and armed — opening the Dojo so you can press Begin Sim.`);
+    await offerToOpen(dojoUrl, "the Dojo (you're pre-selected)", { nonInteractive, autoOpen, say });
+    result.steps.push({ step: "handoff", status: "ok", detail: dojoUrl });
+    say();
+    say(renderRecount(manifest, name, agentId));
+    if (json)
+        console.log(JSON.stringify(result, null, 2));
+}
+// ── name (human checkpoint) ──────────────────────────────────────────────────
+async function pickName(manifest, options, skipPrompt, say) {
+    if (options.name && options.name.trim())
+        return options.name.trim();
+    const opts = manifest.handoff.name_options ?? [];
+    const fallback = opts[0] ?? "mnemom-dojo-agent";
+    if (skipPrompt) {
+        say(fmt.dim(`Non-interactive: naming the agent "${fallback}" (override with --name).`));
+        return fallback;
+    }
+    say();
+    const TYPE_MY_OWN = "Type my own";
+    const choice = await askSelect(manifest.handoff.name_question, [...opts, TYPE_MY_OWN]);
+    if (choice && choice !== TYPE_MY_OWN)
+        return choice;
+    // "Type my own" — or no valid selection — falls through to free-form entry.
+    for (;;) {
+        const typed = (await askInput("Enter a name for your agent:")).trim();
+        if (typed)
+            return typed;
+        // A non-responsive stream (EOF on a pipe) returns "" on every read; don't
+        // spin forever — fall back to the default so an unattended run completes.
+        if (!process.stdin.isTTY) {
+            say(fmt.warn(`No name entered on a non-interactive stream — using "${fallback}".`));
+            return fallback;
+        }
+        say(fmt.warn("A name is required (it's permanent) — please enter one."));
+    }
+}
+/** Token mode is the shipped reality; legacy provider-key claims aren't supported by this runner. */
+function missingLegacyProof() {
+    throw new Error("This briefing is a legacy provider-key flow; `mnemom try-me` supports token-mode (mnbt_) " +
+        "briefings. Follow the manifest's steps manually, or ask for a token-mode invite.");
+}
+// ── offer-to-open (enter-default = open it for me) ──────────────────────────
+async function offerToOpen(url, what, ctx) {
+    ctx.say(fmt.label(`  Link:`, url));
+    if (!ctx.autoOpen) {
+        ctx.say(fmt.dim(`  Open ${what} in your browser, then come back here.`));
+        return "printed";
+    }
+    if (ctx.nonInteractive) {
+        openBrowser(url);
+        ctx.say(fmt.dim(`  Opened ${what} in your browser.`));
+        return "opened";
+    }
+    // Enter-default is the FIRST choice — "Open it for me".
+    const choice = await askSelect(`Open ${what}?`, ["Open it for me", "I'll open it myself"]);
+    if (choice === "I'll open it myself") {
+        ctx.say(fmt.dim(`  Okay — open the link above when you're ready.`));
+        return "printed";
+    }
+    // Default (enter / first choice / unrecognized) → open it.
+    openBrowser(url);
+    ctx.say(fmt.dim(`  Opened ${what} in your browser.`));
+    return "opened";
+}
+// ── claim poll ───────────────────────────────────────────────────────────────
+async function pollUntilClaimed(apiBase, agentId, timeoutSeconds, say) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let waited = 0;
+    for (;;) {
+        const status = await fetchAgentClaimed(apiBase, agentId);
+        if (status?.claimed)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await sleep(POLL_INTERVAL_MS);
+        waited += POLL_INTERVAL_MS;
+        // A gentle heartbeat every ~30s so a multi-minute signup doesn't look hung.
+        if (waited % 30000 === 0)
+            say(fmt.dim(`  …still waiting for the claim (${waited / 1000}s).`));
+    }
+}
+// ── CLI session for the card writes ──────────────────────────────────────────
+/**
+ * Ensure the CLI holds the human's session before the card writes. The card-write
+ * PUTs authorize on org membership and need the human's JWT/API-key — the
+ * headless twin of the MCP host-connector authorization. If unauthenticated, offer
+ * a one-click `mnemom login` (one-click since the human just signed in to claim).
+ */
+async function ensureSession(ctx) {
+    const cred = await resolveAuth();
+    if (cred.type !== "none")
+        return;
+    ctx.say();
+    ctx.say(fmt.dim("To set your cards as you, the CLI needs your Mnemom session — this is the headless twin of " +
+        "the host-connector authorization (your own login, not a forged credential)."));
+    if (ctx.nonInteractive) {
+        throw new Error("Not authenticated. Run `mnemom login` (or set MNEMOM_TOKEN / MNEMOM_API_KEY) first, then " +
+            `re-run with --resume ${ctx.agentId} to resume after the claim.`);
+    }
+    const ok = await askYesNo("Sign in now? (one-click — you just signed in to claim)", true);
+    if (!ok) {
+        throw new Error("A Mnemom session is required to set the cards. Run `mnemom login`, then re-run with " +
+            `--resume ${ctx.agentId} to resume.`);
+    }
+    // No local browser (e.g. SSH) → device flow; otherwise the loopback OAuth flow.
+    if (ctx.autoOpen) {
+        await loginWithBrowser();
+    }
+    else {
+        await loginWithDeviceFlow();
+    }
+    ctx.say(fmt.success("Signed in."));
+}
+// ── card writes (retry on first-auth / grant propagation) ───────────────────
+/**
+ * Write a card, retrying while the server reports the caller isn't yet authorized
+ * (401 / 403). For alignment this absorbs the brief org-membership propagation
+ * right after the claim; for protection it ALSO absorbs the one-time grant landing
+ * (the manifest's 403 insufficient_scope → keep polling; first 200 → done). Any
+ * other status is a real error and is surfaced immediately.
+ */
+async function writeCardWithRetry(kind, agentId, card, timeoutSeconds, say) {
+    const body = JSON.stringify(card);
+    const put = kind === "alignment" ? putAlignmentCard : putProtectionCard;
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let waited = 0;
+    for (;;) {
+        try {
+            await put(agentId, body, "application/json");
+            return;
+        }
+        catch (err) {
+            const status = err instanceof MnemomApiError ? err.effectiveStatus : undefined;
+            const retriable = status === 401 || status === 403;
+            if (!retriable || Date.now() >= deadline) {
+                if (retriable) {
+                    throw new Error(`Timed out waiting to set the ${kind} card (last status ${status}). ` +
+                        (kind === "protection"
+                            ? "Make sure you approved the one-time grant, then re-run with --resume " +
+                                agentId +
+                                "."
+                            : "Re-run with --resume " + agentId + " to resume."), { cause: err });
+                }
+                throw err;
+            }
+            await sleep(POLL_INTERVAL_MS);
+            waited += POLL_INTERVAL_MS;
+            if (waited % 15000 === 0) {
+                say(fmt.dim(`  …waiting to set the ${kind} card (${waited / 1000}s)` +
+                    (kind === "protection"
+                        ? " — approve the grant in your browser if you haven't."
+                        : ".")));
+            }
+        }
+    }
+}
+// ── dry-run rendering ────────────────────────────────────────────────────────
+/** Render the resolved plan as human-readable text (no side effects). */
+export function renderPlan(manifest) {
+    const L = [];
+    const mission = manifest.mission ?? {};
+    const credKind = isTokenMode(manifest) ? "birth_token (mnbt_…)" : "provider_key (legacy)";
+    L.push(fmt.header("Mnemom Dojo — try-me (dry run)"));
+    L.push("");
+    L.push(fmt.label("  Manifest:", `v${manifest.version}  ·  token ${manifest.token}`));
+    if (mission.name)
+        L.push(fmt.label("  Mission: ", `${mission.name} (${mission.scenario_id ?? "?"})`));
+    L.push(fmt.label("  Model:   ", `${manifest.gateway.provider} / ${manifest.gateway.model} via ${manifest.gateway.endpoint}`));
+    L.push(fmt.label("  Credential:", credKind));
+    L.push("");
+    L.push(fmt.dim("  The runner will, with NO side effects in this dry run:"));
+    L.push(`   1. ${fmt.badge("name", "cyan")}   ask: "${manifest.handoff.name_question}"`);
+    L.push(fmt.dim(`        options: ${(manifest.handoff.name_options ?? []).join(", ")}, or type your own`));
+    L.push(`   2. ${fmt.badge("birth", "cyan")}  POST ${manifest.gateway.endpoint}/v1/messages`);
+    L.push(fmt.dim(`        headers: ${manifest.gateway.key_header}: <${isTokenMode(manifest) ? "birth_token" : "provider_key"}>, ` +
+        `${manifest.gateway.agent_header}: <name>  ·  model ${manifest.gateway.model}`));
+    L.push(`   3. ${fmt.badge("claim", "cyan")}  open ${manifest.handoff.claim_url_template}`);
+    L.push(fmt.dim("        then poll GET /v1/agents/<agent_id> until claimed:true"));
+    L.push(`   4. ${fmt.badge("alignment", "cyan")} PUT /v1/alignment/agent/<agent_id> (your session)`);
+    L.push(`   5. ${fmt.badge("protection", "cyan")} open ${manifest.handoff.grant_url_template}`);
+    L.push(fmt.dim("        then PUT /v1/protection/agent/<agent_id> (poll until the grant lands)"));
+    L.push(`   6. ${fmt.badge("dojo", "cyan")}  open ${manifest.handoff.dojo_url}?agent=<agent_id> → Begin Sim`);
+    L.push("");
+    L.push(fmt.dim("  Cards that would be declared:"));
+    L.push(fmt.dim(`    alignment: ${compactCard(manifest.declare.alignment_card)}`));
+    L.push(fmt.dim(`    protection: ${compactCard(manifest.declare.protection_card)} (mode ${manifest.declare.protection_mode})`));
+    L.push("");
+    L.push(fmt.warn("Dry run — nothing was resolved-and-acted-on beyond reading the briefing."));
+    return L.join("\n");
+}
+/** One-line preview of a card's top-level keys (avoids dumping the whole object). */
+function compactCard(card) {
+    const keys = Object.keys(card ?? {});
+    return keys.length ? `{ ${keys.join(", ")} }` : "{}";
+}
+/** Machine-readable dry-run plan. */
+function buildDryRunJson(manifest) {
+    return {
+        dry_run: true,
+        token: manifest.token,
+        version: manifest.version,
+        mission: manifest.mission ?? null,
+        model: { provider: manifest.gateway.provider, name: manifest.gateway.model },
+        gateway: {
+            endpoint: manifest.gateway.endpoint,
+            key_header: manifest.gateway.key_header,
+            credential: isTokenMode(manifest) ? "birth_token" : "provider_key",
+        },
+        handoff: {
+            name_question: manifest.handoff.name_question,
+            name_options: manifest.handoff.name_options,
+            claim_url_template: manifest.handoff.claim_url_template,
+            grant_url_template: manifest.handoff.grant_url_template,
+            dojo_url: manifest.handoff.dojo_url,
+        },
+        declare: {
+            alignment_card_keys: Object.keys(manifest.declare.alignment_card ?? {}),
+            protection_card_keys: Object.keys(manifest.declare.protection_card ?? {}),
+            protection_mode: manifest.declare.protection_mode,
+        },
+    };
+}
+/** The closing recount the human can paste back, personalized from the run. */
+function renderRecount(manifest, name, agentId) {
+    const closing = manifest.closing;
+    const tmpl = closing?.recount_template ??
+        "I ran the Mnemom try-me as {agent_name}: born, claimed, alignment + protection set. Ready for Begin Sim.";
+    const filled = tmpl.replace("{agent_name}", name).replace("{org}", "your org");
+    return fmt.dim(`Done — ${agentId} is ready. Press Begin Sim in the Dojo.\n\n${filled}`);
+}

package/dist/index.js

@@ -3,7 +3,7 @@ import { program } from "commander";
 import { isEntrypoint } from "./lib/entrypoint.js";
 import { CLI_VERSION } from "./version.js";
 import { statusCommand } from "./commands/status.js";
-import { integrityCommand } from "./commands/integrity.js";
+import { activityCommand, integrityCommand } from "./commands/activity.js";
 import { logsCommand } from "./commands/logs.js";
 import { licenseActivateCommand, licenseStatusCommand, licenseDeactivateCommand, } from "./commands/license.js";
 import { cardShowCommand, cardPublishCommand, cardValidateCommand, cardEditCommand, cardEvaluateCommand, } from "./commands/card.js";
@@ -19,11 +19,57 @@ import { validateSafeHouseCommand } from "./commands/validate.js";
 import { apiKeyListCommand, apiKeyCreateCommand, apiKeyRotateCommand, apiKeyRevokeCommand, } from "./commands/api-key.js";
 import { webhooksListCommand, webhooksGetCommand, webhooksCreateCommand, webhooksUpdateCommand, webhooksDeleteCommand, webhooksRotateSecretCommand, webhooksTriggerCommand, webhooksListDeliveriesCommand, webhooksRedeliverCommand, webhooksReplayCommand, } from "./commands/webhooks.js";
 import { listenCommand } from "./commands/listen.js";
+import { tryMeCommand } from "./commands/try-me.js";
 program
     .name("mnemom")
     .description("Transparent AI agent tracing")
     .version(CLI_VERSION)
     .option("--agent <name>", "Select agent by name (or set MNEMOM_AGENT)");
+// ============================================================================
+// try-me — deterministic Dojo-onboarding skill-runner (MNE-934, epic MNE-931)
+//
+// `mnemom try-me <token>` executes the shipped v5.0 Dojo briefing manifest's
+// flow so a human/agent on a fresh machine (no MCP connector) doesn't improvise
+// it: resolve → name → be born → hand off (human claims in-browser) → set
+// alignment → one-time protection grant (human approves in-browser) → set
+// protection → hand off to the Dojo. Additive + read-only on the dojo backend;
+// the two privileged acts stay in the human's browser (the runner orchestrates
+// + polls). See commands/try-me.ts for the auth model.
+// ============================================================================
+program
+    .command("try-me <token>")
+    .description("Run the Mnemom Dojo onboarding for a /try-me token (born → claim → declare → spar)")
+    .option("--dry-run", "Resolve the briefing and print the plan — no birth, claim, card writes, or sim")
+    .option("--json", "Emit machine-readable step outcomes (implies non-interactive)")
+    .option("-y, --yes", "Non-interactive: auto-pick defaults and auto-open URLs")
+    .option("--name <name>", "Pre-choose the agent's name (skips the name prompt)")
+    // NB: a distinct `--resume` (not `--agent`) — the program-level `--agent`
+    // option shadows any subcommand `--agent` under commander@12 (see the
+    // `advisories` command's MNE-238 note), so a subcommand `--agent` would bind
+    // to the parent program and arrive undefined here.
+    .option("--resume <agent_id>", "Resume from an already-born agent id (skip birth)")
+    .option("--api <url>", "Override the API base used to resolve the token (default: env)")
+    .option("--no-open", "Never auto-open URLs in a browser — just print them")
+    .option("--poll-timeout <seconds>", "How long to poll the claim/grant before giving up", "600")
+    .action(async (token, opts) => {
+    try {
+        const pollTimeout = opts.pollTimeout ? parseInt(opts.pollTimeout, 10) : 600;
+        await tryMeCommand(token, {
+            dryRun: opts.dryRun,
+            json: opts.json,
+            yes: opts.yes,
+            name: opts.name,
+            agent: opts.resume,
+            api: opts.api,
+            open: opts.open,
+            pollTimeout: isNaN(pollTimeout) ? 600 : pollTimeout,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 program
     .command("status")
     .description("Show agent status and connection info")
@@ -37,11 +83,25 @@ program
         process.exit(1);
     }
 });
+program
+    .command("activity")
+    .description("Show AAP behavioral activity and activity score (agent-side runtime audit log; distinct from AIP checkpoints)")
+    .action(async () => {
+    try {
+        const opts = program.opts();
+        await activityCommand(opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 program
     .command("integrity")
-    .description("Display integrity score and verification stats")
+    .description("(deprecated, use 'mnemom activity') AAP behavioral activity — note: 'integrity' is reserved for AIP checkpoint surfacing in a future release")
     .action(async () => {
     try {
+        console.error("Deprecated: use 'mnemom activity' instead. 'mnemom integrity' will surface AIP checkpoints in a future release.");
         const opts = program.opts();
         await integrityCommand(opts.agent);
     }
@@ -962,7 +1022,7 @@ postureCmd
 program
     .command("login")
     .description("Authenticate with your Mnemom account")
-    .option("--no-browser", "Use email/password prompt instead of browser")
+    .option("--no-browser", "Use the device code flow instead of opening a browser")
     .action(async (options) => {
     try {
         await loginCommand({ noBrowser: options.browser === false });

package/dist/lib/api.js

@@ -179,14 +179,13 @@ async function authHeaders() {
  * Issue an authenticated fetch, and on a 401 response transparently force a
  * token refresh and retry once.
  *
- * We hit this in the wild when the locally-stored expiresAt diverges from
- * the JWT's actual exp claim (e.g. Supabase has been observed reporting
- * expires_in values longer than the JWT's exp). Without this retry,
+ * We hit this when the locally-cached access token is stale despite the
+ * stored expiresAt claiming it's valid — server-side revocation, clock skew,
+ * or the token being invalidated out from under us. Without this retry,
  * `whoami` cheerfully reports a "valid" token while every authenticated
  * call gets 401 — and the user has no path forward besides
- * `mnemom logout && mnemom login`. The retry heals stale auth files
- * transparently for users who haven't re-logged-in since the
- * computeExpiresAt fix landed.
+ * `mnemom logout && mnemom login`. The retry runs the OAuth refresh_token
+ * grant and heals the stale auth file transparently.
  *
  * `buildInit` is invoked fresh for each attempt so the retry picks up the
  * new Authorization header from the refreshed token. We do NOT mint a new

package/dist/lib/auth.d.ts

@@ -3,13 +3,32 @@
  *
  * Stores auth tokens in ~/.mnemom/auth.json (UC-9: no more config.json).
  * License JWTs are stored alongside auth tokens.
+ *
+ * As of MNE-806, `mnemom login` authenticates against the Mnemom OAuth
+ * Authorization Server (see lib/oauth.ts) and persists SCOPED OAuth tokens
+ * (access + optional refresh, scope, token_type, and the registered client_id
+ * needed to refresh) rather than a full Supabase session. The stored shape
+ * stays backward-compatible: `email`/`userId` are optional (opaque OAuth access
+ * tokens don't carry identity) and pre-existing Supabase sessions on disk
+ * continue to resolve until they expire.
  */
 export interface AuthTokens {
     accessToken: string;
-    refreshToken: string;
+    /** Absent when the AS issues no refresh token for this grant. */
+    refreshToken?: string;
     expiresAt: number;
-    userId: string;
-    email: string;
+    /** OAuth scope granted to this token (e.g. "mcp:read mcp:write"). */
+    scope?: string;
+    /** OAuth token_type (typically "Bearer"). */
+    tokenType?: string;
+    /**
+     * The OAuth client_id this token was issued to. Required to refresh (the AS
+     * uses public clients, so the client_id is presented at the token endpoint).
+     */
+    clientId?: string;
+    /** Present only for legacy Supabase sessions; opaque OAuth tokens omit these. */
+    userId?: string;
+    email?: string;
 }
 export interface AuthStore {
     auth?: AuthTokens;
@@ -30,12 +49,6 @@ export type AuthCredential = {
 } | {
     type: "none";
 };
-/**
- * Compute the effective expiresAt for a freshly issued access token.
- * Prefers the JWT's own `exp` claim; falls back to `now + expires_in` if the
- * token can't be parsed (e.g. an opaque token).
- */
-export declare function computeExpiresAt(accessToken: string, expiresInSeconds: number): number;
 /**
  * Get a valid access token, or null if not authenticated.
  *
@@ -81,5 +94,15 @@ export declare function requireAuth(): Promise<AuthCredential & {
  * Check if the user is logged in (has any credential).
  */
 export declare function isLoggedIn(): Promise<boolean>;
+/**
+ * Interactive browser login: OAuth 2.1 authorization-code + PKCE with a
+ * loopback redirect (the `wrangler login` pattern). Persists the resulting
+ * SCOPED tokens (plus the client_id needed to refresh) to ~/.mnemom/auth.json.
+ */
 export declare function loginWithBrowser(): Promise<AuthTokens>;
-export declare function loginWithPassword(email: string, password: string): Promise<AuthTokens>;
+/**
+ * Headless login: RFC 8628 device authorization grant. Shows a user_code +
+ * verification_uri for the user to approve in any browser (possibly on another
+ * device), polls until approval, and persists the scoped tokens.
+ */
+export declare function loginWithDeviceFlow(): Promise<AuthTokens>;