@mnemom/mnemom 0.17.2-next.2 → 0.17.2-next.4

package/README.md

@@ -71,6 +71,39 @@ Make one mode the standing default with `mnemom agent config set goal_mode impli
 (or `off`); `--goal` still seals for that launch and `--no-implicit` turns it off for one
 launch. A sealed contract needs a per-launch statement, so it cannot be the default.
 
+#### Orchestrated launches: `MNEMOM_AGENT_PREFLIGHTED=1`
+
+An orchestrator (the ADW fleet) that already checked sign-in and the µ balance before
+spawning many launches can set `MNEMOM_AGENT_PREFLIGHTED=1`. Each launch then skips its
+own session, personal-org and µ-balance requests. The Mnemom Agent entitlement is still
+fetched, because it gates access and Remote Control. Only the exact value `1` counts.
+This is not for interactive use: a launch with no session or no µ will fail at the
+gateway instead of printing the sign-in or top-up guidance.
+
+An explicit launch shape (`--remote-control`, `--server`, `MNEMOM_AGENT_REMOTE_CONTROL`
+or `launch` in `launcher.toml`) also skips the Remote Control capability probe
+(`claude --help`), which only feeds the automatic upgrade to Remote Control.
+
+#### Context handoff (experimental, off by default)
+
+**Off by default.** `--context-handoff` (or the standing default `mnemom agent config set
+context_handoff on`) registers one extra MCP tool, `handoff(note)`, that the agent can call
+itself — at a natural stopping point, or as soon as it sees a `[mnemom context warning]` line
+from the gateway — to hand a short note (goal, what's done, next action, open questions) to
+its own successor context ahead of the gateway's next fold. It also tells the gateway to turn
+the context-handoff capability on for that one session. Leaving the setting off (the default)
+sends neither the tool nor the header, and the launch is unaffected.
+
+Turn it on for a single launch with `--context-handoff`, or set the standing default:
+
+```bash
+mnemom agent config set context_handoff on   # persists in ~/.mnemom/launcher.toml
+mnemom agent config set context_handoff off  # back to the default
+```
+
+This is experimental: it only ever ADDS the one tool (no gateway behavior changes for a
+session that leaves the setting off, and no change to Claude Code's own `/compact`).
+
 ## How It Works
 
 ```

package/dist/commands/agent-config.js

@@ -187,6 +187,9 @@ function deleteKey(cfg, key) {
         case "key_source":
             delete cfg.keySource;
             break;
+        case "context_handoff":
+            delete cfg.contextHandoff;
+            break;
         default:
             requireSpec(key); // throws the known-keys message for anything unknown
     }

package/dist/commands/agent-goal.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `mnemom agent goal show|pin|reset` (implicit-goal CLI, cli-telemetry §1.4): read and steer the
+ * goal the gateway INFERRED for an implicit-mode session, through the gateway's control route
+ * (lib/goal-api.ts). The session is picked from the local ledger exactly like `mnemom agent show`
+ * (a name, newest match wins, or a unique conversation-id prefix; omitted = the newest session).
+ *
+ *   mnemom agent goal show  [ref] [--thread <id>|--all-threads] [--history] [--json]
+ *   mnemom agent goal pin   [ref] [--thread <id>] [--off] [--json]
+ *   mnemom agent goal reset [ref] [--thread <id>] [--statement <s>] [--requirement <r>...] [--yes] [--json]
+ *
+ * Exit codes: 0 ok; 1 no such session / auth or agent not found / gateway or network failure /
+ * reset declined at the prompt; 2 a usage error (not implicit mode, a bad --thread, --requirement
+ * without --statement, reset without --yes off a TTY) or a 409 from the gateway (sealed contract,
+ * nothing to pin).
+ *
+ * Pure apart from the injected deps, so every arm is unit-tested; `liveGoalDeps` is the driver
+ * index.ts wires in. Key material is never printed.
+ */
+import { type SessionRecord } from "../lib/agent-ledger.js";
+import { type FetchLike, type GoalControlCreds, type GoalShowResponse } from "../lib/goal-api.js";
+export interface GoalCommandDeps {
+    /** The ledger, newest first. */
+    readRecords: () => SessionRecord[];
+    fetch: FetchLike;
+    /** The launch's credential; rejects when no key resolves. */
+    resolveCreds: () => Promise<GoalControlCreds>;
+    isTTY: () => boolean;
+    confirm: (question: string) => Promise<boolean>;
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+/**
+ * The Anthropic key the launch would resolve (env, then ~/.mnemom/launcher.json), never prompted
+ * for. Lazy import: commands/agent.ts is the launcher and carries a heavy import graph.
+ */
+export declare function resolveLaunchCreds(): Promise<GoalControlCreds>;
+export declare const liveGoalDeps: GoalCommandDeps;
+export interface GoalShowOptions {
+    thread?: string;
+    allThreads?: boolean;
+    history?: boolean;
+    json?: boolean;
+}
+export interface GoalPinOptions {
+    thread?: string;
+    off?: boolean;
+    json?: boolean;
+}
+export interface GoalResetOptions {
+    thread?: string;
+    statement?: string;
+    requirement?: string[];
+    yes?: boolean;
+    json?: boolean;
+}
+/** A failed command: the message and the exit code. */
+declare class Exit extends Error {
+    readonly code: 1 | 2;
+    constructor(code: 1 | 2, message: string);
+}
+/** Validate `--thread` locally (same regex as the gateway); `all` only where `allowAll`. */
+export declare function parseThreadOption(raw: string | undefined, allowAll: boolean): string;
+/** The ledger record for `ref`, refusing anything that is not an implicit-mode session. */
+export declare function pickImplicitSession(records: SessionRecord[], ref: string | undefined): SessionRecord;
+/** A gateway / transport failure → the exit code and a message that never names the key. */
+export declare function mapGoalError(e: unknown, host: string): Exit;
+/** `rev 3 · pinned@3 · class refine · 2 pending`, or `rev 0 (no goal yet)`. */
+export declare function revisionLine(body: Pick<GoalShowResponse, "intent" | "last_revision">): string;
+/** The human view of one show body. */
+export declare function buildGoalShowView(record: SessionRecord, body: GoalShowResponse, opts: {
+    history?: boolean;
+}): string[];
+/** `mnemom agent goal show [ref] [--thread <id>|--all-threads] [--history] [--json]` */
+export declare function agentGoalShowCommand(ref: string | undefined, opts: GoalShowOptions, deps: GoalCommandDeps): Promise<number>;
+/** `mnemom agent goal pin [ref] [--thread <id>] [--off] [--json]` */
+export declare function agentGoalPinCommand(ref: string | undefined, opts: GoalPinOptions, deps: GoalCommandDeps): Promise<number>;
+/** `mnemom agent goal reset [ref] [--thread <id>] [--statement <s>] [--requirement <r>...] [--yes] [--json]` */
+export declare function agentGoalResetCommand(ref: string | undefined, opts: GoalResetOptions, deps: GoalCommandDeps): Promise<number>;
+export {};

package/dist/commands/agent-goal.js

@@ -0,0 +1,276 @@
+/**
+ * `mnemom agent goal show|pin|reset` (implicit-goal CLI, cli-telemetry §1.4): read and steer the
+ * goal the gateway INFERRED for an implicit-mode session, through the gateway's control route
+ * (lib/goal-api.ts). The session is picked from the local ledger exactly like `mnemom agent show`
+ * (a name, newest match wins, or a unique conversation-id prefix; omitted = the newest session).
+ *
+ *   mnemom agent goal show  [ref] [--thread <id>|--all-threads] [--history] [--json]
+ *   mnemom agent goal pin   [ref] [--thread <id>] [--off] [--json]
+ *   mnemom agent goal reset [ref] [--thread <id>] [--statement <s>] [--requirement <r>...] [--yes] [--json]
+ *
+ * Exit codes: 0 ok; 1 no such session / auth or agent not found / gateway or network failure /
+ * reset declined at the prompt; 2 a usage error (not implicit mode, a bad --thread, --requirement
+ * without --statement, reset without --yes off a TTY) or a 409 from the gateway (sealed contract,
+ * nothing to pin).
+ *
+ * Pure apart from the injected deps, so every arm is unit-tested; `liveGoalDeps` is the driver
+ * index.ts wires in. Key material is never printed.
+ */
+import { readSessionRecords } from "../lib/agent-ledger.js";
+import { MNEMOM_DIR } from "../lib/config.js";
+import { fmt, formatRelativeAge } from "../lib/format.js";
+import { GoalControlError, goalControlFetch, isValidGoalThread, } from "../lib/goal-api.js";
+import { askYesNo, isInteractive } from "../lib/prompt.js";
+import { localGoalFlag, resolveSessionRef } from "./agent-sessions.js";
+/**
+ * The Anthropic key the launch would resolve (env, then ~/.mnemom/launcher.json), never prompted
+ * for. Lazy import: commands/agent.ts is the launcher and carries a heavy import graph.
+ */
+export async function resolveLaunchCreds() {
+    const { resolveAnthropicKey } = await import("./agent.js");
+    try {
+        return { anthropicKey: await resolveAnthropicKey(process.env, { allowPrompt: false }) };
+    }
+    catch {
+        throw new Error("no Anthropic key in env (MNEMOM_AGENT_ANTHROPIC_KEY / ANTHROPIC_API_KEY) or ~/.mnemom/launcher.json — " +
+            "the goal commands authenticate with the same key the session launched with");
+    }
+}
+export const liveGoalDeps = {
+    readRecords: () => readSessionRecords({ dir: MNEMOM_DIR }).reverse(),
+    fetch: (url, init) => fetch(url, init),
+    resolveCreds: resolveLaunchCreds,
+    isTTY: () => isInteractive(),
+    confirm: (q) => askYesNo(q, false),
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+};
+/** A failed command: the message and the exit code. */
+class Exit extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** Validate `--thread` locally (same regex as the gateway); `all` only where `allowAll`. */
+export function parseThreadOption(raw, allowAll) {
+    const thread = raw?.trim() || "main";
+    if (!isValidGoalThread(thread)) {
+        throw new Exit(2, `invalid --thread '${raw}': use main, or a thread id such as a.<agent-id> (see \`mnemom agent goal show --all-threads\`)`);
+    }
+    if (thread === "all" && !allowAll) {
+        throw new Exit(2, "--thread all is read-only; pin and reset take one thread");
+    }
+    return thread;
+}
+/** The ledger record for `ref`, refusing anything that is not an implicit-mode session. */
+export function pickImplicitSession(records, ref) {
+    if (records.length === 0) {
+        throw new Exit(1, "No sessions yet — run `mnemom agent` to start one.");
+    }
+    const resolved = resolveSessionRef(records, ref);
+    if (resolved === null) {
+        throw new Exit(1, `No session matches '${ref ?? ""}' — try \`mnemom agent sessions\`.`);
+    }
+    if (resolved.record === null) {
+        const ids = resolved.candidates.map((c) => c.conversation_id.slice(0, 12)).join(", ");
+        throw new Exit(1, `'${ref ?? ""}' matches ${resolved.candidates.length} sessions (${ids}) — give more of the conversation id.`);
+    }
+    const mode = localGoalFlag(resolved.record);
+    if (mode !== "implicit") {
+        throw new Exit(2, `session is not in implicit goal mode (goal_mode=${mode})`);
+    }
+    return resolved.record;
+}
+/** A gateway / transport failure → the exit code and a message that never names the key. */
+export function mapGoalError(e, host) {
+    if (e instanceof Exit)
+        return e;
+    if (e instanceof GoalControlError) {
+        if (e.status === 409) {
+            if (e.code === "sealed_contract") {
+                return new Exit(2, "this conversation runs a sealed goal contract, not an implicit goal");
+            }
+            if (e.code === "nothing_to_pin") {
+                return new Exit(2, "this thread has no live goal to pin yet (rev 0)");
+            }
+            return new Exit(2, `the gateway refused: ${e.message}`);
+        }
+        if (e.status === 401) {
+            return new Exit(1, `the gateway on ${host} rejected the credential: ${e.message}`);
+        }
+        if (e.status === 404) {
+            if (e.code === "agent_not_found") {
+                return new Exit(1, `agent not found for this key on ${host}: was the session launched with a different key or agent?`);
+            }
+            if (e.code === "goal_intent_disabled") {
+                return new Exit(1, `implicit goal alignment is not enabled on ${host}`);
+            }
+            return new Exit(1, `${host} has no goal control route yet (HTTP 404)`);
+        }
+        if (e.status === 400)
+            return new Exit(2, `the gateway rejected the request: ${e.message}`);
+        if (e.status === 0)
+            return new Exit(1, e.message);
+        return new Exit(1, `the gateway on ${host} failed (HTTP ${e.status}): ${e.message}`);
+    }
+    return new Exit(1, e instanceof Error ? e.message : String(e));
+}
+async function run(deps, body) {
+    try {
+        await body();
+        return 0;
+    }
+    catch (e) {
+        const exit = mapGoalError(e, "the gateway");
+        deps.err(fmt.error(`mnemom agent goal: ${exit.message}`));
+        process.exitCode = exit.code;
+        return exit.code;
+    }
+}
+async function call(host, fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        throw mapGoalError(e, host);
+    }
+}
+// ─── show ─────────────────────────────────────────────────────────────────────
+function listOrDash(items) {
+    return items.length > 0 ? items.join(", ") : "—";
+}
+/** `rev 3 · pinned@3 · class refine · 2 pending`, or `rev 0 (no goal yet)`. */
+export function revisionLine(body) {
+    const i = body.intent;
+    if (!i) {
+        return body.last_revision > 0
+            ? `rev 0 (no goal yet; last revision ${body.last_revision})`
+            : "rev 0 (no goal yet)";
+    }
+    const bits = [`rev ${i.revision}`];
+    if (i.pinned)
+        bits.push(`pinned@${i.pinned.revision}`);
+    const last = i.history[i.history.length - 1];
+    if (last)
+        bits.push(`class ${last.class}`);
+    bits.push(`${i.pending_count} pending`);
+    return bits.join(" · ");
+}
+function intentLines(i, history) {
+    const L = [];
+    L.push(fmt.label("statement:      ", i.statement));
+    if (i.requirements.length === 0) {
+        L.push(fmt.label("requirements:   ", "—"));
+    }
+    else {
+        L.push(fmt.label("requirements:", ""));
+        for (const r of i.requirements)
+            L.push(`  - ${r}`);
+    }
+    L.push(fmt.label("allowed paths:  ", listOrDash(i.allowed_paths)));
+    L.push(fmt.label("forbidden paths:", listOrDash(i.forbidden_paths)));
+    if (history) {
+        L.push(fmt.label("history:", ""));
+        for (const h of i.history) {
+            L.push(`  r${h.revision}  ${h.class.padEnd(10)} ${String(h.ops).padStart(2)} ops  ${h.at}  ${h.source ?? "—"}`);
+        }
+    }
+    return L;
+}
+/** The human view of one show body. */
+export function buildGoalShowView(record, body, opts) {
+    const L = [];
+    L.push(fmt.label("session:        ", `${record.session} (${record.conversation_id.slice(0, 8)}, ${formatRelativeAge(record.started_at)})`));
+    L.push(fmt.label("thread:         ", body.thread));
+    if (body.mode === "sealed") {
+        L.push(fmt.dim(`  this conversation runs a sealed goal contract (hash ${body.sealed_hash ?? "?"})`));
+        return L;
+    }
+    L.push(revisionLine(body));
+    if (body.intent)
+        L.push(...intentLines(body.intent, opts.history === true));
+    const v = body.verdict;
+    L.push(fmt.label("verdict:        ", v
+        ? `${v.verdict.toUpperCase()} at turn ${v.turn}${v.superseded ? " (superseded)" : ""}`
+        : fmt.dim("none yet")));
+    if (body.threads) {
+        L.push(fmt.label("threads:", ""));
+        for (const t of body.threads) {
+            L.push(`  ${t.thread.padEnd(22)} ${t.role.padEnd(9)} rev ${t.revision}${t.pinned ? " · pinned" : ""}  ${t.statement ?? fmt.dim("(no goal)")}`);
+        }
+    }
+    return L;
+}
+/** `mnemom agent goal show [ref] [--thread <id>|--all-threads] [--history] [--json]` */
+export function agentGoalShowCommand(ref, opts, deps) {
+    return run(deps, async () => {
+        if (opts.allThreads && opts.thread && opts.thread.trim() !== "all") {
+            throw new Exit(2, "--thread and --all-threads are exclusive");
+        }
+        const thread = opts.allThreads ? "all" : parseThreadOption(opts.thread, true);
+        const record = pickImplicitSession(deps.readRecords(), ref);
+        const creds = await deps.resolveCreds();
+        const body = await call(record.gateway_host, () => goalControlFetch(record, "show", { thread }, { fetch: deps.fetch, creds }));
+        if (opts.json) {
+            deps.out(JSON.stringify({ gateway: { ...body, source: "gateway" }, ledger: { ...record, source: "ledger" } }, null, 2));
+            return;
+        }
+        for (const line of buildGoalShowView(record, body, { history: opts.history }))
+            deps.out(line);
+    });
+}
+// ─── pin ──────────────────────────────────────────────────────────────────────
+/** `mnemom agent goal pin [ref] [--thread <id>] [--off] [--json]` */
+export function agentGoalPinCommand(ref, opts, deps) {
+    return run(deps, async () => {
+        const thread = parseThreadOption(opts.thread, false);
+        const record = pickImplicitSession(deps.readRecords(), ref);
+        const creds = await deps.resolveCreds();
+        const pinned = opts.off !== true;
+        const body = await call(record.gateway_host, () => goalControlFetch(record, "pin", { thread, pinned }, { fetch: deps.fetch, creds }));
+        if (opts.json) {
+            deps.out(JSON.stringify({ ...body, source: "gateway" }, null, 2));
+            return;
+        }
+        deps.out(fmt.success(body.pinned
+            ? `pinned ${thread} at rev ${body.pinned.revision} — the gateway keeps this goal until \`mnemom agent goal pin --off\``
+            : `unpinned ${thread} (rev ${body.revision}) — new directions revise the goal again`));
+    });
+}
+// ─── reset ────────────────────────────────────────────────────────────────────
+/** `mnemom agent goal reset [ref] [--thread <id>] [--statement <s>] [--requirement <r>...] [--yes] [--json]` */
+export function agentGoalResetCommand(ref, opts, deps) {
+    return run(deps, async () => {
+        const thread = parseThreadOption(opts.thread, false);
+        const statement = opts.statement?.trim() || undefined;
+        const requirements = (opts.requirement ?? []).map((r) => r.trim()).filter((r) => r !== "");
+        if (requirements.length > 0 && statement === undefined) {
+            throw new Exit(2, "--requirement needs --statement (requirements belong to a stated goal)");
+        }
+        const record = pickImplicitSession(deps.readRecords(), ref);
+        if (!opts.yes) {
+            if (!deps.isTTY())
+                throw new Exit(2, "refusing to reset without --yes (no TTY to confirm on)");
+            const what = statement
+                ? `replace the ${thread} goal of '${record.session}' with your statement`
+                : `clear the ${thread} goal of '${record.session}' (the next message re-infers it)`;
+            if (!(await deps.confirm(`Reset: ${what}?`)))
+                throw new Exit(1, "reset cancelled");
+        }
+        const creds = await deps.resolveCreds();
+        const body = await call(record.gateway_host, () => goalControlFetch(record, "reset", {
+            thread,
+            ...(statement !== undefined ? { statement } : {}),
+            ...(requirements.length > 0 ? { requirements } : {}),
+        }, { fetch: deps.fetch, creds }));
+        if (opts.json) {
+            deps.out(JSON.stringify({ ...body, source: "gateway" }, null, 2));
+            return;
+        }
+        deps.out(fmt.success(body.intent
+            ? `reset ${thread} to your goal at rev ${body.revision} (was rev ${body.prior_revision})`
+            : `reset ${thread}: rev 0 (no goal yet) — the next message re-infers the goal as rev ${body.prior_revision + 1}`));
+    });
+}

package/dist/commands/agent-session.d.ts

@@ -6,28 +6,22 @@
  * a terminal we ask two things, explaining each in a sentence:
  *
  *   1. a SESSION NAME — labels the session in traces and the claude.ai session
- *      list (defaults to the current folder's name);
- *   2. GOAL ALIGNMENT — one of three:
- *      - INFER it from your messages (implicit mode): nothing to type; the
- *        gateway reads your own messages, revises the goal as you steer, and the
- *        judge nudges the agent back when it drifts (a little µ per new message
- *        and per judged turn). Sends `x-mnemom-goal-mode: implicit`, no contract.
- *      - TYPE a one-line goal: sealed as a contract for the session; the judge
- *        nudges against it (a little µ per turn). Sends `x-mnemom-contract`.
- *      - OFF: the session runs governed with goal alignment off — neither header
- *        is sent, so the gateway's goal hooks are simply not engaged.
+ *      list (defaults to the current folder's name).
+ *
+ * GOAL ALIGNMENT is not prompted for: it defaults to IMPLICIT. A bare launch
+ * runs governed with the goal inferred from your own messages
+ * (`x-mnemom-goal-mode: implicit`, no contract). `--goal` seals a one-line
+ * contract instead (`x-mnemom-contract`); `--no-implicit` (or launcher.toml
+ * `goal_mode = "off"`) turns alignment off — neither header is sent. The mode is
+ * resolved upstream (`resolveImplicit`) and announced on the launch line.
  *
  * Non-interactive runs (pipes, CI) never prompt — they get a clear error asking
- * for a name. `--goal` on the command line always wins over the prompt, and a
- * resolved implicit launch (`--implicit`, or launcher.toml `goal_mode =
- * "implicit"` with no `--no-implicit`) skips it too. Pure apart from the
- * injected `ask` functions, so every arm is unit-tested.
+ * for a name. Pure apart from the injected `ask` functions, so every arm is
+ * unit-tested.
  */
 export interface SessionAsk {
     askInput(question: string): Promise<string>;
     askYesNo(question: string, defaultYes: boolean): Promise<boolean>;
-    /** Numbered single-select; resolves the chosen label, or null on no/invalid choice. */
-    askSelect(question: string, options: string[]): Promise<string | null>;
 }
 export interface SessionSetupInput {
     /** The positional `[scenario]` (session name), if given. */
@@ -51,12 +45,6 @@ export interface SessionSetup {
     prompted: boolean;
 }
 export declare const NO_SESSION_NAME_MESSAGE: string;
-/** The three goal-alignment choices offered by the interactive prompt (labels are the select options). */
-export declare const GOAL_CHOICE_IMPLICIT = "Infer my goal from my messages \u2014 nothing to type; revised as I steer (implicit mode)";
-export declare const GOAL_CHOICE_TYPED = "Type a one-line goal \u2014 sealed as a contract for this session";
-export declare const GOAL_CHOICE_OFF = "Off \u2014 run governed with goal alignment off (Enter)";
-export declare const GOAL_CHOICES: readonly string[];
-export declare const GOAL_CHOICE_QUESTION = "Goal alignment for this session?";
 /** Current folder name, sanitised like an agent slug; "session" when that is empty. */
 export declare function defaultSessionName(cwd?: string): string;
 /** The one-line status printed at launch so the customer always knows the mode. */

package/dist/commands/agent-session.js

@@ -6,37 +6,23 @@
  * a terminal we ask two things, explaining each in a sentence:
  *
  *   1. a SESSION NAME — labels the session in traces and the claude.ai session
- *      list (defaults to the current folder's name);
- *   2. GOAL ALIGNMENT — one of three:
- *      - INFER it from your messages (implicit mode): nothing to type; the
- *        gateway reads your own messages, revises the goal as you steer, and the
- *        judge nudges the agent back when it drifts (a little µ per new message
- *        and per judged turn). Sends `x-mnemom-goal-mode: implicit`, no contract.
- *      - TYPE a one-line goal: sealed as a contract for the session; the judge
- *        nudges against it (a little µ per turn). Sends `x-mnemom-contract`.
- *      - OFF: the session runs governed with goal alignment off — neither header
- *        is sent, so the gateway's goal hooks are simply not engaged.
+ *      list (defaults to the current folder's name).
+ *
+ * GOAL ALIGNMENT is not prompted for: it defaults to IMPLICIT. A bare launch
+ * runs governed with the goal inferred from your own messages
+ * (`x-mnemom-goal-mode: implicit`, no contract). `--goal` seals a one-line
+ * contract instead (`x-mnemom-contract`); `--no-implicit` (or launcher.toml
+ * `goal_mode = "off"`) turns alignment off — neither header is sent. The mode is
+ * resolved upstream (`resolveImplicit`) and announced on the launch line.
  *
  * Non-interactive runs (pipes, CI) never prompt — they get a clear error asking
- * for a name. `--goal` on the command line always wins over the prompt, and a
- * resolved implicit launch (`--implicit`, or launcher.toml `goal_mode =
- * "implicit"` with no `--no-implicit`) skips it too. Pure apart from the
- * injected `ask` functions, so every arm is unit-tested.
+ * for a name. Pure apart from the injected `ask` functions, so every arm is
+ * unit-tested.
  */
 import { basename } from "node:path";
 import { sanitizeAgentName } from "../lib/agent.js";
 export const NO_SESSION_NAME_MESSAGE = "mnemom agent: a session name is required here (e.g. `mnemom agent onboarding`). " +
     "In a terminal, plain `mnemom agent` asks for one.";
-/** The three goal-alignment choices offered by the interactive prompt (labels are the select options). */
-export const GOAL_CHOICE_IMPLICIT = "Infer my goal from my messages — nothing to type; revised as I steer (implicit mode)";
-export const GOAL_CHOICE_TYPED = "Type a one-line goal — sealed as a contract for this session";
-export const GOAL_CHOICE_OFF = "Off — run governed with goal alignment off (Enter)";
-export const GOAL_CHOICES = [
-    GOAL_CHOICE_IMPLICIT,
-    GOAL_CHOICE_TYPED,
-    GOAL_CHOICE_OFF,
-];
-export const GOAL_CHOICE_QUESTION = "Goal alignment for this session?";
 /** Current folder name, sanitised like an agent slug; "session" when that is empty. */
 export function defaultSessionName(cwd = process.cwd()) {
     return sanitizeAgentName(basename(cwd)) || "session";
@@ -50,7 +36,7 @@ export function goalAlignmentLine(mode) {
     }
     return m === "on"
         ? "mnemom agent: goal alignment: on (the judge nudges the agent back when it drifts from your goal)"
-        : "mnemom agent: goal alignment: off (no goal set — pass --goal or --implicit, or set one when prompted)";
+        : "mnemom agent: goal alignment: off (--no-implicit or goal_mode = off — pass --goal or drop --no-implicit to turn it back on)";
 }
 const defaultSay = (line = "") => console.error(line);
 /**
@@ -79,36 +65,13 @@ export async function resolveSessionSetup(input, ask) {
     say(`  (Next time you can pass it directly: mnemom agent <name>.)`);
     const typed = await ask.askInput(`Session name [${fallback}]:`);
     const scenario = sanitizeAgentName(typed.trim()) || fallback;
-    // ── 2. goal alignment (skipped when --goal or implicit mode was resolved) ──
+    // ── 2. goal alignment — resolved upstream, no prompt. Implicit is the DEFAULT
+    // (a bare launch runs governed with the goal inferred from your messages), so
+    // there is nothing to pick here: `--goal` seals a contract, the default (and
+    // `--implicit` / `goal_mode = "implicit"`) is implicit, and `--no-implicit` /
+    // `goal_mode = "off"` turns it off. The launch line announces the mode.
     if (flagGoal) {
         return { scenario, goal: flagGoal, goalAlignment: "on", prompted: true };
     }
-    if (implicit) {
-        return { scenario, goalAlignment: "implicit", prompted: true };
-    }
-    say();
-    say("Goal alignment — how Mnemom keeps this session on track. Three choices:");
-    say("  Infer: nothing to type — the gateway reads your own messages, revises the goal as you");
-    say("    steer, and the judge nudges the agent back when it drifts (a little µ per message + turn).");
-    say("  Type a goal: one line, sealed as a contract; the judge nudges against it (a little µ per turn).");
-    say("  Off: the session runs governed with goal alignment off (the default — just press Enter).");
-    say("  (Make one the default: mnemom agent config set goal_mode implicit|off.)");
-    const choice = await ask.askSelect(GOAL_CHOICE_QUESTION, [...GOAL_CHOICES]);
-    if (choice === GOAL_CHOICE_IMPLICIT) {
-        return { scenario, goalAlignment: "implicit", prompted: true };
-    }
-    if (choice === GOAL_CHOICE_TYPED) {
-        const goal = (await ask.askInput("Goal (one line):")).trim();
-        if (!goal) {
-            say("  No goal entered — continuing with goal alignment off.");
-            return { scenario, goalAlignment: "off", prompted: true };
-        }
-        return { scenario, goal, goalAlignment: "on", prompted: true };
-    }
-    // Enter (no pick) and any invalid pick both resolve to null → off. Off is the
-    // deliberate default for now: a µ-costing mode is never picked by a bare Enter.
-    if (choice !== GOAL_CHOICE_OFF) {
-        say("  Goal alignment off (press 1 or 2 next time to turn it on).");
-    }
-    return { scenario, goalAlignment: "off", prompted: true };
+    return { scenario, goalAlignment: implicit ? "implicit" : "off", prompted: true };
 }

package/dist/commands/agent-sessions.d.ts

@@ -15,11 +15,17 @@
  */
 import { type GoalMode, type SessionRecord } from "../lib/agent-ledger.js";
 import { type AgentSessionResponse } from "../lib/api.js";
+import { type GoalShowResponse } from "../lib/goal-api.js";
 export interface SessionCommandDeps {
     /** The ledger, newest first. */
     readRecords: () => SessionRecord[];
     /** The live state from mnemom-api; rejects when unreachable / not found. */
     fetchSession: (conversationId: string, agentId: string, orgId: string) => Promise<AgentSessionResponse>;
+    /**
+     * The live implicit goal from the gateway's control route (`GET /mnemom/goal/intent`), for the
+     * one `live goal` line an implicit session gets. Optional: absent ⇒ no line.
+     */
+    fetchGoal?: (record: SessionRecord) => Promise<GoalShowResponse>;
     out: (line: string) => void;
     err: (line: string) => void;
 }
@@ -35,15 +41,17 @@ export interface SessionRefMatch {
 }
 export interface SessionRefAmbiguous {
     record: null;
-    /** Every record whose conversation id starts with the ref. */
+    /** The newest record of each distinct conversation whose id starts with the ref. */
     candidates: SessionRecord[];
 }
 /**
  * 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;
+ *   - else a conversation-id prefix → the newest record of the one conversation it names
+ *     (a relaunch / `--resume` appends another row for the same conversation id, which is not
+ *     ambiguity), or `{record: null, candidates}` — newest row per conversation — when several
+ *     distinct conversations share the prefix (an exact full id among them wins);
  *   - nothing matches (or the ledger is empty) → null.
  */
 export declare function resolveSessionRef(records: SessionRecord[], ref?: string): SessionRefMatch | SessionRefAmbiguous | null;
@@ -106,5 +114,7 @@ export interface AgentShowOptions {
 }
 /** Why the live read could not happen, from the thrown error. */
 export declare function unavailableReason(err: unknown): string;
+/** `rev N[ · pinned]` from a live show body, or `rev 0 (no goal yet)`. */
+export declare function liveGoalLine(body: GoalShowResponse): string;
 /** `mnemom agent show [ref] [--json]` */
 export declare function agentShowCommand(ref: string | undefined, opts: AgentShowOptions, deps: SessionCommandDeps): Promise<void>;