prae-cli 0.7.1 → 0.9.1

package/lib/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import "./evaluate-wMPkjcIC.js";
-import "./views-UODslKwu.js";
-import { t as main } from "./cli-mahLCjoD.js";
-import "./src-Ciggx9ja.js";
+import "./views-CIg2ZNG0.js";
+import { t as main } from "./cli-7yLG89gV.js";
+import "./src-D7g4lvaY.js";
 
 //#region src/bin.ts
 main(process.argv.slice(2)).catch((error) => {

package/lib/checkpoint-BWSuhZ5h.js

@@ -0,0 +1,99 @@
+import { m as canonical, s as fingerprint } from "./src-D7g4lvaY.js";
+import { createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+
+//#region src/checkpoint.ts
+/** What the signature covers: the facts, never the timestamp or the name of the key. */
+function signable(cp) {
+	return Buffer.from(canonical({
+		ledger: cp.ledger,
+		entries: cp.entries,
+		head: cp.head
+	}));
+}
+function makeCheckpoint(rows, ledger, privateKeyPem, at = (/* @__PURE__ */ new Date()).toISOString()) {
+	const head = rows.at(-1);
+	const cp = {
+		prae: "checkpoint/1",
+		at,
+		ledger,
+		entries: rows.length,
+		head: head === void 0 ? {
+			seq: -1,
+			hash: ""
+		} : {
+			seq: head.seq,
+			hash: head.hash
+		}
+	};
+	if (privateKeyPem === void 0) return cp;
+	const key = createPrivateKey(privateKeyPem);
+	const publicKey = createPublicKey(key).export({
+		type: "spki",
+		format: "pem"
+	}).toString();
+	return {
+		...cp,
+		fingerprint: fingerprint(publicKey),
+		sig: sign(null, signable(cp), key).toString("base64")
+	};
+}
+/**
+* The ledger as it is now, against the checkpoint as it was then. Rows may
+* have been appended since; nothing before the head may differ.
+*/
+function checkCheckpoint(rows, cp, publicKeyPem) {
+	const lines = [];
+	let ok = true;
+	if (cp.prae !== "checkpoint/1") return {
+		ok: false,
+		lines: [`not a checkpoint: prae is ${String(cp.prae)}`]
+	};
+	if (publicKeyPem !== void 0) if (cp.sig === void 0) {
+		ok = false;
+		lines.push("checkpoint is not signed; a key was given to check it against");
+	} else {
+		let good = false;
+		try {
+			good = verify(null, signable(cp), createPublicKey(publicKeyPem), Buffer.from(cp.sig, "base64"));
+		} catch {
+			good = false;
+		}
+		if (good) lines.push(`checkpoint signature verifies against ${fingerprint(publicKeyPem)}`);
+		else {
+			ok = false;
+			lines.push(`checkpoint signature FAILS against ${fingerprint(publicKeyPem)} — the checkpoint itself has been altered or was signed by another key`);
+		}
+	}
+	if (rows.length < cp.entries) {
+		ok = false;
+		lines.push(`ledger holds ${rows.length} rows; the checkpoint of ${cp.at} recorded ${cp.entries} — ${cp.entries - rows.length} row${cp.entries - rows.length === 1 ? "" : "s"} removed since`);
+		return {
+			ok,
+			lines
+		};
+	}
+	if (cp.entries === 0) {
+		lines.push(`checkpoint of ${cp.at} recorded an empty ledger; ${rows.length} rows since`);
+		return {
+			ok,
+			lines
+		};
+	}
+	const then = rows.find((row) => row.seq === cp.head.seq);
+	if (then === void 0 || then.hash !== cp.head.hash) {
+		ok = false;
+		lines.push(`row ${cp.head.seq} does not match the checkpoint head (${cp.head.hash.slice(0, 16)}…) — the ledger was rewritten since ${cp.at}`);
+		return {
+			ok,
+			lines
+		};
+	}
+	lines.push(`checkpoint of ${cp.at} holds: ${cp.entries} rows then, ${rows.length} now, head ${cp.head.hash.slice(0, 16)}… intact`);
+	return {
+		ok,
+		lines
+	};
+}
+
+//#endregion
+export { checkCheckpoint, makeCheckpoint };

package/lib/{cli-mahLCjoD.js → cli-7yLG89gV.js}

@@ -1,6 +1,6 @@
 import { t as evaluate } from "./evaluate-wMPkjcIC.js";
-import { a as renderPacks, c as renderNav, d as FRAMEWORKS, f as cite, i as renderOverview, l as renderShell, n as renderApprovals, o as CONTROLS, r as renderCompliance, s as esc, t as navFor, u as VERDICT_LABEL$1 } from "./views-UODslKwu.js";
-import { f as chain, i as fingerprint, l as verifySignature, m as seal, n as readEntries, r as verifyEntries, t as Ledger, u as GENESIS } from "./src-Ciggx9ja.js";
+import { a as renderPacks, c as renderNav, d as FRAMEWORKS, f as cite, i as renderOverview, l as renderShell, n as renderApprovals, o as CONTROLS, r as renderCompliance, s as esc, t as navFor, u as VERDICT_LABEL$1 } from "./views-CIg2ZNG0.js";
+import { _ as seal, f as verifySignature, h as chain, n as readEntries, p as GENESIS, r as verifyEntries, s as fingerprint, t as Ledger } from "./src-D7g4lvaY.js";
 import { existsSync, readFileSync, readdirSync, statSync, watch } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
@@ -972,7 +972,6 @@ function verifyRecord(record, tamper, repair = false) {
 		signatures
 	};
 }
-const OWASP = "owasp-llm-top-10-2026";
 /**
 * Evidence toward each control, from the pack and the ledger as they are
 * now — the rows the controls package defines, so the console, the exporter and
@@ -1001,15 +1000,18 @@ function complianceOf(record) {
 		verification: verifyEntries(text),
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	const owasp = FRAMEWORKS[OWASP]?.controls ?? {};
 	return { controls: CONTROLS.map((control) => {
-		const code = /LLM\d\d/.exec(control.id)?.[0];
-		const named = code === void 0 ? void 0 : owasp[code];
+		const found = Object.entries(FRAMEWORKS).find(([, f]) => control.id.startsWith(`${f.short} · `));
+		const code = found === void 0 ? void 0 : control.id.split(" · ")[1];
+		const named = found === void 0 || code === void 0 ? void 0 : found[1].controls[code];
+		const standard = control.standard;
+		const name = named?.name ?? control.name;
 		return {
-			id: code ?? control.id,
-			...named === void 0 ? {} : { name: named.name },
+			id: code ?? (standard === void 0 ? control.id : control.id.split(" · ")[1] ?? control.id),
+			...name === void 0 ? {} : { name },
 			asks: control.asks,
-			framework: named === void 0 ? "obligation" : OWASP,
+			framework: found?.[0] ?? standard?.id ?? "obligation",
+			...found === void 0 ? standard === void 0 ? {} : { frameworkName: standard.name } : { frameworkName: found[1].name },
 			...control.evidence(data)
 		};
 	}) };
@@ -1187,14 +1189,42 @@ const USAGE = `⌜▪⌟ prae — operator policy for agent harnesses
       the exit code is non-zero if any invariant no longer holds, so a
       control pack can be defended in CI. --pack overrides the suite's own.
 
-  prae verify <ledger.jsonl> [--key <public.pem>]
+  prae verify <ledger.jsonl> [--key <public.pem>] [--checkpoint <file>]
       Re-derive every hash in a decision log and report any break. With
-      --key, also verify each row's signature against that pinned key.
+      --key, also verify each row's signature against that pinned key. With
+      --checkpoint, also check that nothing before that checkpoint's head
+      has been removed or rewritten since it was taken.
+
+  prae checkpoint <ledger.jsonl> [--key <private.pem>] [--out <file>]
+      Record the ledger's length and head, signed, to keep somewhere the
+      ledger's machine cannot write. A chain proves no row inside the file
+      was touched; a checkpoint proves the file was not cut at the end.
+
+  prae export <ledger.jsonl> --format ocsf [--out <file>]
+                [--hec <url> --hec-token <token>]
+      The record as OCSF 1.5.0 events (NDJSON) for a SIEM or data lake:
+      refusals, holds and withheld outputs as Detection Findings, allowed
+      calls as API Activity, every event carrying the row's seal. With --hec,
+      post them to a Splunk HTTP Event Collector instead of writing a file.
 
   prae keygen [--out <dir>]
       Generate an Ed25519 keypair for signing ledger rows. Prints the
       fingerprint a counterparty pins.
 
+  prae keygen --role operator|policy|ledger [--out <dir>]
+      A keypair whose private half is sealed under a passphrase (asked for
+      without echo, or PRAE_KEY_PASSPHRASE). The operator key signs answers
+      to held calls; the policy key signs packs. Pin the public half in the
+      gate (operator.publicKey / policyKey); the agent can read the sealed
+      file and still cannot sign. The ledger key is for the signer that
+      holds it on the harness's behalf (signerFd): prae-signing.*.
+
+  prae sign-pack <pack.json> --key <policy.key.sealed.pem>
+      Sign a pack's exact bytes with the sealed policy key (passphrase asked
+      without echo, or PRAE_KEY_PASSPHRASE), writing <pack.json>.sig. A gate
+      with policyKey pinned governs only by a signed pack whose version
+      rises; raise the version before signing.
+
   prae receipt <ledger.jsonl> <seq> --key <private.pem> [--out <file>]
       Export one decision as a self-contained signed receipt.
 
@@ -1270,7 +1300,7 @@ async function check(path) {
 * from the findings, so there is nothing here to be careful about printing.
 */
 async function scanFile(path, packPath, json) {
-	const { scan } = await import("./src-Vnr0fcpK.js");
+	const { scan } = await import("./src-CwBEFhww.js");
 	let content;
 	try {
 		content = await readFile(path, "utf8");
@@ -1310,13 +1340,13 @@ async function scanFile(path, packPath, json) {
 * not come up inspecting nothing.
 */
 async function mcp(root, packPath, ledgerPath) {
-	const { serveMcp } = await import("./mcp-DDcejhwQ.js");
+	const { serveMcp } = await import("./mcp-doNYU-1C.js");
 	const { resolve: resolve$1 } = await import("node:path");
 	const bundled = [join(import.meta.dirname, "secret-catcher.prae.json"), join(import.meta.dirname, "..", "..", "..", "examples", "secret-catcher.prae.json")].find((candidate) => existsSync(candidate));
 	const chosen = packPath ?? bundled;
 	if (chosen === void 0) return fail("mcp needs --pack <file>; no bundled secret-catcher found");
 	const pack = await loadPack(chosen);
-	const { Ledger: Ledger$1 } = await import("./src-C9L6NBvu.js");
+	const { Ledger: Ledger$1 } = await import("./src-d82lSKVQ.js");
 	const ledger = ledgerPath === void 0 ? void 0 : Ledger$1.open(ledgerPath);
 	console.error(`prae mcp: serving ${resolve$1(root)} under ${pack.pack} ${pack.version}` + (ledgerPath === void 0 ? " (no ledger)" : ` · ledger ${ledgerPath}`));
 	await serveMcp({
@@ -1368,7 +1398,7 @@ async function explain(path, tool, pairs) {
 * a key that arrived beside it is checked against nothing.
 */
 async function keygen(dir) {
-	const { generateKeypair, fingerprint: fingerprint$1 } = await import("./src-C9L6NBvu.js");
+	const { generateKeypair, fingerprint: fingerprint$1 } = await import("./src-d82lSKVQ.js");
 	const { writeFileSync: writeFileSync$1 } = await import("node:fs");
 	const keys = generateKeypair();
 	const priv = join(dir, "prae-signing.pem");
@@ -1383,8 +1413,73 @@ async function keygen(dir) {
 	console.log("receipts, through a channel they trust. Point the plugin at the");
 	console.log("private key with `signingKey` to sign every row.");
 }
+/**
+* A sealed keypair for a human authority (PRA-106/107): written as
+* `<role>.pub.pem` and `<role>.key.sealed.pem`. The passphrase is never an
+* argument — arguments land in process listings and shell history.
+*/
+async function keygenSealed(role, dir) {
+	if (role !== "operator" && role !== "policy" && role !== "ledger") fail("--role is operator, policy or ledger");
+	const stem = role === "ledger" ? "prae-signing" : role;
+	const { sealedKeypair, fingerprint: fingerprint$1 } = await import("./src-d82lSKVQ.js");
+	const { writeFileSync: writeFileSync$1 } = await import("node:fs");
+	const keys = sealedKeypair(process.env.PRAE_KEY_PASSPHRASE ?? await askHidden("passphrase: "));
+	const pub = join(dir, `${stem}.pub.pem`);
+	const sealed = join(dir, `${stem}.key.sealed.pem`);
+	writeFileSync$1(sealed, keys.sealedPrivateKey, { mode: 384 });
+	writeFileSync$1(pub, keys.publicKey);
+	console.log(`sealed      ${sealed}  (useless without the passphrase)`);
+	console.log(`public      ${pub}`);
+	console.log(`fingerprint ${fingerprint$1(keys.publicKey)}`);
+}
+/** A detached signature over a pack's bytes (PRA-107). */
+async function signPack(packPath, keyPath) {
+	const { signBytes, unsealPrivateKey, fingerprint: fingerprint$1 } = await import("./src-d82lSKVQ.js");
+	const { createPublicKey } = await import("node:crypto");
+	const bytes = readFileSync(packPath);
+	const parsed = parsePack(bytes.toString("utf8"));
+	if (!parsed.ok) fail(`${packPath} does not parse; nothing signed`);
+	const passphrase = process.env.PRAE_KEY_PASSPHRASE ?? await askHidden("passphrase: ");
+	let key;
+	try {
+		key = unsealPrivateKey(readFileSync(keyPath, "utf8"), passphrase);
+	} catch {
+		fail("wrong passphrase, or not a sealed key");
+	}
+	await writeFile(`${packPath}.sig`, `${signBytes(bytes, key)}\n`);
+	const pub = createPublicKey(key).export({
+		type: "spki",
+		format: "pem"
+	});
+	console.log(`signed      ${packPath}.sig  (${parsed.pack.pack} ${parsed.pack.version})`);
+	console.log(`policy key  ${fingerprint$1(pub.toString())}`);
+}
+/** Read a line from the terminal without echoing it. */
+function askHidden(prompt) {
+	const input = process.stdin;
+	if (!input.isTTY) fail("no terminal to ask on: set PRAE_KEY_PASSPHRASE");
+	process.stdout.write(prompt);
+	input.setRawMode(true);
+	input.resume();
+	input.setEncoding("utf8");
+	return new Promise((done) => {
+		let typed = "";
+		const onData = (ch) => {
+			if (ch === "\r" || ch === "\n") {
+				input.setRawMode(false);
+				input.pause();
+				input.off("data", onData);
+				process.stdout.write("\n");
+				done(typed);
+			} else if (ch === "") process.exit(130);
+			else if (ch === "") typed = typed.slice(0, -1);
+			else typed += ch;
+		};
+		input.on("data", onData);
+	});
+}
 async function receipt(path, seq, keyPath, out) {
-	const { Ledger: Ledger$1, makeReceipt, fingerprint: fingerprint$1 } = await import("./src-C9L6NBvu.js");
+	const { Ledger: Ledger$1, makeReceipt, fingerprint: fingerprint$1 } = await import("./src-d82lSKVQ.js");
 	const { readFileSync: readFileSync$1 } = await import("node:fs");
 	const { createPublicKey } = await import("node:crypto");
 	const privateKey = readFileSync$1(keyPath, "utf8");
@@ -1414,7 +1509,7 @@ async function receipt(path, seq, keyPath, out) {
 * file and sets the exit code, so scripts can branch on it.
 */
 async function verifyReceiptCmd(path) {
-	const { checkReceipt } = await import("./receipt-check-DrDE3Wwi.js");
+	const { checkReceipt } = await import("./receipt-check-CD-W1wXs.js");
 	let parsed;
 	try {
 		parsed = JSON.parse(await readFile(path, "utf8"));
@@ -1445,7 +1540,7 @@ async function test(suitePath, packOverride, asJson) {
 	} catch (error) {
 		return fail(`${suitePath} is not valid JSON: ${error instanceof Error ? error.message : error}`);
 	}
-	const { parseSuite, renderSuite, runSuite } = await import("./test-run-DOaCKD1t.js");
+	const { parseSuite, renderSuite, runSuite } = await import("./test-run-XNIRHKOu.js");
 	const suite = parseSuite(parsed);
 	if (!suite.ok) {
 		console.error(`prae: ${suitePath} is not a valid test suite`);
@@ -1456,7 +1551,7 @@ async function test(suitePath, packOverride, asJson) {
 	if (chosen === void 0) return fail("test needs a pack: set `pack` in the suite or pass --pack");
 	const pack = await loadPack(chosen);
 	const { capabilityForTool } = await import("capmark");
-	const { scan } = await import("./src-Vnr0fcpK.js");
+	const { scan } = await import("./src-CwBEFhww.js");
 	const inspect = pack.rules.some((rule) => rule.when.secrets !== void 0) ? (path) => {
 		try {
 			return scan(readFileSync(path, "utf8"));
@@ -1472,7 +1567,7 @@ async function test(suitePath, packOverride, asJson) {
 	else for (const line of renderSuite(result)) console.log(line);
 	if (!result.ok) process.exit(1);
 }
-async function verify(path, keyPath) {
+async function verify(path, keyPath, checkpointPath) {
 	let ledger;
 	try {
 		ledger = Ledger.open(path);
@@ -1484,8 +1579,15 @@ async function verify(path, keyPath) {
 		const entries = ledger.read();
 		const last = entries.at(-1);
 		console.log(`${result.entries} entries · chain intact${last === void 0 ? "" : ` · seal ${seal(last)}`}`);
+		if (checkpointPath !== void 0) {
+			const { checkCheckpoint } = await import("./checkpoint-BWSuhZ5h.js");
+			const publicKey = keyPath === void 0 ? void 0 : readFileSync(keyPath, "utf8");
+			const verdict = checkCheckpoint(entries, JSON.parse(readFileSync(checkpointPath, "utf8")), publicKey);
+			for (const line of verdict.lines) (verdict.ok ? console.log : console.error)(`checkpoint: ${line}`);
+			if (!verdict.ok) process.exitCode = 1;
+		}
 		if (keyPath !== void 0) {
-			const { verifySignature: verifySignature$1, fingerprint: fingerprint$1 } = await import("./src-C9L6NBvu.js");
+			const { verifySignature: verifySignature$1, fingerprint: fingerprint$1 } = await import("./src-d82lSKVQ.js");
 			const { readFileSync: readFileSync$1 } = await import("node:fs");
 			const publicKey = readFileSync$1(keyPath, "utf8");
 			let signed = 0;
@@ -1563,7 +1665,7 @@ async function report(path, out, packPath) {
 * that step is a proposal a human approves, and it starts from this list.
 */
 async function instructions(from, asJson) {
-	const { ingest } = await import("./src-CraUX64d.js");
+	const { ingest } = await import("./src-d4c_n6wd.js");
 	const result = ingest(from);
 	if (asJson) {
 		console.log(JSON.stringify(result, null, 2));
@@ -1599,7 +1701,7 @@ async function instructions(from, asJson) {
 * on purpose rather than something that happened to their policy.
 */
 async function propose(from, options) {
-	const [{ ingest }, { extract }] = await Promise.all([import("./src-CraUX64d.js"), import("./src-CQ0UmFUK.js")]);
+	const [{ ingest }, { extract }] = await Promise.all([import("./src-d4c_n6wd.js"), import("./src-CBGZVvt7.js")]);
 	const read = ingest(from);
 	if (read.files.length === 0) {
 		console.log(`No instruction files found at or above ${from}.`);
@@ -1659,9 +1761,9 @@ async function consoleOut(path, argv) {
 	const instructionsDir = flag(argv, "instructions");
 	if (instructionsDir !== void 0) {
 		const [{ ingest }, { extract }, { renderInstructions }] = await Promise.all([
-			import("./src-CraUX64d.js"),
-			import("./src-CQ0UmFUK.js"),
-			import("./instructions-C104EUaE.js")
+			import("./src-d4c_n6wd.js"),
+			import("./src-CBGZVvt7.js"),
+			import("./instructions-Bg5puOen.js")
 		]);
 		const read = ingest(instructionsDir);
 		instructionsView = renderInstructions(data, read, extract(read.statements));
@@ -1759,6 +1861,60 @@ async function init(argv) {
 		return fail(error instanceof Error ? error.message : String(error));
 	}
 }
+async function checkpoint(path, keyPath, out) {
+	const { makeCheckpoint } = await import("./checkpoint-BWSuhZ5h.js");
+	let ledger;
+	try {
+		ledger = Ledger.open(path);
+	} catch (error) {
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	const chain$1 = ledger.verify();
+	if (!chain$1.ok) return fail(`chain broken at line ${chain$1.problems[0]?.line}: ${chain$1.problems[0]?.message} — a checkpoint of a broken chain would certify the break`);
+	const privateKey = keyPath === void 0 ? void 0 : readFileSync(keyPath, "utf8");
+	const cp = makeCheckpoint(ledger.read(), path.split("/").at(-1) ?? path, privateKey);
+	const text = `${JSON.stringify(cp, null, 2)}\n`;
+	if (out === void 0) console.log(text);
+	else {
+		await mkdir(dirname(out), { recursive: true });
+		await writeFile(out, text);
+		console.log(`checkpoint ${out} · ${cp.entries} rows · head ${cp.head.hash.slice(0, 16)}…${cp.sig === void 0 ? " · unsigned" : ` · signed ${cp.fingerprint}`}`);
+		console.log("Keep it where this machine cannot write. `prae verify --checkpoint` later detects rows removed or rewritten since.");
+	}
+}
+async function exportLedger(path, options) {
+	const { toOcsf, ndjson, sendToHec } = await import("./ocsf-DhVGbBUw.js");
+	const { createRequire } = await import("node:module");
+	const { version } = createRequire(import.meta.url)("../package.json");
+	let ledger;
+	try {
+		ledger = Ledger.open(path);
+	} catch (error) {
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	const events = toOcsf(ledger.read(), {
+		product: {
+			name: "prae-gate",
+			version
+		},
+		ledger: path
+	});
+	if (options.hec !== void 0) {
+		if (options.token === void 0) fail("--hec needs --hec-token");
+		const sent = await sendToHec(events, options.hec, options.token);
+		if (sent.status < 200 || sent.status >= 300) return fail(`HEC answered ${sent.status}: ${sent.body.slice(0, 200)}`);
+		console.log(`${sent.sent} events → ${options.hec} (${sent.status})`);
+		return;
+	}
+	const text = ndjson(events);
+	if (options.out === void 0) {
+		process.stdout.write(text);
+		return;
+	}
+	await mkdir(dirname(options.out), { recursive: true });
+	await writeFile(options.out, text);
+	console.log(`${events.length} OCSF events → ${options.out} · seals carried under unmapped; the signature covers the ledger row, not the event`);
+}
 async function main(argv) {
 	const [command, ...rest] = argv;
 	switch (command) {
@@ -1782,7 +1938,17 @@ async function main(argv) {
 			if (root === void 0) fail("mcp needs --root <dir>; serving without a boundary is not a gate");
 			return mcp(root, flag(rest, "pack"), flag(rest, "ledger"));
 		}
-		case "keygen": return keygen(flag(rest, "out") ?? ".");
+		case "keygen": {
+			const role = flag(rest, "role");
+			if (role !== void 0) return keygenSealed(role, flag(rest, "out") ?? ".");
+			return keygen(flag(rest, "out") ?? ".");
+		}
+		case "sign-pack": {
+			const [path] = rest;
+			const key = flag(rest, "key");
+			if (path === void 0 || key === void 0) fail("sign-pack needs <pack.json> --key <policy.key.sealed.pem>");
+			return signPack(path, key);
+		}
 		case "receipt": {
 			const [path, seq] = rest;
 			const key = flag(rest, "key");
@@ -1798,7 +1964,23 @@ async function main(argv) {
 		case "verify": {
 			const path = rest[0];
 			if (path === void 0) fail("verify needs a ledger file");
-			return verify(path, flag(rest, "key"));
+			return verify(path, flag(rest, "key"), flag(rest, "checkpoint"));
+		}
+		case "checkpoint": {
+			const path = rest[0];
+			if (path === void 0) fail("checkpoint needs a ledger file");
+			return checkpoint(path, flag(rest, "key"), flag(rest, "out"));
+		}
+		case "export": {
+			const path = rest[0];
+			if (path === void 0) fail("export needs a ledger file");
+			const format = flag(rest, "format") ?? "ocsf";
+			if (format !== "ocsf") fail(`unknown format ${format}; only ocsf today`);
+			return exportLedger(path, {
+				out: flag(rest, "out"),
+				hec: flag(rest, "hec"),
+				token: flag(rest, "hec-token")
+			});
 		}
 		case "verify-receipt": {
 			const path = rest[0];

package/lib/index.js

@@ -1,6 +1,6 @@
 import "./evaluate-wMPkjcIC.js";
-import "./views-UODslKwu.js";
-import { a as planWrite, i as dshHome, n as applyWrite, o as praeRow, r as defaultProfile, s as profileAt, t as main } from "./cli-mahLCjoD.js";
-import "./src-Ciggx9ja.js";
+import "./views-CIg2ZNG0.js";
+import { a as planWrite, i as dshHome, n as applyWrite, o as praeRow, r as defaultProfile, s as profileAt, t as main } from "./cli-7yLG89gV.js";
+import "./src-D7g4lvaY.js";
 
 export { applyWrite, defaultProfile, dshHome, main, planWrite, praeRow, profileAt };

package/lib/{instructions-C104EUaE.js → instructions-Bg5puOen.js}

@@ -1,4 +1,4 @@
-import { c as renderNav, l as renderShell, s as esc, t as navFor } from "./views-UODslKwu.js";
+import { c as renderNav, l as renderShell, s as esc, t as navFor } from "./views-CIg2ZNG0.js";
 
 //#region src/console/instructions.ts
 const STYLE = `

package/lib/{mcp-DDcejhwQ.js → mcp-doNYU-1C.js}

@@ -1,5 +1,5 @@
 import { t as evaluate } from "./evaluate-wMPkjcIC.js";
-import { a as scan, n as MAX_SCAN_BYTES } from "./src-Br1tGPtS.js";
+import { a as scan, n as MAX_SCAN_BYTES } from "./src-B25SHWcz.js";
 import { readFile, readdir, stat } from "node:fs/promises";
 import { resolve, sep } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";