@mnemom/mnemom 0.17.2-next.1 → 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.d.ts

@@ -52,6 +52,12 @@ export interface AgentOptions {
     trimMcp?: boolean;
     /** yolo default: commander `--no-yolo` sets this false. */
     yolo?: boolean;
+    /**
+     * Context folding: undefined = default ON, false = `--no-context`, true =
+     * `--context`. When OFF the launch sends `x-mnemom-session-config` telling the
+     * gateway to skip folding for this session only.
+     */
+    context?: boolean;
     /** context-hint seed default: commander `--no-context-hint` sets this false. */
     contextHint?: boolean;
     /**

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, 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;
@@ -96,6 +95,11 @@ export async function agentCommand(scenarioArg, options = {}) {
     const cellNote = isProdGateway(env) ? "us-2/prod" : `custom (${gatewayHost})`;
     const yolo = options.yolo !== false; // default ON
     const contextHint = options.contextHint !== false; // default ON
+    // Context folding is ON by default; --no-context (or `context = false` in
+    // launcher.toml → MNEMOM_AGENT_CONTEXT) turns it off for this session via the
+    // per-session config header. `undefined` sessionConfigB64 ⇒ nothing sent.
+    const contextFold = resolveContextFold({ context: options.context, env });
+    const sessionConfigB64 = buildSessionConfigB64(contextFold);
     // ── which CLI executable (name or full path) ── resolve GRACEFULLY: if it's not
     // found we don't crash with a technical error — we ask for the path at launch.
     let cli;
@@ -138,6 +142,9 @@ export async function agentCommand(scenarioArg, options = {}) {
         if (previewShape === "remote-control") {
             say("mnemom agent: the plan shows Remote Control because this machine can run it; the real launch uses it only if your account is entitled (internal Mnemom accounts), else terminal-only.");
         }
+        if (!contextFold) {
+            say("mnemom agent: context folding OFF for this session (--no-context or context = false).");
+        }
         return;
     }
     // Real launch: make sure we actually have a CLI to run. If we couldn't find it,
@@ -157,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))
@@ -174,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
@@ -235,6 +251,9 @@ export async function agentCommand(scenarioArg, options = {}) {
     });
     logLaunch({ shape, door, agent, conversationId, cellNote, envelope, goalMode, cli });
     say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
+    if (!contextFold) {
+        say("mnemom agent: context folding OFF for this session (--no-context or context = false).");
+    }
     if (shape === "terminal") {
         launchTerminal({
             cli,
@@ -244,6 +263,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             conversationId,
             envelope,
             goalMode,
+            sessionConfigB64,
             options,
             yolo,
             contextHint,
@@ -260,6 +280,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         scenario,
         envelope,
         goalMode,
+        sessionConfigB64,
         options,
         yolo,
     });
@@ -544,6 +565,7 @@ function launchTerminal(ctx) {
         conversationId: ctx.conversationId,
         contractB64: ctx.envelope?.base64,
         goalMode: ctx.goalMode ?? undefined,
+        sessionConfigB64: ctx.sessionConfigB64,
     });
     const args = buildCliArgs(ctx.options, { yolo: ctx.yolo, allowCliFlags: true });
     // Claude Code logged in via claude.ai (OAuth) PREEMPTS ANTHROPIC_API_KEY, so
@@ -592,6 +614,7 @@ function launchRemoteControl(ctx) {
             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_SESSION_CONFIG: ctx.sessionConfigB64 ?? "",
             MNEMOM_AGENT_RC_PROXY_LOG: proxyLog,
             MNEMOM_AGENT_RC_PARENT_PID: String(process.pid),
         },

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)")
@@ -134,6 +134,8 @@ const agentCmd = program
     .option("--no-setup", "Skip governed-agent provisioning entirely for this launch")
     .option("--no-yolo", "Do NOT pass --dangerously-skip-permissions (yolo is on by default)")
     .option("--no-context-hint", "Do NOT seed Claude Code's context-hint feature flag before launch")
+    .option("--context", "Force context folding ON for this launch even when launcher.toml (context = false) or MNEMOM_AGENT_CONTEXT turns it off")
+    .option("--no-context", "Disable context folding for this launch (folding is on by default; tells the gateway to skip it for this session)")
     .option("--dry-run", "Print the resolved launch plan and exit — no key read, no spawn")
     .action(async (scenario, passthrough, opts) => {
     try {
@@ -215,6 +217,7 @@ const agentCmd = program
             trimMcp: opts.trimMcp,
             yolo: opts.yolo,
             contextHint: opts.contextHint,
+            context: opts.context,
             setup: opts.setup,
             keySource: cfg.keySource,
             passthrough,

package/dist/lib/agent.d.ts

@@ -126,6 +126,15 @@ export interface SealedContractEnvelope {
 export declare function assembleContract(flags: ContractFlags): SealedContractEnvelope | null;
 /** The request header that opts a conversation into implicit goal mode. */
 export declare const GOAL_MODE_HEADER = "x-mnemom-goal-mode";
+/**
+ * Per-session env overlay the gateway honours (`session-config.ts`
+ * SESSION_CONFIG_HEADER). base64url(JSON) of `{ v, config: { KEY: "value" } }`,
+ * keys drawn from the gateway's allow-list. Today the CLI uses it for exactly
+ * one thing: turning context folding off for a single launch.
+ */
+export declare const SESSION_CONFIG_HEADER = "x-mnemom-session-config";
+/** The gateway env key that gates context folding (allow-listed for per-session overlay). */
+export declare const CONTEXT_RUNTIME_KEY = "CONTEXT_RUNTIME_ENABLED";
 /**
  * The `x-mnemom-goal-mode` header value for `--implicit`, or null when the flag
  * is absent: `implicit[; max_turns=N][; budget_usd=X][; stall_turns=N]` — the
@@ -156,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
@@ -204,7 +223,26 @@ export declare function buildCustomHeaders(opts: {
     contractB64?: string;
     /** `buildGoalModeHeader` output for an `--implicit` launch. */
     goalMode?: string;
+    /** `buildSessionConfigB64` output — the per-session env overlay (e.g. fold off). */
+    sessionConfigB64?: string;
 }): string;
+/**
+ * Whether context folding is ON for this launch. Folding is a gateway feature
+ * that summarises older turns to fit the window; it is ON by default. Precedence:
+ * an explicit `--context`/`--no-context` flag wins, else `MNEMOM_AGENT_CONTEXT`
+ * (which `applyConfigToEnv` sets from the `context` config key), else ON.
+ * Recognised OFF values for the env var: `0`, `false`, `off`, `no` (case-insensitive).
+ */
+export declare function resolveContextFold(opts: {
+    context?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+/**
+ * The `x-mnemom-session-config` value that turns context folding OFF, or
+ * `undefined` when folding is ON (the default — nothing is sent, the gateway's
+ * own default stands). base64url so it survives the gateway's inbound strip.
+ */
+export declare function buildSessionConfigB64(fold: boolean): string | undefined;
 /**
  * The persistable goal-alignment default (`launcher.toml` `goal_mode`). Only the
  * two statement-free modes can be a standing default: a SEALED contract needs a
@@ -216,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

@@ -186,6 +186,15 @@ export function assembleContract(flags) {
 }
 /** The request header that opts a conversation into implicit goal mode. */
 export const GOAL_MODE_HEADER = "x-mnemom-goal-mode";
+/**
+ * Per-session env overlay the gateway honours (`session-config.ts`
+ * SESSION_CONFIG_HEADER). base64url(JSON) of `{ v, config: { KEY: "value" } }`,
+ * keys drawn from the gateway's allow-list. Today the CLI uses it for exactly
+ * one thing: turning context folding off for a single launch.
+ */
+export const SESSION_CONFIG_HEADER = "x-mnemom-session-config";
+/** The gateway env key that gates context folding (allow-listed for per-session overlay). */
+export const CONTEXT_RUNTIME_KEY = "CONTEXT_RUNTIME_ENABLED";
 const SEALED_ONLY_FLAGS = "--goal/--requirement/--allow/--forbid/--goal-id";
 /**
  * `--implicit` and a sealed contract are mutually exclusive: on the gateway a
@@ -291,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
@@ -352,15 +373,47 @@ export function buildCustomHeaders(opts) {
         lines.push(`x-mnemom-contract: ${opts.contractB64}`);
     if (opts.goalMode)
         lines.push(`${GOAL_MODE_HEADER}: ${opts.goalMode}`);
+    if (opts.sessionConfigB64)
+        lines.push(`${SESSION_CONFIG_HEADER}: ${opts.sessionConfigB64}`);
     return lines.join("\n");
 }
+/**
+ * Whether context folding is ON for this launch. Folding is a gateway feature
+ * that summarises older turns to fit the window; it is ON by default. Precedence:
+ * an explicit `--context`/`--no-context` flag wins, else `MNEMOM_AGENT_CONTEXT`
+ * (which `applyConfigToEnv` sets from the `context` config key), else ON.
+ * Recognised OFF values for the env var: `0`, `false`, `off`, `no` (case-insensitive).
+ */
+export function resolveContextFold(opts) {
+    if (opts.context !== undefined)
+        return opts.context;
+    const raw = (opts.env?.MNEMOM_AGENT_CONTEXT ?? "").trim().toLowerCase();
+    if (raw === "")
+        return true;
+    return !(raw === "0" || raw === "false" || raw === "off" || raw === "no");
+}
+/**
+ * The `x-mnemom-session-config` value that turns context folding OFF, or
+ * `undefined` when folding is ON (the default — nothing is sent, the gateway's
+ * own default stands). base64url so it survives the gateway's inbound strip.
+ */
+export function buildSessionConfigB64(fold) {
+    if (fold)
+        return undefined;
+    const payload = JSON.stringify({ v: 1, config: { [CONTEXT_RUNTIME_KEY]: "false" } });
+    return Buffer.from(payload, "utf8").toString("base64url");
+}
 /**
  * Is this launch implicit-mode? Precedence, highest wins:
  *   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).
@@ -370,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/dist/lib/launcher-config.d.ts

@@ -31,6 +31,8 @@ export interface LauncherConfig {
     keySource?: KeySource;
     /** Standing goal-alignment default when neither --goal nor --implicit is given. */
     goalMode?: GoalModeDefault;
+    /** Context folding default (on when unset; `false` disables it for every launch). */
+    context?: boolean;
     guardrails?: {
         maxTurns?: number;
         budgetUsd?: number;
@@ -45,7 +47,7 @@ export interface LauncherConfig {
 export interface ConfigKeySpec {
     key: string;
     describe: string;
-    get(cfg: LauncherConfig): string | number | undefined;
+    get(cfg: LauncherConfig): string | number | boolean | undefined;
     set(cfg: LauncherConfig, raw: string): void;
 }
 /** The full set of settable keys — drives get/set/unset/list and validation. */

package/dist/lib/launcher-config.js

@@ -38,6 +38,16 @@ function coerceEffort(raw) {
         return v;
     throw new Error(`effort must be one of ${EFFORTS.join(", ")} (got '${raw}').`);
 }
+const TRUE_WORDS = ["true", "1", "on", "yes"];
+const FALSE_WORDS = ["false", "0", "off", "no"];
+function coerceBool(name, raw) {
+    const s = raw.trim().toLowerCase();
+    if (TRUE_WORDS.includes(s))
+        return true;
+    if (FALSE_WORDS.includes(s))
+        return false;
+    throw new Error(`${name} must be a boolean (${[...TRUE_WORDS, ...FALSE_WORDS].join("|")}); got '${raw}'.`);
+}
 function coerceKeySource(raw) {
     const v = raw.trim();
     if (KEY_SOURCES.includes(v))
@@ -127,6 +137,14 @@ export const CONFIG_KEYS = [
             c.goalMode = coerceGoalMode(v);
         },
     },
+    {
+        key: "context",
+        describe: "Context folding (on by default; false disables it for every launch)",
+        get: (c) => c.context,
+        set: (c, v) => {
+            c.context = coerceBool("context", v);
+        },
+    },
     {
         key: "guardrails.max_turns",
         describe: "Contract guardrail: turn ceiling (positive integer)",
@@ -193,6 +211,8 @@ export function parseLauncherConfig(text) {
         cfg.keySource = coerceKeySource(str(raw.key_source) ?? "");
     if (raw.goal_mode !== undefined)
         cfg.goalMode = coerceGoalMode(str(raw.goal_mode) ?? "");
+    if (raw.context !== undefined)
+        cfg.context = coerceBool("context", str(raw.context) ?? "");
     const g = raw.guardrails;
     if (g !== undefined) {
         if (typeof g !== "object" || g === null || Array.isArray(g)) {
@@ -251,6 +271,8 @@ export function serializeLauncherConfig(cfg) {
         doc.key_source = cfg.keySource;
     if (cfg.goalMode !== undefined)
         doc.goal_mode = cfg.goalMode;
+    if (cfg.context !== undefined)
+        doc.context = cfg.context;
     const g = cfg.guardrails;
     if (g && (g.maxTurns !== undefined || g.budgetUsd !== undefined || g.stallTurns !== undefined)) {
         const gr = {};
@@ -297,4 +319,7 @@ export function applyConfigToEnv(cfg, env = process.env) {
         env.MNEMOM_AGENT_REMOTE_CONTROL =
             cfg.launch === "server" ? "server" : cfg.launch === "remote-control" ? "1" : "0";
     }
+    if (cfg.context !== undefined && !(env.MNEMOM_AGENT_CONTEXT ?? "").trim()) {
+        env.MNEMOM_AGENT_CONTEXT = cfg.context ? "1" : "0";
+    }
 }

package/dist/rc-proxy.mjs

@@ -64,6 +64,7 @@
 //   MNEMOM_AGENT_RC_CONTRACT_B64      base64 contract for x-mnemom-contract (optional)
 //   MNEMOM_AGENT_RC_GOAL_MODE         x-mnemom-goal-mode value (optional; `--implicit` — no contract,
 //                                  the gateway infers the goal from the user's messages)
+//   MNEMOM_AGENT_RC_SESSION_CONFIG    x-mnemom-session-config value (optional; per-session env overlay, e.g. context folding off)
 //   MNEMOM_AGENT_RC_PROVIDER          x-mnemom-provider directive JSON (optional; router door)
 //   MNEMOM_AGENT_RC_THREAD_MODE       `reject` (default: answer thread-bearing requests locally,
 //                                  see above) | `strip` (legacy: delete `thread`, forward)
@@ -101,6 +102,7 @@ const CONV =
   env.MNEMOM_AGENT_RC_CONVERSATION_ID || die("MNEMOM_AGENT_RC_CONVERSATION_ID is required");
 const CONTRACT_B64 = env.MNEMOM_AGENT_RC_CONTRACT_B64 || "";
 const GOAL_MODE = env.MNEMOM_AGENT_RC_GOAL_MODE || "";
+const SESSION_CONFIG = env.MNEMOM_AGENT_RC_SESSION_CONFIG || "";
 const PROVIDER = env.MNEMOM_AGENT_RC_PROVIDER || "";
 const THREAD_MODE = env.MNEMOM_AGENT_RC_THREAD_MODE || "reject";
 if (THREAD_MODE !== "reject" && THREAD_MODE !== "strip")
@@ -351,6 +353,7 @@ function handle(req, res, viaPlain) {
     if (secrets.openai) headers["x-mnemom-egress-key"] = secrets.openai;
     if (CONTRACT_B64) headers["x-mnemom-contract"] = CONTRACT_B64;
     if (GOAL_MODE) headers["x-mnemom-goal-mode"] = GOAL_MODE;
+    if (SESSION_CONFIG) headers["x-mnemom-session-config"] = SESSION_CONFIG;
     if (headers["anthropic-beta"]) {
       // drop the OAuth-only beta tokens
       const b = String(headers["anthropic-beta"])

package/package.json

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