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

package/dist/commands/agent-sessions.js

@@ -0,0 +1,271 @@
+/**
+ * `mnemom agent sessions [--all] [--json]` and `mnemom agent show [ref] [--json]`
+ * — the read side of the local session ledger (`~/.mnemom/sessions.jsonl`, one
+ * line per real launch) merged with the gateway's live goal state for one
+ * session (`GET /v1/agent/sessions/{conversationId}` via mnemom-api).
+ *
+ * Pure apart from the injected deps (`readRecords`, `fetchSession`, `out`,
+ * `err`), so every arm is unit-tested; `liveSessionDeps` is the thin driver
+ * index.ts wires in.
+ *
+ * Hash note: the CLI's launch-time envelope sha will NOT equal the gateway's
+ * sealed hash in general (the gateway normalises absent arrays to `[]`), so the
+ * local sha is never printed as "the sealed hash" and no mismatch is flagged —
+ * only the server's hash is shown, labelled "sealed hash".
+ */
+import { readSessionRecords } from "../lib/agent-ledger.js";
+import { MNEMOM_DIR } from "../lib/config.js";
+import { getAgentSession, MnemomApiError } from "../lib/api.js";
+import { fmt, formatRelativeAge } from "../lib/format.js";
+/** The production wiring (index.ts). Lazy so a test that mocks lib/api without
+ *  this export can still import index.ts. */
+export const liveSessionDeps = {
+    // The ledger is oldest-first on disk; every consumer here wants newest-first.
+    readRecords: () => readSessionRecords({ dir: MNEMOM_DIR }).reverse(),
+    fetchSession: (conversationId, agentId, orgId) => getAgentSession(conversationId, agentId, orgId),
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+};
+export const NO_SESSIONS_MESSAGE = "No sessions yet — run `mnemom agent` to start one.";
+export const DEFAULT_SESSIONS_LIMIT = 20;
+/**
+ * Resolve `[ref]` against the ledger (newest first):
+ *   - no ref → the newest record;
+ *   - an exact session name → the newest record with that name, older ones in `others`;
+ *   - else a conversation-id prefix → the unique match, or `{record: null, candidates}`
+ *     when several share the prefix;
+ *   - nothing matches (or the ledger is empty) → null.
+ */
+export function resolveSessionRef(records, ref) {
+    const needle = ref?.trim() ?? "";
+    if (needle === "") {
+        const newest = records[0];
+        return newest ? { record: newest, others: [] } : null;
+    }
+    const newestByName = records.find((r) => r.session === needle);
+    if (newestByName) {
+        const others = records.filter((r) => r !== newestByName && r.session === needle);
+        return { record: newestByName, others };
+    }
+    const byConv = records.filter((r) => r.conversation_id.startsWith(needle));
+    if (byConv.length === 1)
+        return { record: byConv[0], others: [] };
+    if (byConv.length > 1)
+        return { record: null, candidates: byConv };
+    return null;
+}
+// ─── sessions table ───────────────────────────────────────────────────────────
+const COL = { session: 26, started: 16, agent: 22, goal: 6, conv: 8 };
+function cell(text, width) {
+    const max = width - 2;
+    const shown = text.length > max ? `${text.slice(0, max - 1)}…` : text;
+    return shown.padEnd(width);
+}
+/** Goal alignment as the ledger recorded it: a contract at launch ⇒ on. */
+export function localGoalFlag(record) {
+    return record.contract ? "on" : "off";
+}
+/**
+ * Render the ledger as a table, newest first — the newest
+ * `DEFAULT_SESSIONS_LIMIT` rows unless `all`, with a footer naming the rest.
+ */
+export function formatSessionsTable(rows, opts) {
+    const shown = opts.all ? rows : rows.slice(0, DEFAULT_SESSIONS_LIMIT);
+    const lines = [];
+    lines.push("  " +
+        cell("Session", COL.session) +
+        cell("Started", COL.started) +
+        cell("Agent", COL.agent) +
+        cell("Goal", COL.goal) +
+        "Conv");
+    lines.push("  " + "─".repeat(COL.session + COL.started + COL.agent + COL.goal + COL.conv));
+    for (const r of shown) {
+        lines.push("  " +
+            cell(r.session, COL.session) +
+            cell(formatRelativeAge(r.started_at), COL.started) +
+            cell(r.agent_slug, COL.agent) +
+            cell(localGoalFlag(r), COL.goal) +
+            r.conversation_id.slice(0, 8));
+    }
+    if (shown.length < rows.length) {
+        lines.push(fmt.dim(`  showing ${shown.length} of ${rows.length} sessions — pass --all for every session`));
+    }
+    return lines;
+}
+// ─── show view ────────────────────────────────────────────────────────────────
+function listOrDash(items) {
+    return items && items.length > 0 ? items.join(", ") : "—";
+}
+function numOrDash(n) {
+    return n === null || n === undefined ? "—" : String(n);
+}
+/** `turns 3/10 (crossed)` — value against its ceiling (none ⇒ just the value). */
+export function gauge(label, value, ceiling, fired) {
+    const ratio = ceiling === null ? String(value) : `${value}/${ceiling}`;
+    return `${label} ${ratio}${fired ? " (crossed)" : ""}`;
+}
+/**
+ * The human view for `mnemom agent show`: the local record, then the live
+ * gateway state (or a dim "live state unavailable (<reason>)" line when
+ * `remote` is null).
+ */
+export function buildShowView(local, remote, reason) {
+    const L = [];
+    L.push(fmt.header(`Session ${local.session}`));
+    L.push(fmt.label("started:      ", `${local.started_at} (${formatRelativeAge(local.started_at)})`));
+    L.push(fmt.label("agent:        ", `${local.agent_slug} ${local.agent_id ? `(${local.agent_id})` : fmt.dim("(id unresolved at launch)")}`));
+    L.push(fmt.label("org:          ", `${local.org_label} (${local.org_id})`));
+    L.push(fmt.label("gateway:      ", local.gateway_host));
+    const launchBits = [local.launch_shape, `cli ${local.cli}`];
+    if (local.model)
+        launchBits.push(`model ${local.model}`);
+    if (local.effort)
+        launchBits.push(`effort ${local.effort}`);
+    L.push(fmt.label("launch:       ", launchBits.join(" · ")));
+    L.push(fmt.label("conversation: ", local.conversation_id));
+    const goalOn = remote ? remote.sealed !== null : local.contract !== null;
+    L.push(fmt.label("goal alignment:", goalOn ? fmt.badge("ON", "green") : fmt.badge("OFF", "yellow")));
+    if (local.contract) {
+        L.push(fmt.label("goal (at launch):", local.contract.statement));
+    }
+    L.push(fmt.section("Live state (gateway)"));
+    if (!remote) {
+        L.push(fmt.dim(`  live state unavailable (${reason ?? "unknown"})`));
+        return L;
+    }
+    if (remote.sealed) {
+        const c = remote.sealed.contract;
+        L.push(fmt.label("statement:      ", c.statement));
+        L.push(fmt.label("requirements:   ", listOrDash(c.requirements)));
+        L.push(fmt.label("allowed paths:  ", listOrDash(c.allowed_paths)));
+        L.push(fmt.label("forbidden paths:", listOrDash(c.forbidden_paths)));
+        L.push(fmt.label("ceilings:       ", `max_turns ${numOrDash(c.max_turns)} · budget_usd ${numOrDash(c.budget_usd)} · stall_turns ${numOrDash(c.stall_turns)}`));
+        L.push(fmt.label("sealed hash:    ", remote.sealed.hash));
+        L.push(fmt.label("sealed at:      ", remote.sealed.sealed_at));
+    }
+    else {
+        L.push(fmt.dim("  no sealed contract on the gateway for this conversation"));
+    }
+    if (remote.verdict) {
+        const v = remote.verdict;
+        L.push(fmt.label("verdict:        ", `${v.verdict.toUpperCase()} at turn ${v.turn} — ${v.reason}`));
+    }
+    else {
+        L.push(fmt.label("verdict:        ", fmt.dim("none yet")));
+    }
+    if (remote.guardrails) {
+        const { ceilings, state } = remote.guardrails;
+        if (state) {
+            const parts = [
+                gauge("turns", state.turns, ceilings.max_turns, state.fired.turns),
+                gauge("spend $", state.spend_usd, ceilings.budget_usd, state.fired.budget),
+                gauge("stall", state.stall_run, ceilings.stall_turns, state.fired.stall),
+            ];
+            L.push(fmt.label("guardrails:     ", parts.join(" · ")));
+        }
+        else {
+            L.push(fmt.label("guardrails:     ", `ceilings max_turns ${numOrDash(ceilings.max_turns)} · budget_usd ${numOrDash(ceilings.budget_usd)} · stall_turns ${numOrDash(ceilings.stall_turns)} ${fmt.dim("(no turns counted yet)")}`));
+        }
+    }
+    else {
+        L.push(fmt.label("guardrails:     ", fmt.dim("none")));
+    }
+    if (remote.turn !== null) {
+        L.push(fmt.label("turn:           ", String(remote.turn)));
+    }
+    return L;
+}
+export function buildShowJson(local, remote, reason) {
+    const goalOn = remote ? remote.sealed !== null : local.contract !== null;
+    return {
+        session: { ...local, source: "local" },
+        goal_alignment: goalOn ? "on" : "off",
+        live: remote
+            ? {
+                source: "gateway",
+                available: true,
+                sealed: remote.sealed,
+                verdict: remote.verdict,
+                turn: remote.turn,
+                guardrails: remote.guardrails,
+            }
+            : { source: "gateway", available: false, reason: reason ?? "unknown" },
+    };
+}
+/** `mnemom agent sessions [--all] [--json]` */
+export async function agentSessionsCommand(opts, deps) {
+    const records = deps.readRecords();
+    const rows = opts.all ? records : records.slice(0, DEFAULT_SESSIONS_LIMIT);
+    if (opts.json) {
+        deps.out(JSON.stringify(rows, null, 2));
+        return;
+    }
+    if (records.length === 0) {
+        deps.out(NO_SESSIONS_MESSAGE);
+        return;
+    }
+    deps.out(fmt.header("Mnemom Agent sessions"));
+    deps.out("");
+    for (const line of formatSessionsTable(records, { all: opts.all }))
+        deps.out(line);
+    deps.out("");
+}
+/** Why the live read could not happen, from the thrown error. */
+export function unavailableReason(err) {
+    if (err instanceof MnemomApiError && err.code)
+        return `${err.code}: ${err.message}`;
+    return err instanceof Error ? err.message : String(err);
+}
+/** `mnemom agent show [ref] [--json]` */
+export async function agentShowCommand(ref, opts, deps) {
+    const records = deps.readRecords();
+    if (records.length === 0) {
+        if (opts.json)
+            deps.out(JSON.stringify(null));
+        else
+            deps.out(NO_SESSIONS_MESSAGE);
+        return;
+    }
+    const resolved = resolveSessionRef(records, ref);
+    if (resolved === null) {
+        deps.err(fmt.error(`No session matches '${ref ?? ""}' — try \`mnemom agent sessions\`.`));
+        process.exitCode = 1;
+        return;
+    }
+    if (resolved.record === null) {
+        deps.err(fmt.error(`'${ref ?? ""}' matches ${resolved.candidates.length} sessions — give more of the conversation id:`));
+        for (const c of resolved.candidates) {
+            deps.err(`  ${c.conversation_id}  ${c.session}  ${formatRelativeAge(c.started_at)}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const { record, others } = resolved;
+    let remote = null;
+    let reason;
+    if (record.agent_id === null) {
+        reason = "agent id was not resolved at launch";
+    }
+    else {
+        try {
+            remote = await deps.fetchSession(record.conversation_id, record.agent_id, record.org_id);
+        }
+        catch (e) {
+            reason = unavailableReason(e);
+        }
+    }
+    if (opts.json) {
+        deps.out(JSON.stringify(buildShowJson(record, remote, reason), null, 2));
+        return;
+    }
+    for (const line of buildShowView(record, remote, reason))
+        deps.out(line);
+    if (others.length > 0) {
+        deps.out("");
+        deps.out(fmt.dim(`  ${others.length} older session(s) share this name — \`mnemom agent show <conv-id prefix>\` picks one:`));
+        for (const o of others) {
+            deps.out(fmt.dim(`    ${o.conversation_id.slice(0, 8)}  ${formatRelativeAge(o.started_at)}`));
+        }
+    }
+    deps.out("");
+}

package/dist/commands/agent.d.ts

@@ -25,6 +25,7 @@
  * line, or the proxy's stdin under RC). It is never logged, printed, or passed as
  * an argv value.
  */
+import { type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
     requirement?: string[];
@@ -34,6 +35,12 @@ export interface AgentOptions {
     budget?: string;
     maxTurns?: string;
     stall?: string;
+    /**
+     * `--implicit`: goal alignment with no sealed contract — the gateway infers the
+     * goal from the user's messages and revises it as they steer; the ceilings above
+     * ride on the `x-mnemom-goal-mode` header. Exclusive with the contract flags.
+     */
+    implicit?: boolean;
     /** x-mnemom-agent value (defaults to "code-agent"). */
     agent?: string;
     conversationId?: string;
@@ -66,6 +73,25 @@ export interface AgentOptions {
 }
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export declare function agentCommand(scenarioArg: string | undefined, options?: AgentOptions): Promise<void>;
+/**
+ * Record this launch in ~/.mnemom/sessions.jsonl. The agent record id is
+ * resolved best-effort (a lookup failure or an unknown slug records null); a
+ * ledger write failure warns to stderr and the launch proceeds regardless.
+ */
+export declare function recordSessionLaunch(ctx: {
+    session: string;
+    conversationId: string;
+    agent: string;
+    account: {
+        orgId: string;
+        orgLabel: string;
+    };
+    gatewayHost: string;
+    shape: LaunchShape;
+    options: AgentOptions;
+    cli: ResolvedCli;
+    envelope: SealedContractEnvelope | null;
+}): Promise<void>;
 /**
  * Resolve the Anthropic key with NO 1Password dependency (built for external
  * customer adoption), in order:
@@ -131,3 +157,32 @@ export declare function buildCliArgs(options: AgentOptions, ctx: {
     yolo: boolean;
     allowCliFlags: boolean;
 }): string[];
+/**
+ * Which goal-alignment mode the launch status line names: a sealed contract →
+ * "on"; `--implicit` (mode header, no contract) → "implicit"; neither → "off".
+ * A sealed contract and a mode header never coexist (`assembleContract` refuses
+ * the combination), so the first arm winning is not a precedence choice.
+ */
+export declare function goalAlignmentMode(envelope: SealedContractEnvelope | null, goalMode: string | null): "on" | "implicit" | "off";
+export declare function logLaunch(ctx: {
+    shape: LaunchShape;
+    door: string;
+    agent: string;
+    conversationId: string;
+    cellNote: string;
+    envelope: SealedContractEnvelope | null;
+    goalMode: string | null;
+    cli: ResolvedCli;
+}): void;
+export declare function printPlan(ctx: {
+    scenario: string;
+    shape: LaunchShape;
+    agent: string;
+    conversationId: string;
+    door: string;
+    cellNote: string;
+    envelope: SealedContractEnvelope | null;
+    goalMode: string | null;
+    yolo: boolean;
+    cli: ResolvedCli;
+}): void;

package/dist/commands/agent.js

@@ -31,20 +31,32 @@ import { tmpdir, homedir } from "node:os";
 import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { MNEMOM_DIR } from "../lib/config.js";
+import { getAgentByName } from "../lib/api.js";
+import { LEDGER_FILE, appendSessionRecord, toLedgerContract } from "../lib/agent-ledger.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { fmt } from "../lib/format.js";
-import { askInput, askYesNo, isInteractive } from "../lib/prompt.js";
+import { askInput, askSelect, askYesNo, isInteractive } from "../lib/prompt.js";
 import { goalAlignmentLine, resolveSessionSetup } from "./agent-session.js";
 import { defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, } from "./agent-setup.js";
-import { assembleContract, buildCustomHeaders, isProdGateway, launchPreferenceExplicit, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, sanitizeAgentName, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, isProdGateway, launchPreferenceExplicit, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, sanitizeAgentName, } from "../lib/agent.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
 const CODE_STORE = join(MNEMOM_DIR, "launcher.json");
 const say = (line = "") => console.error(line);
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export async function agentCommand(scenarioArg, options = {}) {
     // ── session name + goal ── (a bare `mnemom agent` in a terminal asks for both,
-    // explaining goal alignment; no goal ⇒ no contract header ⇒ goal alignment off)
-    const session = await resolveSessionSetup({ scenario: scenarioArg, goal: options.goal, interactive: isInteractive() }, { askInput: (q) => askInput(q), askYesNo: (q, d) => askYesNo(q, d) });
+    // explaining goal alignment: infer it from your messages (implicit), type a
+    // one-line goal (sealed), or off — no contract header and no mode header)
+    const session = await resolveSessionSetup({
+        scenario: scenarioArg,
+        goal: options.goal,
+        implicit: options.implicit,
+        interactive: isInteractive(),
+    }, {
+        askInput: (q) => askInput(q),
+        askYesNo: (q, d) => askYesNo(q, d),
+        askSelect: (q, o) => askSelect(q, o),
+    });
     const scenario = session.scenario;
     const env = process.env;
     let shape = resolveLaunchShape({ remoteControl: options.remoteControl, server: options.server }, env);
@@ -68,6 +80,15 @@ export async function agentCommand(scenarioArg, options = {}) {
         budget: options.budget,
         maxTurns: options.maxTurns,
         stall: options.stall,
+        implicit: options.implicit,
+    });
+    // ── implicit goal mode (no contract; the gateway infers the goal from the user's
+    // messages) — the guardrail ceilings ride on the mode header instead ──
+    const goalMode = buildGoalModeHeader({
+        implicit: options.implicit,
+        budget: options.budget,
+        maxTurns: options.maxTurns,
+        stall: options.stall,
     });
     // ── door ──
     const gatewayHost = resolveGatewayHost(env);
@@ -117,6 +138,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             door,
             cellNote,
             envelope,
+            goalMode,
             yolo,
             cli: planCli,
         });
@@ -140,8 +162,9 @@ export async function agentCommand(scenarioArg, options = {}) {
     // there isn't one — and (2) enforce a positive µ balance on the org the agent
     // lives in (default: the user's personal org). No µ ⇒ blocked with a
     // portal-style top-up message. Skipped only on --dry-run (handled above).
+    let account;
     try {
-        await ensureSessionAndBalance({ interactive: isInteractive() });
+        account = await ensureSessionAndBalance({ interactive: isInteractive() });
     }
     catch (err) {
         if (isQuietPreambleExit(err))
@@ -175,8 +198,23 @@ export async function agentCommand(scenarioArg, options = {}) {
             say(fmt.warn(`mnemom agent: agent setup did not complete (${msg}) — launching with the unclaimed identity.`));
         }
     }
-    logLaunch({ shape, door, agent, conversationId, cellNote, envelope, cli });
-    say(goalAlignmentLine(envelope !== null));
+    // ── local session ledger (~/.mnemom/sessions.jsonl) ── one line per real
+    // launch so `mnemom agent sessions` / `show` can find this conversation later.
+    // Written after provisioning so a freshly claimed agent's id resolves. Holds
+    // NO secret (never the key, the headers, or the child env); best-effort.
+    await recordSessionLaunch({
+        session: scenario,
+        conversationId,
+        agent,
+        account,
+        gatewayHost,
+        shape,
+        options,
+        cli,
+        envelope,
+    });
+    logLaunch({ shape, door, agent, conversationId, cellNote, envelope, goalMode, cli });
+    say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
     if (shape === "terminal") {
         launchTerminal({
             cli,
@@ -185,6 +223,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             agent,
             conversationId,
             envelope,
+            goalMode,
             options,
             yolo,
             contextHint,
@@ -200,11 +239,46 @@ export async function agentCommand(scenarioArg, options = {}) {
         conversationId,
         scenario,
         envelope,
+        goalMode,
         options,
         yolo,
     });
 }
 // ───────────────────────────────────────────────────────────────────────────
+// Session ledger (thin driver over lib/agent-ledger.ts)
+// ───────────────────────────────────────────────────────────────────────────
+/**
+ * Record this launch in ~/.mnemom/sessions.jsonl. The agent record id is
+ * resolved best-effort (a lookup failure or an unknown slug records null); a
+ * ledger write failure warns to stderr and the launch proceeds regardless.
+ */
+export async function recordSessionLaunch(ctx) {
+    let agentId;
+    try {
+        agentId = (await getAgentByName(ctx.agent))?.id ?? null;
+    }
+    catch {
+        agentId = null; // unresolvable right now — the ledger still records the launch
+    }
+    const result = appendSessionRecord({
+        session: ctx.session,
+        conversation_id: ctx.conversationId,
+        agent_slug: ctx.agent,
+        agent_id: agentId,
+        org_id: ctx.account.orgId,
+        org_label: ctx.account.orgLabel,
+        gateway_host: ctx.gatewayHost,
+        launch_shape: ctx.shape,
+        model: ctx.options.model?.trim() || null,
+        effort: ctx.options.effort?.trim() || null,
+        cli: ctx.cli.name,
+        contract: toLedgerContract(ctx.envelope?.contract ?? null),
+    }, { dir: MNEMOM_DIR, now: () => new Date(), pid: process.pid });
+    if (!result.ok) {
+        say(fmt.warn(`mnemom agent: could not record this session in ~/.mnemom/${LEDGER_FILE} (${result.error}) — launching anyway.`));
+    }
+}
+// ───────────────────────────────────────────────────────────────────────────
 // Credential resolution (zero 1Password)
 // ───────────────────────────────────────────────────────────────────────────
 /**
@@ -220,7 +294,7 @@ export async function resolveAnthropicKey(env, opts) {
     const source = opts.keySource;
     // "prompt" forces the interactive prompt (skips env + store).
     if (source !== "prompt") {
-        const fromEnv = (env.MNEMOM_AGENT_ANTHROPIC_KEY || env.ANTHROPIC_API_KEY || "").trim();
+        const fromEnv = stripCrlf(env.MNEMOM_AGENT_ANTHROPIC_KEY || env.ANTHROPIC_API_KEY || "");
         if (fromEnv)
             return fromEnv;
         // "env" restricts to env only — no store, no prompt.
@@ -231,11 +305,17 @@ export async function resolveAnthropicKey(env, opts) {
         const stored = readStoredKey();
         if (stored)
             return stored;
+        // "store" restricts to env → store — never the interactive prompt.
+        if (source === "store") {
+            throw new Error("mnemom agent: key_source is 'store' but no Anthropic key is set in env or ~/.mnemom/launcher.json.\n" +
+                "  Set one:   export MNEMOM_AGENT_ANTHROPIC_KEY=sk-ant-...   (or ANTHROPIC_API_KEY)\n" +
+                "  Or store it: `mnemom agent config set key_source prompt`, run `mnemom agent` once and accept the save.");
+        }
     }
-    // (source can only be "store", "prompt", or undefined here — "env" threw above.)
+    // (source can only be "prompt" or undefined here — "env" and "store" threw above.)
     if (opts.allowPrompt && isInteractive()) {
         say("mnemom agent: no Anthropic key in env (MNEMOM_AGENT_ANTHROPIC_KEY / ANTHROPIC_API_KEY) or ~/.mnemom/launcher.json.");
-        const entered = (await askInput("Enter your Anthropic API key (sk-ant-…):", true)).trim();
+        const entered = stripCrlf(await askInput("Enter your Anthropic API key (sk-ant-…):", true));
         if (entered) {
             if (await askYesNo("Save it to ~/.mnemom/launcher.json (0600) for next time?", true)) {
                 storeKey(entered);
@@ -265,7 +345,7 @@ export function anthropicKeySource(env = process.env) {
 function readStoredKey() {
     try {
         const data = JSON.parse(readFileSync(CODE_STORE, "utf8"));
-        const key = typeof data.anthropic_key === "string" ? data.anthropic_key.trim() : "";
+        const key = typeof data.anthropic_key === "string" ? stripCrlf(data.anthropic_key) : "";
         return key || undefined;
     }
     catch {
@@ -442,6 +522,7 @@ function launchTerminal(ctx) {
         agent: ctx.agent,
         conversationId: ctx.conversationId,
         contractB64: ctx.envelope?.base64,
+        goalMode: ctx.goalMode ?? undefined,
     });
     const args = buildCliArgs(ctx.options, { yolo: ctx.yolo, allowCliFlags: true });
     // Claude Code logged in via claude.ai (OAuth) PREEMPTS ANTHROPIC_API_KEY, so
@@ -489,6 +570,7 @@ function launchRemoteControl(ctx) {
             MNEMOM_AGENT_RC_AGENT: ctx.agent,
             MNEMOM_AGENT_RC_CONVERSATION_ID: ctx.conversationId,
             MNEMOM_AGENT_RC_CONTRACT_B64: ctx.envelope?.base64 ?? "",
+            MNEMOM_AGENT_RC_GOAL_MODE: ctx.goalMode ?? "",
             MNEMOM_AGENT_RC_PROXY_LOG: proxyLog,
             MNEMOM_AGENT_RC_PARENT_PID: String(process.pid),
         },
@@ -720,14 +802,30 @@ function seedContextHintFlag(childEnv) {
 // ───────────────────────────────────────────────────────────────────────────
 // Human-facing logging (never prints the key)
 // ───────────────────────────────────────────────────────────────────────────
-function logLaunch(ctx) {
+/**
+ * Which goal-alignment mode the launch status line names: a sealed contract →
+ * "on"; `--implicit` (mode header, no contract) → "implicit"; neither → "off".
+ * A sealed contract and a mode header never coexist (`assembleContract` refuses
+ * the combination), so the first arm winning is not a precedence choice.
+ */
+export function goalAlignmentMode(envelope, goalMode) {
+    if (envelope)
+        return "on";
+    if (goalMode)
+        return "implicit";
+    return "off";
+}
+export function logLaunch(ctx) {
     say(`mnemom agent: routing ${ctx.cli.name} through ${ctx.door} [${ctx.cellNote}] as '${ctx.agent}' (conversation ${ctx.conversationId}).`);
     if (ctx.envelope) {
         say(`mnemom agent: contract statement: ${ctx.envelope.contract.statement}`);
         say(`mnemom agent: contract sha256[0:16]: ${ctx.envelope.sha}`);
     }
+    else if (ctx.goalMode) {
+        say(`mnemom agent: goal mode: ${ctx.goalMode} (inferred from your messages; watch x-mnemom-goal-revision / x-mnemom-goal-steer on each response)`);
+    }
 }
-function printPlan(ctx) {
+export function printPlan(ctx) {
     const L = [];
     L.push("mnemom agent — launch plan (dry run)");
     L.push(`  scenario:      ${ctx.scenario}`);
@@ -741,6 +839,10 @@ function printPlan(ctx) {
         L.push(`  contract:      ${ctx.envelope.canonical}`);
         L.push(`  contract sha:  ${ctx.envelope.sha}`);
     }
+    else if (ctx.goalMode) {
+        L.push("  contract:      (none — implicit goal mode: the gateway infers the goal from your messages)");
+        L.push(`  goal mode:     ${ctx.goalMode}`);
+    }
     else {
         L.push("  contract:      (none — no contract flag given)");
     }
@@ -748,3 +850,11 @@ function printPlan(ctx) {
     L.push("  Dry run — no key was read and nothing was launched.");
     process.stdout.write(`${L.join("\n")}\n`);
 }
+/**
+ * Header-value hygiene for the Anthropic key: the key is spliced into the newline-joined
+ * ANTHROPIC_CUSTOM_HEADERS block (`x-api-key: <key>`), so an embedded CR/LF from a multi-line
+ * paste would inject extra header lines. Same rule resolveConversationId applies to its input.
+ */
+function stripCrlf(raw) {
+    return raw.replace(/[\r\n]+/g, "").trim();
+}

package/dist/commands/validate.js

@@ -12,7 +12,7 @@
  * green — useful for shell scripts and the `mnemom/deploy` gate-guard
  * workflow which can call the CLI rather than parse the JSON itself.
  */
-import { fmt } from "../lib/format.js";
+import { fmt, formatRelativeAge } from "../lib/format.js";
 import { requireAuth } from "../lib/auth.js";
 import { getSafeHouseHarnessState } from "../lib/api.js";
 /**
@@ -32,21 +32,6 @@ function parseMaxAge(input) {
     const ms = n * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[unit];
     return ms;
 }
-function formatRelativeAge(startedAt) {
-    const ageMs = Date.now() - Date.parse(startedAt);
-    if (ageMs < 0)
-        return "in the future?";
-    const m = Math.floor(ageMs / 60_000);
-    if (m < 1)
-        return "<1m ago";
-    if (m < 60)
-        return `${m}m ago`;
-    const h = Math.floor(m / 60);
-    if (h < 24)
-        return `${h}h ${m % 60}m ago`;
-    const d = Math.floor(h / 24);
-    return `${d}d ${h % 24}h ago`;
-}
 function evaluateLane(lane, run, maxAgeMs) {
     if (!run) {
         return {