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

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

@@ -38,7 +38,7 @@ import { fmt } from "../lib/format.js";
 import { askInput, askSelect, askYesNo, isInteractive } from "../lib/prompt.js";
 import { goalAlignmentLine, resolveSessionSetup } from "./agent-session.js";
 import { defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, } from "./agent-setup.js";
-import { assembleContract, buildGoalModeHeader, buildCustomHeaders, isProdGateway, launchPreferenceExplicit, remoteControlAllowed, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, resolveRemoteControlShape, sanitizeAgentName, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildSessionConfigB64, resolveContextFold, isProdGateway, launchPreferenceExplicit, 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);
@@ -96,6 +96,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 +143,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,
@@ -235,6 +243,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 +255,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             conversationId,
             envelope,
             goalMode,
+            sessionConfigB64,
             options,
             yolo,
             contextHint,
@@ -260,6 +272,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         scenario,
         envelope,
         goalMode,
+        sessionConfigB64,
         options,
         yolo,
     });
@@ -544,6 +557,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 +606,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

@@ -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
@@ -204,7 +213,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

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
@@ -352,8 +361,36 @@ 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);

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.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {