@mnemom/mnemom 0.17.0-next.5 → 0.17.0-next.7

package/dist/commands/{code-setup.d.ts → agent-setup.d.ts}

@@ -1,9 +1,9 @@
 /**
- * `mnemom code setup` + the zero-friction provisioning behind a bare
- * `mnemom code <scenario>`.
+ * `mnemom agent setup` + the zero-friction provisioning behind a bare
+ * `mnemom agent <scenario>`.
  *
- * If a customer names no agent, `mnemom code` launches under a per-customer
- * governed identity `code-<handle>`. This module makes that identity REAL in
+ * If a customer names no agent, `mnemom agent` launches under a per-customer
+ * governed identity `agent-<handle>`. This module makes that identity REAL in
  * their Mnemom org: it births the agent through the gateway, claims it (so the
  * customer owns it), and publishes a sane default coding posture. The CARDS are
  * observe-only (visibility, no active intervention); the goal contract is what
@@ -24,11 +24,19 @@
  * putAlignmentCard/putProtectionCard (lib/api.ts) — rather than reinventing it.
  */
 /**
- * The default governed-agent slug for the current customer: `code-<handle>`,
+ * The default governed-agent slug for the current customer: `agent-<handle>`,
  * where <handle> is the local-part of their mnemom login email (sanitised), or
  * "user" when no email is available (API-key auth / opaque OAuth token).
  */
 export declare function defaultAgentSlug(): string;
+/**
+ * The default slug resolved from the authenticated IDENTITY: `agent-<handle>` from
+ * the login email fetched via `/v1/auth/me`. The CLI's stored OAuth token carries
+ * no email, so the sync `defaultAgentSlug()` alone falls back to "agent-user";
+ * this fetches the real email once a session exists. Falls back to
+ * `defaultAgentSlug()` on any failure. Call it AFTER the session is ensured.
+ */
+export declare function resolveDefaultSlug(): Promise<string>;
 export interface EnsureAgentOptions {
     /** The already-resolved final agent slug (what rides as x-mnemom-agent). */
     slug: string;
@@ -52,12 +60,12 @@ export interface EnsureAgentResult {
  * allowed here (non-interactive without --setup, or not logged in), or when the
  * customer declines the confirm — in all those cases the launch continues under
  * the given slug. THROWS only on an actual provisioning failure (birth/claim/
- * card write) so the caller can decide whether that is fatal (`mnemom code
+ * card write) so the caller can decide whether that is fatal (`mnemom agent
  * setup`) or a warn-and-continue (a bare launch).
  */
 export declare function ensureGovernedAgent(opts: EnsureAgentOptions): Promise<EnsureAgentResult>;
-/** `mnemom code setup [--agent <slug>]` — the explicit provisioning entry point. */
-export declare function codeSetupCommand(opts?: {
+/** `mnemom agent setup [--agent <slug>]` — the explicit provisioning entry point. */
+export declare function agentSetupCommand(opts?: {
     agent?: string;
 }): Promise<void>;
 /** Thrown when the agent's org has no spendable MU balance. The user-facing
@@ -69,7 +77,7 @@ export declare class MuInsufficientError extends Error {
 /**
  * The preamble errors whose guidance is ALREADY printed when thrown — callers
  * exit 1 quietly instead of re-printing them as "Error: …". One predicate so the
- * two catch sites (`mnemom code` and `mnemom code setup`) cannot drift.
+ * two catch sites (`mnemom agent` and `mnemom agent setup`) cannot drift.
  */
 export declare function isQuietPreambleExit(err: unknown): boolean;
 /**
@@ -85,7 +93,7 @@ export declare function ensureMnemomSession(opts?: {
 }): Promise<boolean>;
 /**
  * Enforce a positive Mnemom Units balance on the org the agent lives in.
- * `mnemom code` has NO free tier — a determined zero/negative balance (or an org
+ * `mnemom agent` has NO free tier — a determined zero/negative balance (or an org
  * with no billing account) is BLOCKED with a portal-style top-up message.
  * Fails OPEN on an inconclusive error (transient 5xx / network / 403), since the
  * gateway is the real enforcement and this is a friendly pre-check; hard-blocks
@@ -93,7 +101,7 @@ export declare function ensureMnemomSession(opts?: {
  */
 export declare function assertMuBalance(orgId: string, orgLabel: string): Promise<void>;
 /**
- * The shared pre-launch preamble for `mnemom code` (and `mnemom code setup`):
+ * The shared pre-launch preamble for `mnemom agent` (and `mnemom agent setup`):
  * ensure a Mnemom session (login/sign-up), then enforce the MU balance on the
  * org the agent lives in (default: the user's personal org). Returns the
  * resolved org so the caller can reuse it. Throws with clear guidance when there

package/dist/commands/{code-setup.js → agent-setup.js}

@@ -1,9 +1,9 @@
 /**
- * `mnemom code setup` + the zero-friction provisioning behind a bare
- * `mnemom code <scenario>`.
+ * `mnemom agent setup` + the zero-friction provisioning behind a bare
+ * `mnemom agent <scenario>`.
  *
- * If a customer names no agent, `mnemom code` launches under a per-customer
- * governed identity `code-<handle>`. This module makes that identity REAL in
+ * If a customer names no agent, `mnemom agent` launches under a per-customer
+ * governed identity `agent-<handle>`. This module makes that identity REAL in
  * their Mnemom org: it births the agent through the gateway, claims it (so the
  * customer owns it), and publishes a sane default coding posture. The CARDS are
  * observe-only (visibility, no active intervention); the goal contract is what
@@ -23,21 +23,21 @@
  * birthThroughGateway (wrap.ts), deriveHashProof (agents.ts), claimAgent +
  * putAlignmentCard/putProtectionCard (lib/api.ts) — rather than reinventing it.
  */
-import { claimAgent, getAgentByName, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
+import { claimAgent, getAgentByName, getMe, 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";
 import { fmt } from "../lib/format.js";
 import { askYesNo, isInteractive } from "../lib/prompt.js";
-import { resolveGatewayHost, sanitizeAgentName } from "../lib/code.js";
-import { configKeySpec, loadCodeConfig, writeCodeConfig } from "../lib/code-config.js";
+import { resolveGatewayHost, sanitizeAgentName } from "../lib/agent.js";
+import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { deriveHashProof } from "./agents.js";
 import { birthThroughGateway } from "./wrap.js";
-import { resolveAnthropicKey } from "./code.js";
-import { assertCodeEnabled, CodeNotEnabledError } from "./code-invite.js";
+import { resolveAnthropicKey } from "./agent.js";
+import { assertCodeEnabled, CodeNotEnabledError } from "./agent-invite.js";
 const say = (line = "") => console.error(line);
 /**
- * The default governed-agent slug for the current customer: `code-<handle>`,
+ * The default governed-agent slug for the current customer: `agent-<handle>`,
  * where <handle> is the local-part of their mnemom login email (sanitised), or
  * "user" when no email is available (API-key auth / opaque OAuth token).
  */
@@ -45,7 +45,26 @@ export function defaultAgentSlug() {
     const email = getAuthInfo()?.email ?? "";
     const local = email.split("@")[0] ?? "";
     const handle = sanitizeAgentName(local) || "user";
-    return `code-${handle}`;
+    return `agent-${handle}`;
+}
+/**
+ * The default slug resolved from the authenticated IDENTITY: `agent-<handle>` from
+ * the login email fetched via `/v1/auth/me`. The CLI's stored OAuth token carries
+ * no email, so the sync `defaultAgentSlug()` alone falls back to "agent-user";
+ * this fetches the real email once a session exists. Falls back to
+ * `defaultAgentSlug()` on any failure. Call it AFTER the session is ensured.
+ */
+export async function resolveDefaultSlug() {
+    try {
+        const email = (await getMe()).email ?? "";
+        const handle = sanitizeAgentName(email.split("@")[0] ?? "");
+        if (handle)
+            return `agent-${handle}`;
+    }
+    catch {
+        // fall through to the token-based best-effort
+    }
+    return defaultAgentSlug();
 }
 /**
  * Ensure `slug` is a usable governed agent in the customer's org. Returns
@@ -53,7 +72,7 @@ export function defaultAgentSlug() {
  * allowed here (non-interactive without --setup, or not logged in), or when the
  * customer declines the confirm — in all those cases the launch continues under
  * the given slug. THROWS only on an actual provisioning failure (birth/claim/
- * card write) so the caller can decide whether that is fatal (`mnemom code
+ * card write) so the caller can decide whether that is fatal (`mnemom agent
  * setup`) or a warn-and-continue (a bare launch).
  */
 export async function ensureGovernedAgent(opts) {
@@ -64,11 +83,11 @@ export async function ensureGovernedAgent(opts) {
     if (loggedIn) {
         const existing = await getAgentByName(slug).catch(() => null);
         if (existing) {
-            // On an EXPLICIT `mnemom code setup`, repair/complete the cards on the
+            // On an EXPLICIT `mnemom agent 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.`));
+                say(fmt.dim(`mnemom agent: '${slug}' is already claimed — refreshing its cards.`));
                 await publishDefaultCards(existing.id);
                 persistAgentSlug(slug);
                 return { slug, provisioned: true };
@@ -87,8 +106,8 @@ export async function ensureGovernedAgent(opts) {
         if (opts.setup === true && !interactive) {
             throw new Error("not authenticated — run `mnemom login` (or set MNEMOM_API_KEY) first.");
         }
-        say(fmt.warn(`mnemom code: not logged in — can't provision '${slug}'.`));
-        say(fmt.dim("  Run `mnemom login`, then `mnemom code setup`. Launching with the unclaimed identity for now."));
+        say(fmt.warn(`mnemom agent: not logged in — can't provision '${slug}'.`));
+        say(fmt.dim("  Run `mnemom login`, then `mnemom agent setup`. Launching with the unclaimed identity for now."));
         return { slug, provisioned: false };
     }
     // 4. Confirm the plan (interactive runs; --setup non-interactive proceeds).
@@ -101,7 +120,7 @@ export async function ensureGovernedAgent(opts) {
         say(fmt.label("  Posture:", "observe (alignment + protection observe-only, all surfaces screened); goal contracts nudge"));
         say(fmt.dim("  Births the agent through the gateway, claims it to your org, and publishes its cards."));
         if (!(await askYesNo("Provision and claim this agent now?", true))) {
-            say(fmt.dim("  Skipped — launching under the unclaimed identity. Run `mnemom code setup` anytime."));
+            say(fmt.dim("  Skipped — launching under the unclaimed identity. Run `mnemom agent setup` anytime."));
             return { slug, provisioned: false };
         }
     }
@@ -110,7 +129,7 @@ export async function ensureGovernedAgent(opts) {
     const agentId = await birthThroughGateway(gatewayUrl, "anthropic", slug, opts.anthropicKey);
     const hashProof = deriveHashProof(opts.anthropicKey, slug);
     await claimAgent(agentId, { hashProof, orgId: org?.org_id });
-    say(fmt.success(`mnemom code: claimed '${slug}' (${agentId}) in ${orgLabel}.`));
+    say(fmt.success(`mnemom agent: claimed '${slug}' (${agentId}) in ${orgLabel}.`));
     // Publish the observe-only cards. A card write that can't complete (propagation
     // right after the claim, or a missing cards:write scope) does NOT abort the
     // provision — the agent is claimed and governed on whatever landed; we warn how
@@ -162,23 +181,23 @@ async function publishDefaultCards(agentId) {
     }
     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)."));
+        say(fmt.success("mnemom agent: observe posture published (alignment + protection observe; goal contracts nudge)."));
         return;
     }
     if (align.ok)
-        say(fmt.success("mnemom code: alignment card published (observe)."));
+        say(fmt.success("mnemom agent: alignment card published (observe)."));
     for (const c of [align, prot]) {
         if (c.ok)
             continue;
         // 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}`));
+        const publishCmd = c.name === "alignment" ? "mnemom card publish" : "mnemom agent setup";
+        say(fmt.warn(`mnemom agent: couldn't publish the ${c.name} card — ${c.error}`));
         say(fmt.dim(`  The agent is claimed and running; finish it later with \`${publishCmd}\`.`));
     }
 }
-/** `mnemom code setup [--agent <slug>]` — the explicit provisioning entry point. */
-export async function codeSetupCommand(opts = {}) {
+/** `mnemom agent setup [--agent <slug>]` — the explicit provisioning entry point. */
+export async function agentSetupCommand(opts = {}) {
     const gatewayHost = resolveGatewayHost(process.env);
     // Sign in (offer sign-up) and enforce the MU balance before any account write.
     try {
@@ -190,24 +209,27 @@ export async function codeSetupCommand(opts = {}) {
         throw err;
     }
     const anthropicKey = await resolveAnthropicKey(process.env, { allowPrompt: true });
-    const slug = opts.agent?.trim() ? sanitizeAgentName(opts.agent.trim()) : defaultAgentSlug();
+    // Session exists now, so derive the real handle from /v1/auth/me (not "agent-user").
+    const slug = opts.agent?.trim()
+        ? sanitizeAgentName(opts.agent.trim())
+        : await resolveDefaultSlug();
     if (!slug)
-        throw new Error("mnemom code setup: agent slug sanitised to empty — pass --agent <slug>.");
+        throw new Error("mnemom agent setup: agent slug sanitised to empty — pass --agent <slug>.");
     const result = await ensureGovernedAgent({ slug, anthropicKey, setup: true, gatewayHost });
     if (!result.provisioned) {
         say(fmt.dim(`  '${slug}' is ready (already claimed) or setup was skipped.`));
     }
 }
 function warnUnclaimed(slug) {
-    say(fmt.warn(`mnemom code: agent '${slug}' is not set up in your org — launching with an UNCLAIMED identity (governance is advisory/fail-open).`));
-    say(fmt.dim("  Provision it (creates + claims the agent, publishes observe cards): mnemom code setup"));
+    say(fmt.warn(`mnemom agent: agent '${slug}' is not set up in your org — launching with an UNCLAIMED identity (governance is advisory/fail-open).`));
+    say(fmt.dim("  Provision it (creates + claims the agent, publishes observe cards): mnemom agent setup"));
 }
 function persistAgentSlug(slug) {
     try {
-        const cfg = loadCodeConfig();
+        const cfg = loadLauncherConfig();
         if (!cfg.agent) {
             configKeySpec("agent").set(cfg, slug);
-            writeCodeConfig(cfg);
+            writeLauncherConfig(cfg);
         }
     }
     catch {
@@ -228,7 +250,7 @@ export class MuInsufficientError extends Error {
 /**
  * The preamble errors whose guidance is ALREADY printed when thrown — callers
  * exit 1 quietly instead of re-printing them as "Error: …". One predicate so the
- * two catch sites (`mnemom code` and `mnemom code setup`) cannot drift.
+ * two catch sites (`mnemom agent` and `mnemom agent setup`) cannot drift.
  */
 export function isQuietPreambleExit(err) {
     return err instanceof MuInsufficientError || err instanceof CodeNotEnabledError;
@@ -258,7 +280,7 @@ export async function ensureMnemomSession(opts = {}) {
     if (!interactive)
         return false;
     say(fmt.section("Sign in to Mnemom"));
-    say(fmt.dim("  mnemom code runs your coding session governed and under your Mnemom account,"));
+    say(fmt.dim("  mnemom agent runs your coding session governed and under your Mnemom account,"));
     say(fmt.dim("  so it shows up in your traces and draws on your org's µ balance."));
     say(fmt.dim(`  New to Mnemom? You can create a free account in the same flow (or at ${getWebsiteUrl()}/signup).`));
     if (!(await askYesNo("Sign in or create your account now?", true)))
@@ -284,7 +306,7 @@ export async function ensureMnemomSession(opts = {}) {
 }
 /**
  * Enforce a positive Mnemom Units balance on the org the agent lives in.
- * `mnemom code` has NO free tier — a determined zero/negative balance (or an org
+ * `mnemom agent` has NO free tier — a determined zero/negative balance (or an org
  * with no billing account) is BLOCKED with a portal-style top-up message.
  * Fails OPEN on an inconclusive error (transient 5xx / network / 403), since the
  * gateway is the real enforcement and this is a friendly pre-check; hard-blocks
@@ -313,7 +335,9 @@ export async function assertMuBalance(orgId, orgLabel) {
 }
 function safeBigInt(v) {
     try {
-        return BigInt(String(v ?? "0").trim().split(".")[0] || "0");
+        return BigInt(String(v ?? "0")
+            .trim()
+            .split(".")[0] || "0");
     }
     catch {
         return 0n;
@@ -327,16 +351,16 @@ function safeBigInt(v) {
 function printTopUp(orgLabel, balanceMu) {
     say();
     say(fmt.warn(`No µ balance — ${orgLabel} is at ${balanceMu} µ.`));
-    say(fmt.dim("  mnemom code runs on µ, and there's no free tier. Without µ, Mnemom's safety"));
+    say(fmt.dim("  mnemom agent runs on µ, and there's no free tier. Without µ, Mnemom's safety"));
     say(fmt.dim("  features can't run, so the launch is blocked. Top up to launch a governed session:"));
     say();
     say(`    Top up µ:  ${getWebsiteUrl()}/settings/billing`);
     say(fmt.dim("  If you don't manage billing for this org, ask an admin to top up."));
     say();
-    say(fmt.dim("  Your µ balance updates the moment a top-up completes — then re-run `mnemom code`."));
+    say(fmt.dim("  Your µ balance updates the moment a top-up completes — then re-run `mnemom agent`."));
 }
 /**
- * The shared pre-launch preamble for `mnemom code` (and `mnemom code setup`):
+ * The shared pre-launch preamble for `mnemom agent` (and `mnemom agent setup`):
  * ensure a Mnemom session (login/sign-up), then enforce the MU balance on the
  * org the agent lives in (default: the user's personal org). Returns the
  * resolved org so the caller can reuse it. Throws with clear guidance when there
@@ -346,14 +370,14 @@ export async function ensureSessionAndBalance(opts) {
     const interactive = opts.interactive ?? isInteractive();
     const haveSession = await ensureMnemomSession({ interactive });
     if (!haveSession) {
-        throw new Error("mnemom code needs a Mnemom account — it runs your coding session governed and on your org's µ balance.\n" +
+        throw new Error("mnemom agent needs a Mnemom account — it runs your coding session governed and on your org's µ balance.\n" +
             "  Sign in:   mnemom login   (or set MNEMOM_API_KEY)\n" +
             `  New here?  create a free account, then top up µ: ${getWebsiteUrl()}/settings/billing`);
     }
     const active = getActiveOrg();
     const orgId = active?.org_id ?? (await getMyPersonalOrg()).org_id;
     const orgLabel = active ? `${active.name} (${active.slug})` : "your personal org";
-    // Invited-cohort gate FIRST: an org that is not enabled for Mnemom Code gets
+    // Invited-cohort gate FIRST: an org that is not enabled for Mnemom Agent gets
     // the invite guidance, not a top-up message (the µ check would be moot).
     await assertCodeEnabled(orgId, orgLabel);
     await assertMuBalance(orgId, orgLabel);

package/dist/commands/{code.d.ts → agent.d.ts}

@@ -1,5 +1,5 @@
 /**
- * `mnemom code <scenario>` — the CLI's first-class governed-coding-agent launcher.
+ * `mnemom agent <scenario>` — the CLI's first-class governed-coding-agent launcher.
  *
  * Launches your coding-agent CLI (Claude Code in v1) with its dev-time model
  * traffic routed through the Mnemom gateway's /anthropic door for observability +
@@ -11,7 +11,7 @@
  *     no router door / Mnemom key). `--cli` selects the executable to run (name or
  *     full path) so codex/cursor/github adapters can be added later.
  *   - The us-2/PROD gateway is the DEFAULT door (https://gateway.mnemom.ai); an
- *     explicit MNEMOM_CODE_GATEWAY / --gateway still wins, never silently prod.
+ *     explicit MNEMOM_AGENT_GATEWAY / --gateway still wins, never silently prod.
  *   - Three launch shapes: `terminal` (DEFAULT), `remote-control` (interactive RC
  *     in this terminal), `server` (headless RC dispatcher). RC runs the CLI
  *     UNTOUCHED behind a bundled local TLS proxy (rc-proxy.mjs) — Claude Code
@@ -20,12 +20,12 @@
  *   - yolo (`--dangerously-skip-permissions`) is ON by default; `--no-yolo` opts out.
  *
  * The Anthropic key is resolved from a credential source with ZERO 1Password
- * dependency (env → the CLI's own ~/.mnemom/code.json store → interactive
+ * dependency (env → the CLI's own ~/.mnemom/launcher.json store → interactive
  * prompt) and placed ONLY in the launched process (an `ANTHROPIC_CUSTOM_HEADERS`
  * line, or the proxy's stdin under RC). It is never logged, printed, or passed as
  * an argv value.
  */
-export interface CodeOptions {
+export interface AgentOptions {
     goal?: string;
     requirement?: string[];
     allow?: string[];
@@ -54,7 +54,7 @@ export interface CodeOptions {
      */
     setup?: boolean;
     /**
-     * Where to source the Anthropic key (from ~/.mnemom/code.toml `key_source`).
+     * Where to source the Anthropic key (from ~/.mnemom/launcher.toml `key_source`).
      * Restricts the default env → store → prompt search: "env" uses env only,
      * "store" uses env → store (no prompt), "prompt" forces the interactive prompt.
      * Undefined = the full default order.
@@ -64,13 +64,13 @@ export interface CodeOptions {
     /** Print the resolved launch plan and exit — no key read, no spawn. */
     dryRun?: boolean;
 }
-/** Entry point for `mnemom code [scenario]`. Throws on fatal misconfig. */
-export declare function codeCommand(scenarioArg: string | undefined, options?: CodeOptions): Promise<void>;
+/** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
+export declare function agentCommand(scenarioArg: string | undefined, options?: AgentOptions): Promise<void>;
 /**
  * Resolve the Anthropic key with NO 1Password dependency (built for external
  * customer adoption), in order:
- *   1. env: MNEMOM_CODE_ANTHROPIC_KEY, else ANTHROPIC_API_KEY
- *   2. the CLI's own store: ~/.mnemom/code.json (`anthropic_key`)
+ *   1. env: MNEMOM_AGENT_ANTHROPIC_KEY, else ANTHROPIC_API_KEY
+ *   2. the CLI's own store: ~/.mnemom/launcher.json (`anthropic_key`)
  *   3. interactive prompt (masked), offering to save it to the store
  * Never logged / printed. Throws with guidance when nothing resolves — we refuse
  * to launch un-routed.
@@ -81,8 +81,8 @@ export declare function resolveAnthropicKey(env: NodeJS.ProcessEnv, opts: {
 }): Promise<string>;
 /**
  * Where an Anthropic key would resolve from RIGHT NOW, without reading its value:
- * "env" (MNEMOM_CODE_ANTHROPIC_KEY / ANTHROPIC_API_KEY), "store" (~/.mnemom/code.json),
- * or null (would fall to the interactive prompt). For `mnemom code doctor`.
+ * "env" (MNEMOM_AGENT_ANTHROPIC_KEY / ANTHROPIC_API_KEY), "store" (~/.mnemom/launcher.json),
+ * or null (would fall to the interactive prompt). For `mnemom agent doctor`.
  */
 export declare function anthropicKeySource(env?: NodeJS.ProcessEnv): "env" | "store" | null;
 export interface ResolvedCli {
@@ -92,7 +92,7 @@ export interface ResolvedCli {
     name: string;
 }
 /**
- * Resolve which coding-agent CLI to launch. `--cli` (or MNEMOM_CODE_CLI) is a
+ * Resolve which coding-agent CLI to launch. `--cli` (or MNEMOM_AGENT_CLI) is a
  * name or a full path; default "claude". A value with a path separator is used
  * verbatim (must exist); a bare name is resolved on PATH, then — for claude — the
  * fnm/nvm/asdf install dirs (a version-manager shim / shell function is absent in
@@ -116,7 +116,7 @@ export interface RcCapability {
 /**
  * Can we launch the DEFAULT Remote-Control-in-terminal shape on this machine?
  * Needs node + openssl (the local proxy mints an ephemeral CA) and a claude
- * adapter that advertises `--remote-control`. Used both by `mnemom code doctor`
+ * adapter that advertises `--remote-control`. Used both by `mnemom agent doctor`
  * and by the auto-default selection (a bare launch prefers RC when capable).
  */
 export declare function checkRcCapability(cli: ResolvedCli): RcCapability;
@@ -127,7 +127,7 @@ export declare function checkRcCapability(cli: ResolvedCli): RcCapability;
  * appends `--strict-mcp-config --mcp-config {}` LAST so it wins over any
  * caller-supplied --mcp-config.
  */
-export declare function buildCliArgs(options: CodeOptions, ctx: {
+export declare function buildCliArgs(options: AgentOptions, ctx: {
     yolo: boolean;
     allowCliFlags: boolean;
 }): string[];