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

package/README.md

@@ -71,6 +71,19 @@ 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.
+
 ## How It Works
 
 ```

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-setup.d.ts

@@ -115,3 +115,16 @@ export declare function ensureSessionAndBalance(opts: {
     orgLabel: string;
     entitlement: CodeEntitlement | null;
 }>;
+/**
+ * The account for a launch an orchestrator already preflighted
+ * (`MNEMOM_AGENT_PREFLIGHTED=1`, see launchPreflighted): no session prompt, no
+ * personal-org lookup, no µ-balance read. The entitlement is still fetched — it
+ * is the access gate and decides Remote Control fail-closed, which a caller's
+ * preflight can't vouch for. With no active org the api resolves the caller's
+ * primary org, and the ledger records the org id the entitlement names.
+ */
+export declare function resolvePreflightedAccount(): Promise<{
+    orgId: string;
+    orgLabel: string;
+    entitlement: CodeEntitlement | null;
+}>;

package/dist/commands/agent-setup.js

@@ -383,6 +383,20 @@ export async function ensureSessionAndBalance(opts) {
     await assertMuBalance(orgId, orgLabel);
     return { orgId, orgLabel, entitlement };
 }
+/**
+ * The account for a launch an orchestrator already preflighted
+ * (`MNEMOM_AGENT_PREFLIGHTED=1`, see launchPreflighted): no session prompt, no
+ * personal-org lookup, no µ-balance read. The entitlement is still fetched — it
+ * is the access gate and decides Remote Control fail-closed, which a caller's
+ * preflight can't vouch for. With no active org the api resolves the caller's
+ * primary org, and the ledger records the org id the entitlement names.
+ */
+export async function resolvePreflightedAccount() {
+    const active = getActiveOrg();
+    const orgLabel = active ? `${active.name} (${active.slug})` : "your primary org";
+    const entitlement = await assertCodeEnabled(active?.org_id ?? "", orgLabel);
+    return { orgId: active?.org_id ?? entitlement?.org_id ?? "", orgLabel, entitlement };
+}
 // ── The default coding posture (cards observe-only; goal contracts nudge) ────
 function buildCodeAlignmentCard(agentId) {
     return {

package/dist/commands/agent.js

@@ -35,18 +35,18 @@ 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, askSelect, askYesNo, isInteractive } from "../lib/prompt.js";
+import { askInput, 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, buildGoalModeHeader, buildCustomHeaders, buildSessionConfigB64, resolveContextFold, isProdGateway, launchPreferenceExplicit, remoteControlAllowed, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, resolveRemoteControlShape, sanitizeAgentName, } from "../lib/agent.js";
+import { defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, resolvePreflightedAccount, } from "./agent-setup.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildSessionConfigB64, resolveContextFold, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, resolveRemoteControlShape, 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: infer it from your messages (implicit), type a
-    // one-line goal (sealed), or off — no contract header and no mode header)
+    // goal alignment is implicit by default (inferred from your messages); --goal
+    // seals a contract and --no-implicit turns it off — all resolved upstream.
     const session = await resolveSessionSetup({
         scenario: scenarioArg,
         goal: options.goal,
@@ -55,7 +55,6 @@ export async function agentCommand(scenarioArg, options = {}) {
     }, {
         askInput: (q) => askInput(q),
         askYesNo: (q, d) => askYesNo(q, d),
-        askSelect: (q, o) => askSelect(q, o),
     });
     const scenario = session.scenario;
     const env = process.env;
@@ -165,9 +164,14 @@ 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).
+    // MNEMOM_AGENT_PREFLIGHTED=1 (orchestrators such as the ADW fleet that already
+    // ran their own session + balance preflight) skips those round trips; the
+    // entitlement is still fetched — see resolvePreflightedAccount.
     let account;
     try {
-        account = await ensureSessionAndBalance({ interactive: isInteractive() });
+        account = launchPreflighted(env)
+            ? await resolvePreflightedAccount()
+            : await ensureSessionAndBalance({ interactive: isInteractive() });
     }
     catch (err) {
         if (isQuietPreambleExit(err))
@@ -182,7 +186,11 @@ export async function agentCommand(scenarioArg, options = {}) {
     // terminal-only with a notice. FAIL-CLOSED — a null entitlement (gate failed
     // open) or an api without the field yields no Remote Control.
     const rcAllowed = remoteControlAllowed(account.entitlement);
-    const rc = checkRcCapability(cli);
+    // The capability probe (`claude --help`, up to 10s, plus `command -v` for node
+    // and openssl) only feeds the auto-upgrade. An explicit shape never auto-upgrades
+    // and a non-allowed account never gets Remote Control, so both skip it; an
+    // explicit RC launch still refuses a missing node/openssl in launchRemoteControl.
+    const rc = shapeExplicit || !rcAllowed ? { ok: false, missing: [] } : checkRcCapability(cli);
     // Preserve the "how to turn Remote Control on" guidance for an allowed account
     // whose machine can't do it yet and who didn't pin a shape (the old
     // applyAutoShape behaviour). Non-allowed accounts never see it — RC isn't

package/dist/index.js

@@ -113,8 +113,8 @@ const agentCmd = program
     .option("--budget <usd>", "Guardrail: spend ceiling in USD (positive number)")
     .option("--max-turns <n>", "Guardrail: turn ceiling (positive integer)")
     .option("--stall <n>", "Guardrail: consecutive no-write turns (positive integer)")
-    .option("--implicit", "Goal alignment without a sealed contract: the gateway infers the goal from your messages and revises it as you steer (not combinable with --goal/--requirement/--allow/--forbid/--goal-id; the guardrail ceilings still apply)")
-    .option("--no-implicit", "Goal alignment off for this launch even when launcher.toml sets goal_mode = implicit")
+    .option("--implicit", "Implicit goal alignment (the default): the gateway infers the goal from your messages and revises it as you steer (not combinable with --goal/--requirement/--allow/--forbid/--goal-id; the guardrail ceilings still apply)")
+    .option("--no-implicit", "Turn goal alignment OFF for this launch (implicit alignment is on by default; also overrides launcher.toml goal_mode = implicit)")
     .option("--conversation-id <id>", "x-mnemom-conversation-id (default: auto-generated)")
     .option("--cli <name|path>", "Coding-agent CLI to launch: a name or full path (default: claude)")
     .option("--gateway <url>", "Gateway host override (default: https://gateway.mnemom.ai; or MNEMOM_AGENT_GATEWAY)")

package/dist/lib/agent.d.ts

@@ -165,6 +165,16 @@ export declare function launchPreferenceExplicit(opts: {
     remoteControl?: boolean;
     server?: boolean;
 }, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Has an orchestrator already run the session + µ-balance preflight for this
+ * launch? `MNEMOM_AGENT_PREFLIGHTED=1` is for orchestrators (the ADW fleet) that
+ * checked sign-in and balance themselves before spawning many launches; it skips
+ * the per-launch session/personal-org/balance round trips. The Mnemom Agent
+ * entitlement (which also gates Remote Control, fail-closed) is still fetched.
+ * Only the exact value `1` counts — anything else, including `true` or ` 1`, is
+ * a normal launch.
+ */
+export declare function launchPreflighted(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Is this account allowed to use Remote Control (a session steerable from
  * claude.ai and the Claude app)? Remote Control is an INTERNAL Mnemom capability
@@ -244,8 +254,12 @@ export type GoalModeDefault = "implicit" | "off";
  *   1. an explicit flag — `--implicit` (true) or `--no-implicit` (false);
  *   2. a `--goal` statement — a sealed contract is a per-launch choice that the
  *      standing config default must never silently override;
- *   3. the config default `goal_mode = "implicit"`;
- *   4. off.
+ *   3. the config default `goal_mode` — `"off"` turns alignment off, `"implicit"`
+ *      keeps it implicit;
+ *   4. IMPLICIT (the default). A bare `mnemom agent` runs with implicit goal
+ *      alignment on: the gateway infers the goal from the user's own messages.
+ *      Turn it off for a launch with `--no-implicit`, or standing with
+ *      `goal_mode = "off"`.
  * Pure so every arm is unit-tested; the caller passes the resolved value on to
  * `assembleContract` / `buildGoalModeHeader` (which still refuse `--implicit`
  * combined with a contract flag — that conflict is EXPLICIT and is reported).

package/dist/lib/agent.js

@@ -300,6 +300,18 @@ export function launchPreferenceExplicit(opts, env = process.env) {
         return true;
     return (env.MNEMOM_AGENT_REMOTE_CONTROL ?? "").trim() !== "";
 }
+/**
+ * Has an orchestrator already run the session + µ-balance preflight for this
+ * launch? `MNEMOM_AGENT_PREFLIGHTED=1` is for orchestrators (the ADW fleet) that
+ * checked sign-in and balance themselves before spawning many launches; it skips
+ * the per-launch session/personal-org/balance round trips. The Mnemom Agent
+ * entitlement (which also gates Remote Control, fail-closed) is still fetched.
+ * Only the exact value `1` counts — anything else, including `true` or ` 1`, is
+ * a normal launch.
+ */
+export function launchPreflighted(env = process.env) {
+    return env.MNEMOM_AGENT_PREFLIGHTED === "1";
+}
 /**
  * Is this account allowed to use Remote Control (a session steerable from
  * claude.ai and the Claude app)? Remote Control is an INTERNAL Mnemom capability
@@ -396,8 +408,12 @@ export function buildSessionConfigB64(fold) {
  *   1. an explicit flag — `--implicit` (true) or `--no-implicit` (false);
  *   2. a `--goal` statement — a sealed contract is a per-launch choice that the
  *      standing config default must never silently override;
- *   3. the config default `goal_mode = "implicit"`;
- *   4. off.
+ *   3. the config default `goal_mode` — `"off"` turns alignment off, `"implicit"`
+ *      keeps it implicit;
+ *   4. IMPLICIT (the default). A bare `mnemom agent` runs with implicit goal
+ *      alignment on: the gateway infers the goal from the user's own messages.
+ *      Turn it off for a launch with `--no-implicit`, or standing with
+ *      `goal_mode = "off"`.
  * Pure so every arm is unit-tested; the caller passes the resolved value on to
  * `assembleContract` / `buildGoalModeHeader` (which still refuse `--implicit`
  * combined with a contract flag — that conflict is EXPLICIT and is reported).
@@ -407,5 +423,5 @@ export function resolveImplicit(opts) {
         return opts.implicit;
     if (hasText(opts.goal))
         return false;
-    return opts.configGoalMode === "implicit";
+    return opts.configGoalMode !== "off";
 }

package/package.json

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