@mnemom/mnemom 0.17.20 → 0.17.22

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
 
@@ -244,6 +245,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-sessions.d.ts

@@ -110,11 +110,13 @@ export declare function formatTrailEntry(e: AgentSessionVerdictTrailEntry): stri
  */
 export declare function verdictTrailKey(e: Pick<AgentSessionVerdictTrailEntry, "request_id" | "turn">): string;
 /**
- * Best-effort "has this session ended" check for `--follow`'s exit condition. No field is locked
- * in on the wire yet: MNE-8149 adds an `expired` seal state on the gateway's row, and a later
- * mnemom-api card is expected to carry it through to this response — so this reads defensively,
- * off either the top-level response or the `sealed` block, and returns null (never throws) when
- * neither carries a recognized value, which is every server today.
+ * Best-effort "has this session ended" check for `--follow`'s exit condition. MNE-8234 wired the
+ * seal lifecycle through on the wire (`remote.seal.state`), so that is read first and is
+ * authoritative: `"expired"` there means the prior seal lapsed and ends the watch. The older
+ * top-level `state` and `remote.sealed.state` fallbacks predate that field actually landing on
+ * the response — neither has ever been observed non-null on any real server — and are kept
+ * defensively in case an even older/non-conformant server ever carries one of them; this never
+ * throws, returning null when nothing recognized is present.
  */
 export declare function sessionEndedState(remote: AgentSessionResponse): "expired" | "ended" | null;
 /** Default and floor for `--follow`'s poll interval. */
@@ -152,6 +154,14 @@ export interface ShowJson {
         guardrails: AgentSessionResponse["guardrails"];
         /** R10 (MNE-8200): oldest first (the gateway's own wire order), unlike the human view. */
         verdict_trail: AgentSessionResponse["verdict_trail"];
+        /**
+         * MNE-8234: the seal's lifecycle (state incl. `expired`, version, mode, hashes). Absent on
+         * an older server; `null` when the API reports no seal.
+         */
+        seal: AgentSessionResponse["seal"];
+        /** MNE-8234 (MNE-8166 R4): judging counts under the current seal. */
+        unjudged_turns: AgentSessionResponse["unjudged_turns"];
+        memoised_turns: AgentSessionResponse["memoised_turns"];
     } | {
         source: "gateway";
         available: false;

package/dist/commands/agent-sessions.js

@@ -190,14 +190,21 @@ export function verdictTrailKey(e) {
     return `${e.request_id ?? ""}#${e.turn}`;
 }
 /**
- * Best-effort "has this session ended" check for `--follow`'s exit condition. No field is locked
- * in on the wire yet: MNE-8149 adds an `expired` seal state on the gateway's row, and a later
- * mnemom-api card is expected to carry it through to this response — so this reads defensively,
- * off either the top-level response or the `sealed` block, and returns null (never throws) when
- * neither carries a recognized value, which is every server today.
+ * Best-effort "has this session ended" check for `--follow`'s exit condition. MNE-8234 wired the
+ * seal lifecycle through on the wire (`remote.seal.state`), so that is read first and is
+ * authoritative: `"expired"` there means the prior seal lapsed and ends the watch. The older
+ * top-level `state` and `remote.sealed.state` fallbacks predate that field actually landing on
+ * the response — neither has ever been observed non-null on any real server — and are kept
+ * defensively in case an even older/non-conformant server ever carries one of them; this never
+ * throws, returning null when nothing recognized is present.
  */
 export function sessionEndedState(remote) {
     const as = (v) => v === "expired" || v === "ended" ? v : null;
+    if (remote.seal) {
+        const sealState = as(remote.seal.state);
+        if (sealState)
+            return sealState;
+    }
     const top = as(remote.state);
     if (top)
         return top;
@@ -349,6 +356,12 @@ export function buildShowView(local, remote, reason) {
     else {
         L.push(fmt.dim("  no sealed contract on the gateway for this conversation"));
     }
+    // MNE-8234: the seal's lifecycle — independent of `sealed` above (which carries the contract
+    // body, not whether the seal itself is still live or has lapsed). Absent on an older server.
+    if (remote.seal) {
+        const modeBit = remote.seal.state === "live" ? ` · mode ${remote.seal.mode}` : "";
+        L.push(fmt.label("seal:           ", `${remote.seal.state.toUpperCase()} (v${remote.seal.version})${modeBit}`));
+    }
     if (remote.verdict) {
         const v = remote.verdict;
         L.push(fmt.label("verdict:        ", `${v.verdict.toUpperCase()} at turn ${v.turn} — ${v.reason}`));
@@ -385,6 +398,14 @@ export function buildShowView(local, remote, reason) {
     if (remote.turn !== null) {
         L.push(fmt.label("turn:           ", String(remote.turn)));
     }
+    // MNE-8234 (MNE-8166 R4): judging counts under the current seal. `null`/absent ⇒ no judge
+    // ledger counts (older server, or nothing judged under this seal yet) — no line then.
+    if (remote.unjudged_turns !== null && remote.unjudged_turns !== undefined) {
+        const memoisedBit = remote.memoised_turns !== null && remote.memoised_turns !== undefined
+            ? ` · memoised ${remote.memoised_turns}`
+            : "";
+        L.push(fmt.label("judging:        ", `unjudged ${remote.unjudged_turns}${memoisedBit}`));
+    }
     return L;
 }
 export function buildShowJson(local, remote, reason) {
@@ -400,6 +421,9 @@ export function buildShowJson(local, remote, reason) {
                 turn: remote.turn,
                 guardrails: remote.guardrails,
                 verdict_trail: remote.verdict_trail,
+                seal: remote.seal,
+                unjudged_turns: remote.unjudged_turns,
+                memoised_turns: remote.memoised_turns,
             }
             : { source: "gateway", available: false, reason: reason ?? "unknown" },
     };

package/dist/commands/agent.d.ts

@@ -127,7 +127,7 @@ export interface AgentOptions {
     /**
      * Load the "Mnemom for Claude Code" plugin (`plugins/mnemom`: the Mnemom band,
      * `/mnemom`, the gateway guard, Mnemom attribution) into the launched Claude Code.
-     * Default OFF (not published yet); `--plugin` ⇒ true; `--no-plugin` ⇒ false; undefined ⇒
+     * Default OFF (the plugin lands dark); `--plugin` ⇒ true; `--no-plugin` ⇒ false; undefined ⇒
      * MNEMOM_AGENT_PLUGIN decides (lib/claude-plugin).
      */
     plugin?: boolean;

package/dist/commands/agent.js

@@ -26,7 +26,7 @@
  * an argv value.
  */
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, renameSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { tmpdir, homedir, hostname } from "node:os";
 import { basename, join, dirname } from "node:path";
@@ -539,7 +539,7 @@ export async function agentCommand(scenarioArg, options = {}) {
         plugin: launchPlugin.line,
     });
     if (pluginWanted && cli.name === "claude" && !bundledPluginDir) {
-        say(fmt.warn("mnemom agent: the Mnemom plugin folder is not in this install (it is not published yet; run from a source checkout) — launching without the Mnemom band and /mnemom."));
+        say(fmt.warn("mnemom agent: the Mnemom plugin folder is not in this install — launching without the Mnemom band and /mnemom."));
     }
     // Non-secret launch facts for the plugin's band and `/mnemom status`. Built here, applied to the
     // child env by each launch shape AFTER it has built that env (lib/claude-plugin, PLUGIN_ENV).
@@ -1303,7 +1303,8 @@ function launchRemoteControl(ctx) {
         }
     }
     const proxyScript = resolveProxyScript();
-    const rcDir = mkdtempSync(join(tmpdir(), "mnemom-code-rc."));
+    const rcDir = mkdtempSync(join(rcStateRoot(), "mnemom-code-rc."));
+    writeFileSync(join(rcDir, "owner.pid"), `${process.pid}\n`, { mode: 0o600 }); // rc-state.mjs sweep
     const proxyLog = process.env.MNEMOM_AGENT_RC_PROXY_LOG || join(rcDir, "proxy.log");
     const proxy = spawn("node", [proxyScript], {
         env: {
@@ -1519,6 +1520,23 @@ function warnServerDrops(options, yolo) {
         say("mnemom agent: yolo (--dangerously-skip-permissions) is not applied under --server; set permissions from the driven sessions.");
     }
 }
+/**
+ * ~/.mnemom/rc, created 0700 — the same root src/rc-state.mjs gives the proxy's CA dir (tsc emits
+ * no .mjs, so this mirrors its rcStateRoot() rather than importing it). Never the OS temp dir,
+ * whose cleaners delete files behind a long session; that is only the fallback when home is not
+ * writable. Read at call time, not from MNEMOM_DIR: HOME can move after import (tests do).
+ */
+function rcStateRoot() {
+    const root = join(homedir(), ".mnemom", "rc");
+    try {
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+        chmodSync(root, 0o700);
+        return root;
+    }
+    catch {
+        return tmpdir();
+    }
+}
 function resolveProxyScript() {
     const here = dirname(fileURLToPath(import.meta.url));
     const cand = join(here, "..", "rc-proxy.mjs");

package/dist/commands/validate.d.ts

@@ -3,7 +3,7 @@
  * integration). Surface for engineers to check whether staging is safe
  * to promote to production based on the most recent harness run state.
  *
- *   mnemom validate safe-house [--against=staging] [--max-age=24h]
+ *   mnemom validate safe-house [--against=test] [--max-age=24h]
  *                              [--lane=full|fast] [--strict] [--json]
  *
  * Wraps `GET /v1/admin/safe-house/harness-state` (mnemom-staff only).

package/dist/commands/validate.js

@@ -3,7 +3,7 @@
  * integration). Surface for engineers to check whether staging is safe
  * to promote to production based on the most recent harness run state.
  *
- *   mnemom validate safe-house [--against=staging] [--max-age=24h]
+ *   mnemom validate safe-house [--against=test] [--max-age=24h]
  *                              [--lane=full|fast] [--strict] [--json]
  *
  * Wraps `GET /v1/admin/safe-house/harness-state` (mnemom-staff only).
@@ -76,10 +76,12 @@ export async function validateSafeHouseCommand(opts) {
     await requireAuth();
     // `--against` is informational only today (validation is always against
     // the api root the user is authenticated to). Keep the flag for forward-
-    // compat: production gains a separate harness corpus per T1.
-    const against = opts.against ?? "staging";
-    if (against !== "staging" && against !== "production") {
-        console.log(fmt.error(`--against must be 'staging' or 'production' (got '${against}')`) + "\n");
+    // compat: production gains a separate harness corpus per T1. The non-prod
+    // value is `test` (the Azure test cell): `staging` named the retired ring
+    // (MNE-7968) and is rejected so a stale script fails loud, not quietly.
+    const against = opts.against ?? "test";
+    if (against !== "test" && against !== "production") {
+        console.log(fmt.error(`--against must be 'test' or 'production' (got '${against}')`) + "\n");
         process.exit(1);
         return;
     }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./lib/retired-env-guard.js";
 import { program } from "commander";
 export { program };
 /**

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// MUST stay the first import: it exits cleanly on MNEMOM_ENV=staging before any
+// module below resolves the (retired) staging URLs at import time (MNE-7968).
+import "./lib/retired-env-guard.js";
 import { program, InvalidArgumentError, Option } from "commander";
 import { isEntrypoint } from "./lib/entrypoint.js";
 import { CLI_VERSION } from "./version.js";
@@ -10,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";
@@ -141,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; `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, [])
@@ -872,6 +876,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")
@@ -1656,7 +1674,7 @@ const validateCmd = program
 validateCmd
     .command("safe-house")
     .description("Render Safe House harness state per lane (full/fast) — promotion-readiness signal")
-    .option("--against <env>", "Target environment ('staging' or 'production'; informational)", "staging")
+    .option("--against <env>", "Target environment ('test' or 'production'; informational)", "test")
     .option("--max-age <duration>", "Reject runs older than this (e.g. 30m, 2h, 24h, 1d)", "24h")
     .option("--lane <lane>", "Show only one lane ('full', 'fast', or 'both')", "both")
     .option("--strict", "Exit non-zero if any selected lane is stale or red")

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

@@ -0,0 +1,133 @@
+/**
+ * `mnemom agent export` — the pure half: option parsing (format, --since /
+ * --from / --to), the default output filename, the per-section counts (from the
+ * JSON body / the CSV `X-Mnemom-Export-Counts` header), the summary, and the
+ * error-message mapping. No I/O here; the command driver
+ * (commands/agent-export.ts) does the network and filesystem work, so every
+ * branch below is unit-tested directly.
+ *
+ * Server side: `GET /v1/agents/{id}/compliance-export?format=json|csv&from=&to=`
+ * (mnemom-api reclassification/handlers.ts handleComplianceExport). `from`/`to`
+ * are passed straight into PostgREST `gte.`/`lte.` filters, so they are
+ * normalised here to full UTC ISO timestamps.
+ */
+import type { SessionRecord } from "./agent-ledger.js";
+export type ExportFormat = "json" | "csv";
+/** The record's sections, in the order the summary prints them. */
+export declare const EXPORT_SECTIONS: readonly ["checkpoints", "score_history", "reclassifications", "card_amendments", "disagreement_reviews", "policy_evaluations_with_gaps"];
+export type ExportSection = (typeof EXPORT_SECTIONS)[number];
+/** Rows per section; null = the server didn't say (and it couldn't be derived). */
+export type ExportCounts = Record<ExportSection, number | null>;
+export declare const COUNTS_HEADER = "X-Mnemom-Export-Counts";
+/** A bad flag value — reported as-is, before any network call. */
+export declare class ExportUsageError extends Error {
+    constructor(message: string);
+}
+export interface ExportFlags {
+    format?: string;
+    since?: string;
+    from?: string;
+    to?: string;
+    output?: string;
+    force?: boolean;
+    json?: boolean;
+}
+export interface ExportPeriod {
+    from: string | null;
+    to: string | null;
+}
+export interface ParsedExportFlags {
+    format: ExportFormat;
+    period: ExportPeriod;
+    /** The -o value as given; undefined = use the default filename. "-" = stdout. */
+    output?: string;
+    force: boolean;
+    json: boolean;
+}
+export declare function parseFormat(raw: string | undefined): ExportFormat;
+/** `--since 7d` / `--since 12h` → the UTC ISO timestamp that long before `now`. */
+export declare function parseSince(raw: string, now: Date): string;
+/**
+ * Validate an ISO-8601 date or datetime for `--from` / `--to` and normalise it to
+ * a UTC ISO timestamp. A bare date is a UTC day: `--from` starts at its first
+ * millisecond and `--to` includes the whole day (ends at its last millisecond).
+ * A datetime with no offset is read in local time, like `new Date()` does.
+ */
+export declare function parseDateBound(raw: string, flag: "--from" | "--to"): string;
+/** Resolve `--since` / `--from` / `--to` into the period sent to the server. */
+export declare function resolvePeriod(flags: ExportFlags, now: Date): ExportPeriod;
+/** All the flag validation, done locally before any network call. */
+export declare function parseExportFlags(flags: ExportFlags, now: Date): ParsedExportFlags;
+/** `?format=…&from=…&to=…` for the compliance-export route. */
+export declare function buildExportQuery(format: ExportFormat, period: ExportPeriod): string;
+export declare const NO_AGENT_MESSAGE = "No agent given. Pass one: mnemom agent export <id-or-name> (see mnemom agent list)";
+/** What to resolve (`ref`, an id or name) and what to name the default file after (`label`). */
+export interface AgentRef {
+    ref: string;
+    label: string;
+}
+/** Where the no-argument default comes from; each is read only if the ones before it are empty. */
+export interface DefaultAgentSources {
+    /** MNEMOM_AGENT. */
+    env: () => string | undefined;
+    /** The saved `agent` in ~/.mnemom/launcher.toml (throws on a malformed file). */
+    configAgent: () => string | undefined;
+    /** The session ledger, newest launch first. */
+    ledger: () => SessionRecord[];
+}
+/**
+ * The agent to export: the positional `[id-or-name]` when given; else, in
+ * order, MNEMOM_AGENT, the saved launcher-config `agent`, and the agent of the
+ * newest launch in the session ledger that resolved one (resolved by id, named
+ * after its slug). null when none of them has an agent.
+ */
+export declare function pickAgentRef(given: string | undefined, sources: DefaultAgentSources): AgentRef | null;
+/** The filename-safe agent label: `label` sanitised; the resolved id when that leaves nothing. */
+export declare function filenameLabel(label: string, agentId: string): string;
+/** `./mnemom-record-<label>-<YYYY-MM-DD>.<json|csv>` (UTC date). */
+export declare function defaultOutputPath(label: string, format: ExportFormat, now: Date): string;
+/**
+ * Counts from a JSON export body: the server's `counts` object where it has a
+ * section, else the length of that section's array. null when the body is not
+ * a JSON object.
+ */
+export declare function countsFromJsonBody(text: string): ExportCounts | null;
+export declare function countsFromHeader(header: string | null): ExportCounts | null;
+export declare function extractCounts(format: ExportFormat, body: Uint8Array, headers: Headers): ExportCounts | null;
+export declare function sha256Hex(bytes: Uint8Array): string;
+export interface VerificationLinks {
+    reputation_url: string;
+    verify_url: string;
+}
+export declare function verificationLinks(agentId: string, websiteBase: string, apiBase: string): VerificationLinks;
+export interface ExportSummary {
+    agent_id: string;
+    /** The file written, or "-" for stdout. */
+    output: string;
+    format: ExportFormat;
+    period: ExportPeriod;
+    counts: ExportCounts | null;
+    bytes: number;
+    /** SHA-256 of the exact bytes written — a file checksum, not a signature. */
+    sha256: string;
+    verification: VerificationLinks;
+}
+export declare function buildSummary(input: {
+    agentId: string;
+    output: string;
+    format: ExportFormat;
+    period: ExportPeriod;
+    body: Uint8Array;
+    counts: ExportCounts | null;
+    websiteBase: string;
+    apiBase: string;
+}): ExportSummary;
+export declare function describePeriod(period: ExportPeriod): string;
+/** The human summary, one line per entry (no colour; the driver adds none). */
+export declare function formatSummaryLines(summary: ExportSummary): string[];
+/** The one-line sensitivity note (the driver prints it dim, on stderr). */
+export declare function sensitivityNote(toStdout: boolean): string;
+/** The user-facing message for a failed export request. */
+export declare function exportErrorMessage(error: unknown, agentId: string): string;
+/** The user-facing message for a failed file write. */
+export declare function writeErrorMessage(error: unknown, path: string): string;