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

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

@@ -13,7 +13,7 @@
  * local sha is never printed as "the sealed hash" and no mismatch is flagged —
  * only the server's hash is shown, labelled "sealed hash".
  */
-import { type SessionRecord } from "../lib/agent-ledger.js";
+import { type GoalMode, type SessionRecord } from "../lib/agent-ledger.js";
 import { type AgentSessionResponse } from "../lib/api.js";
 export interface SessionCommandDeps {
     /** The ledger, newest first. */
@@ -47,8 +47,19 @@ export interface SessionRefAmbiguous {
  *   - nothing matches (or the ledger is empty) → null.
  */
 export declare function resolveSessionRef(records: SessionRecord[], ref?: string): SessionRefMatch | SessionRefAmbiguous | null;
-/** Goal alignment as the ledger recorded it: a contract at launch ⇒ on. */
-export declare function localGoalFlag(record: SessionRecord): "on" | "off";
+/**
+ * Goal-alignment mode as the ledger recorded it. Prefers the explicit
+ * `goal_mode` (which alone distinguishes `implicit` from `off`); records
+ * written before that field existed fall back to `contract ? "on" : "off"`.
+ */
+export declare function localGoalFlag(record: SessionRecord): GoalMode;
+/**
+ * Goal-alignment mode for the `show` view: the live gateway state wins when it
+ * is present (a sealed contract ⇒ `on`), otherwise the locally recorded mode.
+ * A gateway with no sealed contract can still be an `implicit` session, so the
+ * local `goal_mode` fills that in.
+ */
+export declare function resolveGoalMode(local: SessionRecord, remote: AgentSessionResponse | null): GoalMode;
 /**
  * Render the ledger as a table, newest first — the newest
  * `DEFAULT_SESSIONS_LIMIT` rows unless `all`, with a footer naming the rest.
@@ -69,7 +80,7 @@ export interface ShowJson {
     session: SessionRecord & {
         source: "local";
     };
-    goal_alignment: "on" | "off";
+    goal_alignment: GoalMode;
     live: {
         source: "gateway";
         available: true;

package/dist/commands/agent-sessions.js

@@ -55,15 +55,46 @@ export function resolveSessionRef(records, ref) {
     return null;
 }
 // ─── sessions table ───────────────────────────────────────────────────────────
-const COL = { session: 26, started: 16, agent: 22, goal: 6, conv: 8 };
+const COL = { session: 26, started: 16, agent: 22, goal: 10, conv: 8 };
 function cell(text, width) {
     const max = width - 2;
     const shown = text.length > max ? `${text.slice(0, max - 1)}…` : text;
     return shown.padEnd(width);
 }
-/** Goal alignment as the ledger recorded it: a contract at launch ⇒ on. */
+/**
+ * Goal-alignment mode as the ledger recorded it. Prefers the explicit
+ * `goal_mode` (which alone distinguishes `implicit` from `off`); records
+ * written before that field existed fall back to `contract ? "on" : "off"`.
+ */
 export function localGoalFlag(record) {
-    return record.contract ? "on" : "off";
+    return record.goal_mode ?? (record.contract ? "on" : "off");
+}
+/**
+ * Goal-alignment mode for the `show` view: the live gateway state wins when it
+ * is present (a sealed contract ⇒ `on`), otherwise the locally recorded mode.
+ * A gateway with no sealed contract can still be an `implicit` session, so the
+ * local `goal_mode` fills that in.
+ */
+export function resolveGoalMode(local, remote) {
+    if (remote) {
+        // Live truth wins: a sealed contract ⇒ on. When the gateway has NO sealed
+        // contract, the session is either implicit or off — and only the local
+        // `goal_mode` distinguishes those. A stale local "on" (a contract that has
+        // since cleared/expired/been revoked on the gateway) must NOT resurrect an
+        // "on" the live state contradicts, so only "implicit" is recovered here.
+        if (remote.sealed !== null)
+            return "on";
+        return local.goal_mode === "implicit" ? "implicit" : "off";
+    }
+    return localGoalFlag(local);
+}
+/** The badge for a goal mode: on → green, implicit → cyan, off → yellow. */
+function goalBadge(mode) {
+    if (mode === "on")
+        return fmt.badge("ON", "green");
+    if (mode === "implicit")
+        return fmt.badge("IMPLICIT", "cyan");
+    return fmt.badge("OFF", "yellow");
 }
 /**
  * Render the ledger as a table, newest first — the newest
@@ -123,8 +154,8 @@ export function buildShowView(local, remote, reason) {
         launchBits.push(`effort ${local.effort}`);
     L.push(fmt.label("launch:       ", launchBits.join(" · ")));
     L.push(fmt.label("conversation: ", local.conversation_id));
-    const goalOn = remote ? remote.sealed !== null : local.contract !== null;
-    L.push(fmt.label("goal alignment:", goalOn ? fmt.badge("ON", "green") : fmt.badge("OFF", "yellow")));
+    const goalMode = resolveGoalMode(local, remote);
+    L.push(fmt.label("goal alignment:", goalBadge(goalMode)));
     if (local.contract) {
         L.push(fmt.label("goal (at launch):", local.contract.statement));
     }
@@ -176,10 +207,9 @@ export function buildShowView(local, remote, reason) {
     return L;
 }
 export function buildShowJson(local, remote, reason) {
-    const goalOn = remote ? remote.sealed !== null : local.contract !== null;
     return {
         session: { ...local, source: "local" },
-        goal_alignment: goalOn ? "on" : "off",
+        goal_alignment: resolveGoalMode(local, remote),
         live: remote
             ? {
                 source: "gateway",

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;
     /**
@@ -91,6 +97,7 @@ export declare function recordSessionLaunch(ctx: {
     options: AgentOptions;
     cli: ResolvedCli;
     envelope: SealedContractEnvelope | null;
+    goalMode: string | null;
 }): Promise<void>;
 /**
  * Resolve the Anthropic key with NO 1Password dependency (built for external

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,
@@ -231,9 +239,13 @@ export async function agentCommand(scenarioArg, options = {}) {
         options,
         cli,
         envelope,
+        goalMode,
     });
     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,
@@ -243,6 +255,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             conversationId,
             envelope,
             goalMode,
+            sessionConfigB64,
             options,
             yolo,
             contextHint,
@@ -259,6 +272,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         scenario,
         envelope,
         goalMode,
+        sessionConfigB64,
         options,
         yolo,
     });
@@ -292,6 +306,7 @@ export async function recordSessionLaunch(ctx) {
         effort: ctx.options.effort?.trim() || null,
         cli: ctx.cli.name,
         contract: toLedgerContract(ctx.envelope?.contract ?? null),
+        goal_mode: goalAlignmentMode(ctx.envelope, ctx.goalMode),
     }, { dir: MNEMOM_DIR, now: () => new Date(), pid: process.pid });
     if (!result.ok) {
         say(fmt.warn(`mnemom agent: could not record this session in ~/.mnemom/${LEDGER_FILE} (${result.error}) — launching anyway.`));
@@ -542,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
@@ -590,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-ledger.d.ts

@@ -46,7 +46,18 @@ export interface SessionRecord {
     /** The coding-agent CLI's basename, e.g. "claude". */
     cli: string;
     contract: SessionRecordContract | null;
+    /**
+     * The goal-alignment mode the launch ran under: `"on"` (a sealed contract),
+     * `"implicit"` (`--implicit` — the gateway infers the goal, no sealed
+     * contract), or `"off"`. Optional: records written before this field existed
+     * omit it, and readers fall back to `contract ? "on" : "off"` (an old
+     * `--implicit` launch is indistinguishable from `off` — its mode was never
+     * captured).
+     */
+    goal_mode?: GoalMode;
 }
+/** Goal-alignment mode as recorded at launch. */
+export type GoalMode = "off" | "on" | "implicit";
 /** What the call site supplies — the ledger stamps `v` and `started_at`. */
 export type SessionRecordInput = Omit<SessionRecord, "v" | "started_at">;
 /** The injected environment of the ledger. */

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