prae-cli 0.2.0 → 0.3.0

package/lib/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { t as main } from "./cli-6hDu8-nF.js";
-import "./views-BU0sOciR.js";
+import { t as main } from "./cli-DZ0FPdSr.js";
+import "./src-DGWTvmRZ.js";
+import "./views-CLLfJPWB.js";
 
 //#region src/bin.ts
 main(process.argv.slice(2)).catch((error) => {

package/lib/{cli-6hDu8-nF.js → cli-DZ0FPdSr.js}

@@ -1,8 +1,8 @@
-import { a as renderPacks, c as renderShell, i as renderOverview, l as VERDICT_LABEL$1, n as renderApprovals, o as esc, r as renderCompliance, s as renderNav, t as navFor } from "./views-BU0sOciR.js";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { p as seal, t as Ledger } from "./src-DGWTvmRZ.js";
+import { a as renderPacks, c as renderShell, i as renderOverview, l as VERDICT_LABEL$1, n as renderApprovals, o as esc, r as renderCompliance, s as renderNav, t as navFor } from "./views-CLLfJPWB.js";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, extname, join, normalize, resolve, sep } from "node:path";
-import { createHash } from "node:crypto";
+import { extname, join, normalize, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { composePatchFile, preflightOps, revisionOf, takeSnapshot } from "dsh-overlay-check";
 import { createServer } from "node:http";
@@ -774,165 +774,6 @@ function parsePack(source) {
 	};
 }
 
-//#endregion
-//#region ../ledger/src/entry.ts
-/** The hash a chain starts from. */
-const GENESIS = "0".repeat(64);
-/**
-* Deterministic serialization: object keys sorted at every depth.
-*
-* A hash over `JSON.stringify(entry)` would depend on key insertion order,
-* which means a re-serialized entry could hash differently while saying
-* exactly the same thing — and a verifier that reports tampering on a
-* faithful copy trains its operators to ignore it.
-*/
-function canonical(value) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
-}
-/** Hash one entry's content together with its position and predecessor. */
-function hashEntry(record, seq, prev) {
-	return createHash("sha256").update(canonical({
-		...record,
-		seq,
-		prev
-	})).digest("hex");
-}
-/** Chain a record onto a predecessor. */
-function chain(record, seq, prev) {
-	return {
-		...record,
-		seq,
-		prev,
-		hash: hashEntry(record, seq, prev)
-	};
-}
-/** The short form an auditor quotes from a screenshot. */
-function seal(entry) {
-	return `${entry.hash.slice(0, 4)}…${entry.hash.slice(-4)}`;
-}
-
-//#endregion
-//#region ../ledger/src/ledger.ts
-/**
-* Read a ledger held as text.
-*
-* Split out from the class because a ledger is not always a file being
-* appended to: a build step renders one it imported, and a reader pastes one
-* in. Those callers need the same parsing and the same verification the CLI
-* runs, and a second implementation of either is how two answers to "does this
-* chain hold" come to exist.
-*/
-function readEntries(text) {
-	return text.split("\n").filter((line) => line.trim() !== "").map((line) => JSON.parse(line));
-}
-/** Re-derive every hash and confirm each entry names its predecessor. */
-function verifyEntries(text) {
-	const problems = [];
-	let expectedPrev = GENESIS;
-	let expectedSeq = 0;
-	let count = 0;
-	const lines = text.split("\n").filter((line) => line.trim() !== "");
-	for (const [index, line] of lines.entries()) {
-		const at = index + 1;
-		count += 1;
-		let entry;
-		try {
-			entry = JSON.parse(line);
-		} catch {
-			problems.push({
-				line: at,
-				message: "not valid JSON"
-			});
-			return {
-				ok: false,
-				entries: count,
-				problems
-			};
-		}
-		if (entry.seq !== expectedSeq) problems.push({
-			line: at,
-			message: `expected seq ${expectedSeq}, found ${entry.seq}`
-		});
-		if (entry.prev !== expectedPrev) problems.push({
-			line: at,
-			message: "does not name the previous entry; a row was removed or reordered"
-		});
-		const { seq, prev, hash,...record } = entry;
-		if (hashEntry(record, seq, prev) !== hash) problems.push({
-			line: at,
-			message: "contents do not match the sealed hash"
-		});
-		expectedPrev = entry.hash;
-		expectedSeq = entry.seq + 1;
-	}
-	return {
-		ok: problems.length === 0,
-		entries: count,
-		problems
-	};
-}
-var Ledger = class Ledger {
-	path;
-	seq;
-	last;
-	constructor(path, seq, last) {
-		this.path = path;
-		this.seq = seq;
-		this.last = last;
-	}
-	/**
-	* Open a ledger, reading the tail to continue an existing chain.
-	*
-	* A corrupt or truncated final line is a hard error rather than something to
-	* skip past: appending onto a chain whose end we could not read would bury
-	* the damage under valid-looking entries.
-	*/
-	static open(path) {
-		mkdirSync(dirname(path), { recursive: true });
-		let text = "";
-		try {
-			text = readFileSync(path, "utf8");
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-			writeFileSync(path, "", { flag: "wx" });
-			return new Ledger(path, 0, GENESIS);
-		}
-		const tail = text.split("\n").filter((line) => line.trim() !== "").at(-1);
-		if (tail === void 0) return new Ledger(path, 0, GENESIS);
-		let entry;
-		try {
-			entry = JSON.parse(tail);
-		} catch {
-			throw new Error(`prae ledger: last line of ${path} is not readable; refusing to append onto a chain that cannot be continued`);
-		}
-		return new Ledger(path, entry.seq + 1, entry.hash);
-	}
-	/** Append one decision and return the entry as written. */
-	append(record) {
-		const entry = chain(record, this.seq, this.last);
-		appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
-		this.seq += 1;
-		this.last = entry.hash;
-		return entry;
-	}
-	/** Every entry, in order. */
-	read() {
-		return readEntries(readFileSync(this.path, "utf8"));
-	}
-	/**
-	* Re-derive every hash and confirm each entry names its predecessor.
-	*
-	* Catches a deleted row, an edited field, and a reordering. Does not catch a
-	* wholesale rewrite of the file by someone holding the same code — see the
-	* note in `entry.ts`.
-	*/
-	verify() {
-		return verifyEntries(readFileSync(this.path, "utf8"));
-	}
-};
-
 //#endregion
 //#region src/console/ledger.ts
 function ago(iso, now) {
@@ -1381,8 +1222,16 @@ const USAGE = `prae — operator policy for agent harnesses
   prae explain <pack.json> <tool> [key=value ...]
       Judge one call against the pack and print the trace. Nothing is executed.
 
-  prae verify <ledger.jsonl>
-      Re-derive every hash in a decision log and report any break.
+  prae verify <ledger.jsonl> [--key <public.pem>]
+      Re-derive every hash in a decision log and report any break. With
+      --key, also verify each row's signature against that pinned key.
+
+  prae keygen [--out <dir>]
+      Generate an Ed25519 keypair for signing ledger rows. Prints the
+      fingerprint a counterparty pins.
+
+  prae receipt <ledger.jsonl> <seq> --key <private.pem> [--out <file>]
+      Export one decision as a self-contained signed receipt.
 
   prae report <ledger.jsonl> [--out <file.html>]
       Render the decision record as a printable evidence report.
@@ -1472,7 +1321,52 @@ async function explain(path, tool, pairs) {
 	console.log(`\n${pack.pack} ${pack.version} · ${decision.evaluated} rules considered`);
 	if (capability === void 0) console.log(`\nnote: no capability claims \`${tool}\`, so capability rules did not apply`);
 }
-async function verify(path) {
+/**
+* Keys for signing rows.
+*
+* Written 0600 and never printed. What is printed is the fingerprint — the
+* thing a counterparty pins out-of-band, because a signature checked against
+* a key that arrived beside it is checked against nothing.
+*/
+async function keygen(dir) {
+	const { generateKeypair, fingerprint } = await import("./src-Cinsv7Wq.js");
+	const { writeFileSync: writeFileSync$1 } = await import("node:fs");
+	const keys = generateKeypair();
+	const priv = join(dir, "prae-signing.pem");
+	const pub = join(dir, "prae-signing.pub.pem");
+	writeFileSync$1(priv, keys.privateKey, { mode: 384 });
+	writeFileSync$1(pub, keys.publicKey);
+	console.log(`private     ${priv}  (0600 — this signs; guard it)`);
+	console.log(`public      ${pub}`);
+	console.log(`fingerprint ${fingerprint(keys.publicKey)}`);
+	console.log("");
+	console.log("Give the PUBLIC key and fingerprint to whoever will verify");
+	console.log("receipts, through a channel they trust. Point the plugin at the");
+	console.log("private key with `signingKey` to sign every row.");
+}
+async function receipt(path, seq, keyPath, out) {
+	const { Ledger: Ledger$1, makeReceipt, fingerprint } = await import("./src-Cinsv7Wq.js");
+	const { readFileSync: readFileSync$1 } = await import("node:fs");
+	const { createPublicKey } = await import("node:crypto");
+	const privateKey = readFileSync$1(keyPath, "utf8");
+	const publicKey = createPublicKey(privateKey).export({
+		type: "spki",
+		format: "pem"
+	}).toString();
+	const entry = Ledger$1.open(path).read().find((row$1) => row$1.seq === seq);
+	if (entry === void 0) return fail(`no row with seq ${seq} in ${path}`);
+	const packaged = makeReceipt(entry, privateKey, publicKey);
+	const text = `${JSON.stringify(packaged, null, 2)}\n`;
+	if (out === void 0) console.log(text);
+	else {
+		await writeFile(out, text);
+		console.log(`${out} · seq ${seq} · ${entry.verdict} ${entry.tool} ${entry.subject ?? ""}`);
+	}
+	console.log(`fingerprint ${fingerprint(publicKey)}`);
+	console.log("The verifier compares that fingerprint against the one they");
+	console.log("pinned — a receipt is only as good as the key they trust.");
+}
+async function verify(path, keyPath) {
 	let ledger;
 	try {
 		ledger = Ledger.open(path);
@@ -1481,8 +1375,26 @@ async function verify(path) {
 	}
 	const result = ledger.verify();
 	if (result.ok) {
-		const last = ledger.read().at(-1);
+		const entries = ledger.read();
+		const last = entries.at(-1);
 		console.log(`${result.entries} entries · chain intact${last === void 0 ? "" : ` · seal ${seal(last)}`}`);
+		if (keyPath !== void 0) {
+			const { verifySignature, fingerprint } = await import("./src-Cinsv7Wq.js");
+			const { readFileSync: readFileSync$1 } = await import("node:fs");
+			const publicKey = readFileSync$1(keyPath, "utf8");
+			let signed = 0;
+			const bad = [];
+			for (const entry of entries) {
+				if (entry.sig === void 0) continue;
+				signed += 1;
+				if (!verifySignature(entry, entry.sig, publicKey)) bad.push(entry.seq);
+			}
+			if (bad.length > 0) {
+				console.error(`signatures: ${bad.length} of ${signed} FAIL against ${fingerprint(publicKey)} — rows ${bad.join(", ")}`);
+				process.exitCode = 1;
+			} else if (signed === 0) console.log("signatures: none present — this ledger is not signed");
+			else console.log(`signatures: ${signed}/${entries.length} rows verify against ${fingerprint(publicKey)}`);
+		}
 		console.log("tamper-evident: a removed, edited, or reordered row breaks this chain.");
 		console.log("It does not prove against a rewrite of the whole file by someone holding this code.");
 		return;
@@ -1543,7 +1455,7 @@ async function report(path, out) {
 * that step is a proposal a human approves, and it starts from this list.
 */
 async function instructions(from, asJson) {
-	const { ingest } = await import("./src-BrZXeEez.js");
+	const { ingest } = await import("./src-2pGbYeGU.js");
 	const result = ingest(from);
 	if (asJson) {
 		console.log(JSON.stringify(result, null, 2));
@@ -1579,7 +1491,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-BrZXeEez.js"), import("./src-Dd2_8m2g.js")]);
+	const [{ ingest }, { extract }] = await Promise.all([import("./src-2pGbYeGU.js"), import("./src-CuHszf3f.js")]);
 	const read = ingest(from);
 	if (read.files.length === 0) {
 		console.log(`No instruction files found at or above ${from}.`);
@@ -1639,9 +1551,9 @@ async function consoleOut(path, argv) {
 	const instructionsDir = flag(argv, "instructions");
 	if (instructionsDir !== void 0) {
 		const [{ ingest }, { extract }, { renderInstructions }] = await Promise.all([
-			import("./src-BrZXeEez.js"),
-			import("./src-Dd2_8m2g.js"),
-			import("./instructions-ijuj4IP1.js")
+			import("./src-2pGbYeGU.js"),
+			import("./src-CuHszf3f.js"),
+			import("./instructions-C6jwClPO.js")
 		]);
 		const read = ingest(instructionsDir);
 		instructionsView = renderInstructions(data, read, extract(read.statements));
@@ -1740,10 +1652,17 @@ async function main(argv) {
 			if (path === void 0 || tool === void 0) fail("explain needs a pack file and a tool name");
 			return explain(path, tool, pairs);
 		}
+		case "keygen": return keygen(flag(rest, "out") ?? ".");
+		case "receipt": {
+			const [path, seq] = rest;
+			const key = flag(rest, "key");
+			if (path === void 0 || seq === void 0 || key === void 0) fail("receipt needs <ledger.jsonl> <seq> --key <private.pem>");
+			return receipt(path, Number(seq), key, flag(rest, "out"));
+		}
 		case "verify": {
 			const path = rest[0];
 			if (path === void 0) fail("verify needs a ledger file");
-			return verify(path);
+			return verify(path, flag(rest, "key"));
 		}
 		case "report": {
 			const path = rest[0];

package/lib/index.js

@@ -1,4 +1,5 @@
-import { a as planWrite, i as dshHome, n as applyWrite, o as praeRow, r as defaultProfile, s as profileAt, t as main } from "./cli-6hDu8-nF.js";
-import "./views-BU0sOciR.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-DZ0FPdSr.js";
+import "./src-DGWTvmRZ.js";
+import "./views-CLLfJPWB.js";
 
 export { applyWrite, defaultProfile, dshHome, main, planWrite, praeRow, profileAt };

package/lib/{instructions-ijuj4IP1.js → instructions-C6jwClPO.js}

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

package/lib/src-Cinsv7Wq.js

@@ -0,0 +1,3 @@
+import { a as generateKeypair, c as verifySignature, d as chain, f as hashEntry, i as fingerprint, l as GENESIS, n as readEntries, o as makeReceipt, p as seal, r as verifyEntries, s as signEntry, t as Ledger, u as canonical } from "./src-DGWTvmRZ.js";
+
+export { GENESIS, Ledger, canonical, chain, fingerprint, generateKeypair, hashEntry, makeReceipt, readEntries, seal, signEntry, verifyEntries, verifySignature };

package/lib/src-DGWTvmRZ.js

@@ -0,0 +1,225 @@
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+
+//#region ../ledger/src/entry.ts
+/** The hash a chain starts from. */
+const GENESIS = "0".repeat(64);
+/**
+* Deterministic serialization: object keys sorted at every depth.
+*
+* A hash over `JSON.stringify(entry)` would depend on key insertion order,
+* which means a re-serialized entry could hash differently while saying
+* exactly the same thing — and a verifier that reports tampering on a
+* faithful copy trains its operators to ignore it.
+*/
+function canonical(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+}
+/** Hash one entry's content together with its position and predecessor. */
+function hashEntry(record, seq, prev) {
+	return createHash("sha256").update(canonical({
+		...record,
+		seq,
+		prev
+	})).digest("hex");
+}
+/** Chain a record onto a predecessor. */
+function chain(record, seq, prev) {
+	return {
+		...record,
+		seq,
+		prev,
+		hash: hashEntry(record, seq, prev)
+	};
+}
+/** The short form an auditor quotes from a screenshot. */
+function seal(entry) {
+	return `${entry.hash.slice(0, 4)}…${entry.hash.slice(-4)}`;
+}
+
+//#endregion
+//#region ../ledger/src/receipt.ts
+function generateKeypair() {
+	const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+	return {
+		publicKey: publicKey.export({
+			type: "spki",
+			format: "pem"
+		}).toString(),
+		privateKey: privateKey.export({
+			type: "pkcs8",
+			format: "pem"
+		}).toString()
+	};
+}
+/** Sign a row's seal. The seal already covers the whole canonical record. */
+function signEntry(entry, privateKeyPem) {
+	const key = createPrivateKey(privateKeyPem);
+	return sign(null, Buffer.from(entry.hash, "hex"), key).toString("base64");
+}
+function verifySignature(entry, signature, publicKeyPem) {
+	try {
+		const key = createPublicKey(publicKeyPem);
+		return verify(null, Buffer.from(entry.hash, "hex"), key, Buffer.from(signature, "base64"));
+	} catch {
+		return false;
+	}
+}
+function makeReceipt(entry, privateKeyPem, publicKeyPem) {
+	return {
+		receipt: "prae/1",
+		entry,
+		signature: signEntry(entry, privateKeyPem),
+		publicKey: publicKeyPem
+	};
+}
+/**
+* A short identifier for a public key, for pinning by eye.
+*
+* A counterparty checks a receipt against a key they already trust; comparing
+* the whole PEM by hand invites skimming, and eight grouped hex bytes do not.
+*/
+function fingerprint(publicKeyPem) {
+	const der = createPublicKey(publicKeyPem).export({
+		type: "spki",
+		format: "der"
+	});
+	return createHash("sha256").update(der).digest("hex").slice(0, 16).replace(/(.{4})/g, "$1 ").trim();
+}
+
+//#endregion
+//#region ../ledger/src/ledger.ts
+/**
+* Read a ledger held as text.
+*
+* Split out from the class because a ledger is not always a file being
+* appended to: a build step renders one it imported, and a reader pastes one
+* in. Those callers need the same parsing and the same verification the CLI
+* runs, and a second implementation of either is how two answers to "does this
+* chain hold" come to exist.
+*/
+function readEntries(text) {
+	return text.split("\n").filter((line) => line.trim() !== "").map((line) => JSON.parse(line));
+}
+/** Re-derive every hash and confirm each entry names its predecessor. */
+function verifyEntries(text) {
+	const problems = [];
+	let expectedPrev = GENESIS;
+	let expectedSeq = 0;
+	let count = 0;
+	const lines = text.split("\n").filter((line) => line.trim() !== "");
+	for (const [index, line] of lines.entries()) {
+		const at = index + 1;
+		count += 1;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			problems.push({
+				line: at,
+				message: "not valid JSON"
+			});
+			return {
+				ok: false,
+				entries: count,
+				problems
+			};
+		}
+		if (entry.seq !== expectedSeq) problems.push({
+			line: at,
+			message: `expected seq ${expectedSeq}, found ${entry.seq}`
+		});
+		if (entry.prev !== expectedPrev) problems.push({
+			line: at,
+			message: "does not name the previous entry; a row was removed or reordered"
+		});
+		const { seq, prev, hash, sig: _sig,...record } = entry;
+		if (hashEntry(record, seq, prev) !== hash) problems.push({
+			line: at,
+			message: "contents do not match the sealed hash"
+		});
+		expectedPrev = entry.hash;
+		expectedSeq = entry.seq + 1;
+	}
+	return {
+		ok: problems.length === 0,
+		entries: count,
+		problems
+	};
+}
+var Ledger = class Ledger {
+	path;
+	seq;
+	last;
+	constructor(path, seq, last) {
+		this.path = path;
+		this.seq = seq;
+		this.last = last;
+	}
+	/**
+	* Open a ledger, reading the tail to continue an existing chain.
+	*
+	* A corrupt or truncated final line is a hard error rather than something to
+	* skip past: appending onto a chain whose end we could not read would bury
+	* the damage under valid-looking entries.
+	*/
+	/** Sign every appended row with this Ed25519 private key (PEM). */
+	signWith;
+	static open(path, options = {}) {
+		const ledger = Ledger.openUnsigned(path);
+		ledger.signWith = options.signWith;
+		return ledger;
+	}
+	static openUnsigned(path) {
+		mkdirSync(dirname(path), { recursive: true });
+		let text = "";
+		try {
+			text = readFileSync(path, "utf8");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			writeFileSync(path, "", { flag: "wx" });
+			return new Ledger(path, 0, GENESIS);
+		}
+		const tail = text.split("\n").filter((line) => line.trim() !== "").at(-1);
+		if (tail === void 0) return new Ledger(path, 0, GENESIS);
+		let entry;
+		try {
+			entry = JSON.parse(tail);
+		} catch {
+			throw new Error(`prae ledger: last line of ${path} is not readable; refusing to append onto a chain that cannot be continued`);
+		}
+		return new Ledger(path, entry.seq + 1, entry.hash);
+	}
+	/** Append one decision and return the entry as written. */
+	append(record) {
+		const sealed = chain(record, this.seq, this.last);
+		const entry = this.signWith === void 0 ? sealed : {
+			...sealed,
+			sig: signEntry(sealed, this.signWith)
+		};
+		appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
+		this.seq += 1;
+		this.last = entry.hash;
+		return entry;
+	}
+	/** Every entry, in order. */
+	read() {
+		return readEntries(readFileSync(this.path, "utf8"));
+	}
+	/**
+	* Re-derive every hash and confirm each entry names its predecessor.
+	*
+	* Catches a deleted row, an edited field, and a reordering. Does not catch a
+	* wholesale rewrite of the file by someone holding the same code — see the
+	* note in `entry.ts`.
+	*/
+	verify() {
+		return verifyEntries(readFileSync(this.path, "utf8"));
+	}
+};
+
+//#endregion
+export { generateKeypair as a, verifySignature as c, chain as d, hashEntry as f, fingerprint as i, GENESIS as l, readEntries as n, makeReceipt as o, seal as p, verifyEntries as r, signEntry as s, Ledger as t, canonical as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prae-cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Operator policy for agent harnesses: validate packs, explain a decision, verify a decision log, and provision a governed DSH profile.",
   "keywords": [
     "dsh-plugin",
@@ -40,11 +40,11 @@
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
     "@prae/controls": "0.1.0",
+    "@prae/extract": "0.1.0",
+    "@prae/instructions": "0.1.0",
     "@prae/kernel": "0.1.0",
     "@prae/ledger": "0.1.0",
-    "@prae/tokens": "0.1.0",
-    "@prae/instructions": "0.1.0",
-    "@prae/extract": "0.1.0"
+    "@prae/tokens": "0.1.0"
   },
   "scripts": {
     "test": "vitest run",