@mnemom/mnemom 0.17.21 → 0.17.23

package/README.md

@@ -45,6 +45,7 @@ That's it. `mnemom init` detects your configured AI provider API keys (Anthropic
 | `mnemom card validate <file>` | Validate card JSON locally                           |
 | `mnemom usage --org <id>`     | Show per-person token and request consumption        |
 | `mnemom agent [name]`         | Launch a governed coding agent through the gateway   |
+| `mnemom agent export [agent]` | Save an agent's full record to a file (JSON or CSV)  |
 
 ### `mnemom agent` — goal alignment
 
@@ -192,22 +193,33 @@ which request is a compaction (a gateway that does not read them ignores them).
 never sets or changes your own auto-compaction settings (`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`,
 `CLAUDE_CODE_AUTO_COMPACT_WINDOW`, or `autoCompactWindow` in settings.json).
 
-**Experimental, off by default.** `--compaction-intercept` (after `mnemom experimental enable
-compaction-intercept`; standing default `mnemom agent config set compaction_intercept on`, or
-`MNEMOM_AGENT_COMPACTION_INTERCEPT=1`) sends `GATEWAY_USAGE_REAL_SIZE=on` and
-`GATEWAY_COMPACTION_INTERCEPT=on` in the per-session config header, asking the gateway to report
-the real context size (so Claude Code compacts at its own threshold) and to answer that
-compaction at once from its fold instead of a blocking model call. This needs the companion
-gateway support: a gateway without it drops both keys (they are echoed back in
-`x-mnemom-session-config-dropped`) and the session behaves exactly as with the setting off. `--no-compaction-intercept` turns it off for
-one launch.
+**Compaction intercept: on by default (since 0.17.23).** Every launch sends
+`GATEWAY_USAGE_REAL_SIZE=on` and `GATEWAY_COMPACTION_INTERCEPT=on` in the per-session config
+header, asking the gateway to report the real context size (so Claude Code compacts at its own
+threshold) and to answer that compaction at once from its fold instead of a blocking model call.
+This matches the production gateway cell's own default, so the header mainly makes the setting
+explicit and keeps every cell consistent; the launch banner shows it as
+`compaction: intercept on (gateway)`. A gateway without the companion support drops both keys
+(they are echoed back in `x-mnemom-session-config-dropped`) and the session behaves as before.
+
+It used to be experimental (`mnemom experimental enable compaction-intercept`); that command is
+now a harmless no-op that says so. To turn it off, use any of:
+
+```bash
+mnemom agent my-task --no-compaction-intercept          # this launch only
+mnemom agent config set compaction_intercept false      # persists in ~/.mnemom/launcher.toml
+export MNEMOM_AGENT_COMPACTION_INTERCEPT=0              # for every launch in this shell
+```
+
+An opt-out sends both keys as `off` by name, so it also turns the intercept off on a cell whose
+own default is on (sending nothing would leave that cell intercepting).
 
 #### Compaction target (`--compact-at`)
 
 `--compact-at <n|200k|1m|off>` lets you play with WHEN the gateway pulls this session's own
 compaction point forward, instead of leaving it entirely to Claude Code's normal 1M-window
 schedule. **Unset, `1m`, or `off` all mean no target** — Claude Code runs its normal 1M window
-and the launcher sends nothing new (byte-identical to a launch without this setting at all). A
+and the launcher sends no target key (only the default intercept keys above). A
 token count below 1M (k/m suffixes OK, e.g. `200k` or `350000`, from 50k up to just under 1M)
 arms a gateway-side target for this session: the per-session config header carries
 `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` (the two keys a target needs to
@@ -222,10 +234,10 @@ nothing back, so the launcher prints a warning at launch (and in `--dry-run`) wh
 the target will be ignored, and a note when it can't tell the window (a passthrough `-- --model`,
 a resume, or a CLI other than Claude Code).
 
-**Arming a target needs the same opt-in as `--compaction-intercept`** (`mnemom experimental
-enable compaction-intercept`) — a target arms the identical pair of gateway keys, so it needs
-the identical gate; the flag itself stays visible in `--help` (it's the knob you asked for), only
-actually _arming_ a target is gated. Passing `--no-compaction-intercept` together with an armed
+**Arming a target needs no opt-in** (since 0.17.23 it rides on the default-on intercept). A
+target arms the intercept's two keys even when a standing `compaction_intercept = false` or
+`MNEMOM_AGENT_COMPACTION_INTERCEPT=0` turned it off, since the target cannot work without them.
+Passing `--no-compaction-intercept` together with an armed
 `--compact-at` is refused outright (they contradict: the target cannot arm without the intercept
 you just turned off). So is an armed `--compact-at` (or `--compaction-intercept`) with context
 profile `off`: with the fold off there is no fold to answer the compaction from.
@@ -234,7 +246,6 @@ Set it per launch, as a standing default, or in the environment (flag > env > `l
 default):
 
 ```bash
-mnemom experimental enable compaction-intercept # one-time opt-in
 mnemom agent my-task --compact-at 200k          # this launch only
 mnemom agent config set compact_at 200k         # persists in ~/.mnemom/launcher.toml
 export MNEMOM_COMPACT_AT=200k                   # for every launch in this shell
@@ -244,6 +255,31 @@ export MNEMOM_COMPACT_AT=200k                   # for every launch in this shell
 Code default (1M)`) and, when a target is set, the decoded session-config keys; the session
 ledger records the effective value.
 
+### `mnemom agent export` — an agent's full record
+
+`mnemom agent export [id-or-name]` saves the agent's full record — integrity checkpoints, score
+history, reclassifications, card amendments, disagreement reviews and policy evaluations with
+gaps — to `./mnemom-record-<agent>-<date>.json` (`--format csv` for CSV). Without an agent it
+uses `MNEMOM_AGENT`, else the agent saved in `~/.mnemom/launcher.toml` (`mnemom agent config
+set agent …`), else the agent of your latest `mnemom agent` launch. You need to be a member of
+the org that owns the agent.
+
+```bash
+mnemom agent export my-agent                        # everything, as JSON
+mnemom agent export my-agent --since 30d            # the last 30 days
+mnemom agent export my-agent --from 2026-09-01 --to 2026-09-30 --format csv
+mnemom agent export my-agent -o - | jq '.checkpoints | length'   # stdout; summary on stderr
+```
+
+`--from`/`--to` take an ISO-8601 date or datetime (a bare `--to` date includes that whole UTC
+day). The command refuses to overwrite an existing file unless you pass `--force`, and prints a
+summary: the period, rows per section, a SHA-256 checksum of the file (so a recipient can
+confirm it was not altered in transit) and the agent's public verification links. The file
+holds full checkpoint reasoning that outsiders normally see redacted, so it is written
+readable by you only (mode 0600); to prove the agent's record to someone without sharing the
+contents, send the public verification link instead. If the period is too large to export in
+one go, narrow it with `--since`, `--from` or `--to`.
+
 ## How It Works
 
 ```

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

@@ -0,0 +1,53 @@
+/**
+ * `mnemom agent export [id-or-name]` — download an agent's full record
+ * (`GET /v1/agents/{id}/compliance-export`) to a file, or to stdout with `-o -`.
+ *
+ * Without `[id-or-name]` the agent is, in order: MNEMOM_AGENT, the saved
+ * `agent` in ~/.mnemom/launcher.toml, then the agent of the newest launch in the
+ * session ledger (lib/agent-export.ts pickAgentRef).
+ *
+ * Pure apart from the injected deps (`resolveAgentId`, `agentSources`,
+ * `fetchExport`, `writeFile`, `writeStdout`, `out`, `err`, `now`), so every arm is
+ * unit-tested; `liveExportDeps` is the thin driver index.ts wires in. The
+ * parsing, counts, summary and error wording live in lib/agent-export.ts.
+ *
+ * Returns the process exit code (0 ok, 1 on any error) instead of exiting, so
+ * index.ts sets `process.exitCode` from it.
+ */
+import { type DefaultAgentSources, type ExportFlags } from "../lib/agent-export.js";
+export interface AgentExportDeps {
+    /** id-or-name → agent id. Exits itself when unresolvable. */
+    resolveAgentId: (ref: string) => Promise<string>;
+    /** Where the agent comes from when no `[id-or-name]` is given. */
+    agentSources: DefaultAgentSources;
+    fetchExport: (agentId: string, query: string) => Promise<{
+        body: Uint8Array;
+        headers: Headers;
+    }>;
+    /** Write owner-only (0600). Without `force`, throws EEXIST when the file exists. */
+    writeFile: (path: string, bytes: Uint8Array, force: boolean) => void;
+    writeStdout: (bytes: Uint8Array) => void;
+    out: (line: string) => void;
+    err: (line: string) => void;
+    now: () => Date;
+    apiBase: () => string;
+    websiteBase: () => string;
+}
+export interface PrivateFileOps {
+    chmodSync: (path: string, mode: number) => void;
+    writeFileSync: (path: string, bytes: Uint8Array, opts: {
+        mode: number;
+        flag: string;
+    }) => void;
+}
+/**
+ * Write `bytes` to `path` readable by the owner only. Without `force`, `wx`
+ * makes the no-overwrite check and the create one step. With `force`, an
+ * existing file is narrowed to 0600 BEFORE the write (so the new contents are
+ * never readable under its old mode) — chmod-and-catch-ENOENT rather than
+ * exists-then-chmod — and chmod'ed again after, since `writeFileSync` only
+ * applies `mode` to a file it creates.
+ */
+export declare function writePrivateFile(path: string, bytes: Uint8Array, force: boolean, ops?: PrivateFileOps): void;
+export declare const liveExportDeps: AgentExportDeps;
+export declare function agentExportCommand(ref: string | undefined, flags: ExportFlags, deps: AgentExportDeps): Promise<number>;

package/dist/commands/agent-export.js

@@ -0,0 +1,127 @@
+/**
+ * `mnemom agent export [id-or-name]` — download an agent's full record
+ * (`GET /v1/agents/{id}/compliance-export`) to a file, or to stdout with `-o -`.
+ *
+ * Without `[id-or-name]` the agent is, in order: MNEMOM_AGENT, the saved
+ * `agent` in ~/.mnemom/launcher.toml, then the agent of the newest launch in the
+ * session ledger (lib/agent-export.ts pickAgentRef).
+ *
+ * Pure apart from the injected deps (`resolveAgentId`, `agentSources`,
+ * `fetchExport`, `writeFile`, `writeStdout`, `out`, `err`, `now`), so every arm is
+ * unit-tested; `liveExportDeps` is the thin driver index.ts wires in. The
+ * parsing, counts, summary and error wording live in lib/agent-export.ts.
+ *
+ * Returns the process exit code (0 ok, 1 on any error) instead of exiting, so
+ * index.ts sets `process.exitCode` from it.
+ */
+import { chmodSync, writeFileSync } from "node:fs";
+import { readSessionRecords } from "../lib/agent-ledger.js";
+import { getComplianceExport, resolveAgentId } from "../lib/api.js";
+import { getApiUrl, getWebsiteUrl, MNEMOM_DIR } from "../lib/config.js";
+import { loadLauncherConfig } from "../lib/launcher-config.js";
+import { buildExportQuery, buildSummary, defaultOutputPath, exportErrorMessage, extractCounts, filenameLabel, formatSummaryLines, NO_AGENT_MESSAGE, parseExportFlags, pickAgentRef, sensitivityNote, writeErrorMessage, } from "../lib/agent-export.js";
+import { fmt } from "../lib/format.js";
+/**
+ * Write `bytes` to `path` readable by the owner only. Without `force`, `wx`
+ * makes the no-overwrite check and the create one step. With `force`, an
+ * existing file is narrowed to 0600 BEFORE the write (so the new contents are
+ * never readable under its old mode) — chmod-and-catch-ENOENT rather than
+ * exists-then-chmod — and chmod'ed again after, since `writeFileSync` only
+ * applies `mode` to a file it creates.
+ */
+export function writePrivateFile(path, bytes, force, ops = { chmodSync, writeFileSync }) {
+    if (force) {
+        try {
+            ops.chmodSync(path, 0o600);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    ops.writeFileSync(path, bytes, { mode: 0o600, flag: force ? "w" : "wx" });
+    ops.chmodSync(path, 0o600);
+}
+export const liveExportDeps = {
+    resolveAgentId: (ref) => resolveAgentId(ref),
+    agentSources: {
+        env: () => process.env.MNEMOM_AGENT,
+        configAgent: () => loadLauncherConfig().agent,
+        // The ledger is oldest-first on disk.
+        ledger: () => readSessionRecords({ dir: MNEMOM_DIR }).reverse(),
+    },
+    fetchExport: (agentId, query) => getComplianceExport(agentId, query),
+    writeFile: (path, bytes, force) => writePrivateFile(path, bytes, force),
+    writeStdout: (bytes) => {
+        process.stdout.write(bytes);
+    },
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    now: () => new Date(),
+    apiBase: getApiUrl,
+    websiteBase: getWebsiteUrl,
+};
+export async function agentExportCommand(ref, flags, deps) {
+    const now = deps.now();
+    let parsed;
+    try {
+        parsed = parseExportFlags(flags, now);
+    }
+    catch (error) {
+        deps.err(fmt.error(error.message));
+        return 1;
+    }
+    let target;
+    try {
+        target = pickAgentRef(ref, deps.agentSources);
+    }
+    catch (error) {
+        // A malformed ~/.mnemom/launcher.toml — its message names the file to fix.
+        deps.err(fmt.error(error.message));
+        return 1;
+    }
+    if (target === null) {
+        deps.err(fmt.error(NO_AGENT_MESSAGE));
+        return 1;
+    }
+    const agentId = await deps.resolveAgentId(target.ref);
+    const output = parsed.output ?? defaultOutputPath(filenameLabel(target.label, agentId), parsed.format, now);
+    const toStdout = output === "-";
+    let response;
+    try {
+        response = await deps.fetchExport(agentId, buildExportQuery(parsed.format, parsed.period));
+    }
+    catch (error) {
+        deps.err(fmt.error(exportErrorMessage(error, agentId)));
+        return 1;
+    }
+    try {
+        if (toStdout)
+            deps.writeStdout(response.body);
+        else
+            deps.writeFile(output, response.body, parsed.force);
+    }
+    catch (error) {
+        deps.err(fmt.error(writeErrorMessage(error, output)));
+        return 1;
+    }
+    const summary = buildSummary({
+        agentId,
+        output,
+        format: parsed.format,
+        period: parsed.period,
+        body: response.body,
+        counts: extractCounts(parsed.format, response.body, response.headers),
+        websiteBase: deps.websiteBase(),
+        apiBase: deps.apiBase(),
+    });
+    // With `-o -` stdout carries the record itself, so the summary goes to stderr.
+    const say = toStdout ? deps.err : deps.out;
+    if (parsed.json)
+        say(JSON.stringify(summary, null, 2));
+    else
+        for (const line of formatSummaryLines(summary))
+            say(line);
+    deps.err(fmt.dim(sensitivityNote(toStdout)));
+    return 0;
+}

package/dist/commands/agent.d.ts

@@ -94,10 +94,11 @@ export interface AgentOptions {
      */
     contextHandoff?: boolean;
     /**
-     * EXPERIMENTAL, off by default (payload-bound fix): tells the gateway
-     * `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` for this session only (real
-     * context size in usage, so Claude Code compacts at its OWN threshold; the compaction request
-     * answered at once from the gateway's fold). Absent/false ⇒ no header key.
+     * ON by default since 0.17.23 (payload-bound fix; graduated from experimental): tells the
+     * gateway `GATEWAY_USAGE_REAL_SIZE=on` + `GATEWAY_COMPACTION_INTERCEPT=on` for this session
+     * (real context size in usage, so Claude Code compacts at its OWN threshold; the compaction
+     * request answered at once from the gateway's fold). `false` (--no-compaction-intercept) sends
+     * both `"off"`; absent ⇒ MNEMOM_AGENT_COMPACTION_INTERCEPT / launcher.toml, else on.
      */
     compactionIntercept?: boolean;
     /**
@@ -135,6 +136,12 @@ export interface AgentOptions {
     /** Print the resolved launch plan and exit — no key read, no spawn. */
     dryRun?: boolean;
 }
+/**
+ * The intercept state as the launch banner and the dry-run plan print it. Context profile `off`
+ * sends the intercept off (`buildSessionConfig`), so it reads off there whatever the setting; an
+ * armed `--compact-at` target turns it on even over a standing opt-out.
+ */
+export declare function describeCompactionIntercept(profile: ContextProfile | null, compactionIntercept: boolean, compactAt: number | null): string;
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export declare function agentCommand(scenarioArg: string | undefined, options?: AgentOptions): Promise<void>;
 /** The Claude Code session id a passthrough `--resume <id>` / `-r <id>` / `--resume=<id>` names. */
@@ -399,6 +406,8 @@ export declare function printPlan(ctx: {
     contextProfile: ContextProfile | null;
     /** The resolved compaction target (`resolveCompactAt`); `null` = no target (default). */
     compactAt: number | null;
+    /** The resolved compaction intercept (`resolveCompactionIntercept`); on by default. */
+    compactionIntercept?: boolean;
     /** The decoded `x-mnemom-session-config` overlay (`buildSessionConfig`); empty ⇒ no header. */
     sessionConfig: Record<string, string>;
     /** The experimental features on for this launch (the header's `experimental` array). */

package/dist/commands/agent.js

@@ -53,21 +53,30 @@ import { CLI_VERSION } from "../version.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
 const CODE_STORE = LAUNCHER_STORE_PATH;
 const say = (line = "") => console.error(line);
-/** The one-line launch note when the compaction intercept is ON. */
-const COMPACTION_INTERCEPT_NOTE = "mnemom agent: compaction intercept ON (experimental) — requested from the gateway (GATEWAY_USAGE_REAL_SIZE, GATEWAY_COMPACTION_INTERCEPT); a gateway without the companion support drops both keys and the session runs as before.";
-const OFF_DROPS_COMPACTION_NOTE = "mnemom agent: compaction intercept off for this session — context profile off leaves compaction to the coding agent, so the standing compaction_intercept / compact_at setting is not sent.";
 /**
- * The compaction notes for a resolved launch. Context profile `off` sends the intercept off and
- * no target (`buildSessionConfig`), so a standing intercept or target is reported as dropped
- * rather than as ON.
+ * The intercept state as the launch banner and the dry-run plan print it. Context profile `off`
+ * sends the intercept off (`buildSessionConfig`), so it reads off there whatever the setting; an
+ * armed `--compact-at` target turns it on even over a standing opt-out.
+ */
+export function describeCompactionIntercept(profile, compactionIntercept, compactAt) {
+    if (profile === "off")
+        return "intercept off (context profile off)";
+    if (compactionIntercept || compactAt !== null)
+        return "intercept on (gateway)";
+    return "intercept off (opted out)";
+}
+/** Context profile off drops a standing compaction target: say so rather than show it as set. */
+const OFF_DROPS_TARGET_NOTE = "mnemom agent: context profile off leaves compaction to the coding agent, so the standing compact_at target is not sent.";
+/**
+ * The compaction lines for a resolved launch: the intercept (on by default since 0.17.23 — no
+ * longer an experimental line) and the compaction target.
  */
 function sayCompaction(profile, compactionIntercept, compactAt, window) {
     const off = profile === "off";
+    say(`mnemom agent: compaction: ${describeCompactionIntercept(profile, compactionIntercept, compactAt)}`);
     sayCompactAt(off ? null : compactAt, window);
-    if (off && (compactionIntercept || compactAt !== null))
-        say(OFF_DROPS_COMPACTION_NOTE);
-    else if (compactionIntercept)
-        say(COMPACTION_INTERCEPT_NOTE);
+    if (off && compactAt !== null)
+        say(OFF_DROPS_TARGET_NOTE);
 }
 /**
  * The one-line launch note for the context profile: `null` (none chosen — nothing is sent) names
@@ -310,6 +319,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             cli: planCli,
             contextProfile,
             compactAt,
+            compactionIntercept,
             sessionConfig,
             experimental,
             plugin: pluginFor(planCli.name).line,
@@ -1766,6 +1776,9 @@ export function printPlan(ctx) {
     L.push(`  yolo:          ${ctx.yolo ? "on (--dangerously-skip-permissions)" : "off"}`);
     L.push(`  context:       ${ctx.contextProfile ?? "cell default"}`);
     L.push(`  compaction:    ${describeCompactAt(ctx.compactAt)}`);
+    if (ctx.compactionIntercept !== undefined) {
+        L.push(`  intercept:     ${describeCompactionIntercept(ctx.contextProfile, ctx.compactionIntercept, ctx.compactAt).replace(/^intercept /, "")}`);
+    }
     const overlay = Object.entries(ctx.sessionConfig);
     if (overlay.length > 0) {
         L.push(`  session config (${SESSION_CONFIG_HEADER}):`);

package/dist/commands/experimental.js

@@ -3,7 +3,7 @@
  * features on and off (registry: lib/experimental.ts; stored in ~/.mnemom/config.json).
  */
 import { existsSync, readdirSync } from "node:fs";
-import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
+import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, graduatedNote, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
 import { loadCliConfig, setExperimentalEnabled } from "../lib/cli-config.js";
 import { MNEMOM_DIR } from "../lib/config.js";
 import { launcherEntries, loadLauncherConfig } from "../lib/launcher-config.js";
@@ -50,6 +50,13 @@ export function experimentalListCommand(opts = {}, deps = defaultDeps()) {
     deps.log("Turn one on with `mnemom experimental enable <id>`.");
 }
 function toggle(verb, rawId, deps) {
+    // A feature that graduated to on-by-default: accept its old id as a no-op with a note, so
+    // a script or an old README that still runs `mnemom experimental enable <id>` keeps working.
+    const note = graduatedNote((rawId ?? "").trim().toLowerCase());
+    if (note) {
+        deps.log(note);
+        return;
+    }
     const id = requireId(rawId, verb);
     const current = new Set(resolveExperimental({ stored: deps.stored(), env: {} }).enabled);
     if (verb === "enable")

package/dist/index.js

@@ -13,6 +13,7 @@ import { cardShowCommand, cardPublishCommand, cardValidateCommand, cardEditComma
 import { policyInitCommand, policyValidateCommand, policyPublishCommand, policyListCommand, policyTestCommand, policyEvaluateCommand, } from "./commands/policy.js";
 import { protectionShowCommand, protectionPublishCommand, protectionValidateCommand, protectionEditCommand, protectionDriftCommand, } from "./commands/protection.js";
 import { agentsListCommand, agentsClaimCommand, agentsMoveCommand } from "./commands/agents.js";
+import { agentExportCommand, liveExportDeps } from "./commands/agent-export.js";
 import { agentSessionsCommand, agentShowCommand, liveSessionDeps, } from "./commands/agent-sessions.js";
 import { agentGoalPinCommand, agentGoalResetCommand, agentGoalShowCommand, liveGoalDeps, } from "./commands/agent-goal.js";
 import { orgListCommand, orgShowCommand, orgUseCommand } from "./commands/org.js";
@@ -144,7 +145,7 @@ function printAgentHelp(verb) {
 const agentCmd = program
     .command("agent [session] [passthrough...]")
     .description("Launch your governed agent (Claude Code in v1) through the Mnemom gateway — governed identity + optional sealed goal contract. Plain `mnemom agent` asks for a session name. " +
-    "Sub-verbs: `setup` provisions your governed agent; `doctor` preflights prerequisites; `config …` manages persistent settings (~/.mnemom/launcher.toml); `--invite <token>` redeems a Mnemom Agent invitation (the one-liner your invitation email shows; `invite <token>` is its alias); `list` / `claim` / `move` manage the agents in your orgs; `sessions` lists your past launches and `show [ref]` merges one with its live goal state; `help [verb]` prints help and never launches.")
+    "Sub-verbs: `setup` provisions your governed agent; `doctor` preflights prerequisites; `config …` manages persistent settings (~/.mnemom/launcher.toml); `--invite <token>` redeems a Mnemom Agent invitation (the one-liner your invitation email shows; `invite <token>` is its alias); `list` / `claim` / `move` manage the agents in your orgs; `export` saves an agent's full record to a file; `sessions` lists your past launches and `show [ref]` merges one with its live goal state; `help [verb]` prints help and never launches.")
     .option("--goal <statement>", "Contract goal statement (required if any contract flag is given)")
     .option("--requirement <text>", "Contract requirement (repeatable)", collectRepeatable, [])
     .option("--allow <glob>", "Allowed path/glob (repeatable)", collectRepeatable, [])
@@ -203,7 +204,7 @@ const agentCmd = program
         throw new InvalidArgumentError(e.message);
     }
 }))
-    .addOption(new Option("--compact-at <n|200k|1m|off>", 'Play with WHEN the gateway pulls this session\'s own compaction point forward, instead of leaving it to Claude Code\'s normal 1M-window schedule. A token count below 1M (k/m suffix OK, e.g. "200k") arms the gateway\'s compaction target for this session; unset, "1m" or "off" all mean no target — Claude Code runs its normal 1M window and nothing new is sent. Arming a target needs `mnemom experimental enable compaction-intercept` (the same opt-in --compaction-intercept uses — a target arms the identical gateway keys) and is refused if you also pass --no-compaction-intercept. Never touches Claude Code\'s own autocompact env/window. Also: config key compact_at, env MNEMOM_COMPACT_AT.').argParser((v) => {
+    .addOption(new Option("--compact-at <n|200k|1m|off>", 'Play with WHEN the gateway pulls this session\'s own compaction point forward, instead of leaving it to Claude Code\'s normal 1M-window schedule. A token count below 1M (k/m suffix OK, e.g. "200k") arms the gateway\'s compaction target for this session; unset, "1m" or "off" all mean no target — Claude Code runs its normal 1M window and nothing new is sent. A target rides on the compaction intercept (on by default) and is refused if you also pass --no-compaction-intercept. Never touches Claude Code\'s own autocompact env/window. Also: config key compact_at, env MNEMOM_COMPACT_AT.').argParser((v) => {
     // Validate with the same parser the other two surfaces (MNEMOM_COMPACT_AT, launcher.toml
     // compact_at) use, but return the validated RAW string rather than parseCompactAt's
     // `number | null` — commander's own option-value handling coerces a parseArg return of
@@ -221,8 +222,8 @@ const agentCmd = program
 }))
     .addOption(new Option("--context-handoff", "EXPERIMENTAL (`mnemom experimental enable context-handoff`): register the `handoff(note)` MCP tool and tell the gateway to turn on the context-handoff capability for this session").hideHelp(hiddenUnless("context-handoff")))
     .option("--no-context-handoff", "Keep context handoff off for this launch even when launcher.toml (context_handoff = true) or MNEMOM_AGENT_CONTEXT_HANDOFF turns it on")
-    .addOption(new Option("--compaction-intercept", "EXPERIMENTAL (`mnemom experimental enable compaction-intercept`): tell the gateway to report the real context size (Claude Code compacts at its own threshold) and answer the compaction at once from its fold, for this session").hideHelp(hiddenUnless("compaction-intercept")))
-    .option("--no-compaction-intercept", "Keep the compaction intercept off for this launch even when launcher.toml (compaction_intercept = true) or MNEMOM_AGENT_COMPACTION_INTERCEPT turns it on")
+    .option("--compaction-intercept", "Turn the compaction intercept on for this launch even when launcher.toml (compaction_intercept = false) or MNEMOM_AGENT_COMPACTION_INTERCEPT=0 turns it off. On by default: the gateway reports the real context size (so Claude Code compacts at its own threshold) and answers the compaction at once from its fold")
+    .option("--no-compaction-intercept", "Turn the compaction intercept off for this launch (it is on by default) — Claude Code's compaction goes to the model as usual. To turn it off for every launch: config key compaction_intercept = false, or env MNEMOM_AGENT_COMPACTION_INTERCEPT=0")
     .option("--dry-run", "Print the resolved launch plan and exit — no key read, no spawn")
     .option("--first-run", "Show the first-run look again: what Mnemom would have saved on your last 30 days of Claude Code (runs on this machine, read-only, nothing uploaded) — then exit")
     .action(async (scenario, passthrough, opts) => {
@@ -277,19 +278,6 @@ const agentCmd = program
                 used: opts.contextHandoff === true,
             },
             { what: "--implicit", id: "implicit", used: opts.implicit === true },
-            {
-                what: "--compaction-intercept",
-                id: "compaction-intercept",
-                used: opts.compactionIntercept === true,
-            },
-            // --compact-at arms the SAME two gateway keys --compaction-intercept does
-            // (buildSessionConfig ORs them) — it needs the identical opt-in, not a free pass
-            // around it. `null`/unset ("1m"/"off"/no flag) is not a target, so it never gates.
-            {
-                what: "--compact-at",
-                id: "compaction-intercept",
-                used: typeof compactAtFlag === "number",
-            },
         ], experimental);
         if (opts.gateway)
             process.env.MNEMOM_AGENT_GATEWAY = opts.gateway;
@@ -378,16 +366,13 @@ const agentCmd = program
             slack: opts.slack ?? cfg.slackListen,
             context: opts.context,
             contextProfile: opts.contextProfile,
-            // Same gate: off ⇒ an explicit null (no target), so MNEMOM_COMPACT_AT cannot arm it —
-            // an armed --compact-at was already refused above, and ignoredSettingLines told the
-            // user the env value is ignored, so this is what makes that true.
-            compactAt: experimental.includes("compaction-intercept") ? compactAtFlag : null,
+            // undefined ⇒ MNEMOM_COMPACT_AT / launcher.toml compact_at (resolveCompactAt).
+            compactAt: compactAtFlag,
             // Off ⇒ an explicit false, so MNEMOM_AGENT_CONTEXT_HANDOFF cannot turn it on.
             contextHandoff: experimental.includes("context-handoff") ? opts.contextHandoff : false,
-            // Same gate: off ⇒ an explicit false, so MNEMOM_AGENT_COMPACTION_INTERCEPT cannot turn it on.
-            compactionIntercept: experimental.includes("compaction-intercept")
-                ? opts.compactionIntercept
-                : false,
+            // On by default (since 0.17.23, no longer experimental): undefined ⇒
+            // MNEMOM_AGENT_COMPACTION_INTERCEPT / launcher.toml compaction_intercept, else ON.
+            compactionIntercept: opts.compactionIntercept,
             experimental,
             setup: opts.setup,
             governance,
@@ -875,6 +860,20 @@ agentCmd
         process.exit(1);
     }
 });
+agentCmd
+    .command("export [id-or-name]")
+    .description("Save an agent's full record (checkpoints, score history, corrections) to a file. " +
+    "Without id-or-name: MNEMOM_AGENT, else the saved agent (mnemom agent config), else the agent of your latest launch")
+    .option("--format <json|csv>", "File format (default: json)")
+    .option("--since <Nd|Nh>", "Only the last N days or hours (instead of --from)")
+    .option("--from <date>", "Start of the period (ISO-8601 date or datetime)")
+    .option("--to <date>", "End of the period (ISO-8601 date or datetime; a date includes that day)")
+    .option("-o, --output <file|->", "Where to write it; - for stdout (default: ./mnemom-record-<agent>-<date>.<format>)")
+    .option("--force", "Overwrite the output file if it exists")
+    .option("--json", "Print the summary as JSON")
+    .action(async (idOrName, opts) => {
+    process.exitCode = await agentExportCommand(idOrName, opts, liveExportDeps);
+});
 agentCmd
     .command("sessions")
     .description("List your Mnemom Agent sessions from the local ledger (~/.mnemom/sessions.jsonl), newest first — the last 20 unless --all")