@vimhead.dev/norn-cli 0.1.0-tip.36679386408.1 → 0.1.0-tip.36824462948.1

package/assets/docs/cli.md

@@ -179,6 +179,31 @@ norn runs delete <run>
 
 `stop` signals SIGTERM; `kill` signals SIGKILL. Delete removes an inactive run and its evidence. Neither stopping nor deleting undoes external effects. Resume and rollback are documented in [recovery](recovery.md).
 
+## Prune run storage
+
+```bash
+norn runs prune --dry-run
+norn runs prune
+norn runs prune --older-than 7d
+norn runs prune --delete-runs
+norn runs prune --delete-runs --all --dry-run
+```
+
+Pruning is explicit and scoped to the current project. By default it discards all checkpoint manifests, saved file contents, and checkpoint references for failed or completed runs that finished more than 24 hours ago. Current workspace files, logs, sessions, state, and outcomes remain available. Pruned checkpoint history cannot be rolled back; checkpoint listing returns an empty list.
+
+`--older-than` accepts a non-negative number followed by `ms`, `s`, `m`, `h`, `d`, or `w`; age is measured from completion/failure, not run creation. `--delete-runs` removes eligible run directories and all their evidence instead. It preserves the age filter unless combined with `--all`. `--all` requires `--delete-runs` and cannot be combined with `--older-than`.
+
+Every mode preserves running, stopped, interrupted, pending-resume, and executor-owned runs. Eligibility is checked again under the existing run lease before deletion. `--dry-run` makes no filesystem changes.
+
+The JSON result under `prune` includes `mode`, `dryRun`, effective `olderThan` (`null` with `--all`), and `runs` with identity, status (`planned`, `pruned`, `skipped`, or `failed`), and an optional reason. Per-run failures produce a nonzero exit status; other eligible runs can still be pruned. Repeating checkpoint pruning safely completes an interrupted cleanup.
+
+| Decision                                                                                                                                                  | GOOD                                                            | BAD                                                       |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------- |
+| IF failed runs may need recovery, THEN retain their checkpoints or select an age beyond the repair window. ELSE prune after reviewing the dry-run result. | `runs prune --older-than 7d --dry-run` before deleting history. | Treat checkpoint pruning as reversible.                   |
+| IF entire runs will be deleted, THEN preserve unique outputs elsewhere first. ELSE keep current files with default pruning.                               | Export private commits before `--delete-runs`.                  | Assume completed means outputs were integrated elsewhere. |
+
+The JavaScript client exposes `client.runs.prune({ deleteRuns: false, all: false, olderThan: null, dryRun: true })`; `olderThan: null` uses the CLI default unless `all` is true.
+
 ## JavaScript client and other harnesses
 
 Claude Code, Pi, Codex, and other CLI-capable harnesses can invoke Norn without an

package/assets/docs/recovery.md

@@ -19,6 +19,8 @@ Checkpoints are taken at run start, successful transitions, gate interruptions,
 | `pendingResume`                     | IF retry is intended, THEN resume with no args. ELSE leave the restored boundary untouched.                                                                             | `norn runs resume <run> </dev/null`.                              | Try to override arbitrary saved inputs through resume.                      |
 | `running` with unhealthy inspection | IF the executor is no longer healthy, THEN inspect ownership and reconcile effects before recovery. ELSE monitor active execution.                                      | Check run health and command evidence before retry.               | Start a competing executor or equate stale status with successful delivery. |
 
+[Run pruning](cli.md#prune-run-storage) permanently removes recovery history while retaining current evidence by default. Pruned runs expose no checkpoints; rollback reports that the history was pruned.
+
 ## Source repair and rollback
 
 ```bash
@@ -43,6 +45,8 @@ The [agent example's repair exercise](../examples/agent-then-analysis/README.md#
 
 ## Saved-run compatibility
 
+New checkpoints are compressed; CLI and client calls are unchanged. Existing uncompressed checkpoints remain readable and are not converted automatically. Older runtimes without compressed-checkpoint support cannot restore new checkpoints.
+
 Runs created before the complete-workflow API migration cannot be resumed or rolled back by this alpha. Their saved status remains inspectable, and existing files are preserved. Use the original runtime to continue those runs, or start a new run.
 
 ## Declared gates

package/assets/package.json

@@ -1 +1 @@
-{"version":"0.1.0-tip.36679386408.1"}
+{"version":"0.1.0-tip.36824462948.1"}

package/assets/packages/cli/src/cli.ts

@@ -50,6 +50,7 @@ import {
 import { readRunMetrics } from "./internal/metrics.ts";
 import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.ts";
 import { generateRunName } from "./internal/run-names.ts";
+import { NornRunPruner, parseRunPruneOptions } from "./internal/run-pruning.ts";
 import {
 	assertRunVersion,
 	getRunInfo,
@@ -433,6 +434,40 @@ const COMMANDS: readonly CliCommand[] = [
 			await signalRun(run, "SIGKILL");
 		},
 	},
+	{
+		id: "runs.prune",
+		path: ["runs", "prune"],
+		description:
+			"Discard checkpoint history or entire failed/completed runs, preserving recent and nonterminal runs.",
+		usage:
+			"norn runs prune [--delete-runs] [--older-than <duration>|--all] [--dry-run]",
+		options: [
+			"--delete-runs: delete entire eligible runs instead of only checkpoint storage",
+			"--older-than <duration>: time since completion/failure; default 24h; units ms, s, m, h, d, w",
+			"--all: ignore age; requires --delete-runs; incompatible with --older-than",
+			"--dry-run: report eligible runs without changing files",
+		],
+		output:
+			"JSON object under prune with mode, dryRun, olderThan, and per-run planned/pruned/skipped/failed results. Any failed result sets a nonzero exit status.",
+		examples: [
+			"norn runs prune --dry-run",
+			"norn runs prune --older-than 7d",
+			"norn runs prune --delete-runs --all",
+		],
+		execute: async (args) => {
+			const options = parseRunPruneOptions(args);
+			const project = await findNornProject(process.cwd());
+			const pruner = new NornRunPruner({
+				projectRoot: project.projectRoot,
+				options,
+				now: new Date(),
+			});
+			const result = await pruner.prune();
+			writeJson({ prune: result });
+			if (result.runs.some((run) => run.status === "failed"))
+				process.exitCode = 1;
+		},
+	},
 	{
 		id: "runs.delete",
 		path: ["runs", "delete"],
@@ -515,6 +550,7 @@ const HELP_COMMAND_ORDER = [
 	"runs.stop",
 	"runs.kill",
 	"runs.delete",
+	"runs.prune",
 	"project.init",
 	"project.inspect",
 	"pi",
@@ -545,6 +581,7 @@ const HUMAN_COMMAND_SUMMARIES: Readonly<Record<string, string>> = {
 	"runs.stop": "Stop a running run.",
 	"runs.kill": "Force-stop a running run.",
 	"runs.delete": "Delete an inactive run.",
+	"runs.prune": "Prune checkpoint storage or old failed/completed runs.",
 	"project.init": "Create a Norn project in the current directory.",
 	"project.inspect": "Inspect the Norn project.",
 	pi: "Run bundled Pi for authentication, providers, and model setup.",

package/assets/packages/cli/src/client.ts

@@ -9,6 +9,8 @@ import type {
 	NornWorkflowInspection,
 	NornRunCheckpoint,
 	NornRunInfo,
+	NornRunPruneOptions,
+	NornRunPruneResult,
 	NornRunMetrics,
 } from "@vimhead.dev/norn";
 import { loadNornProject } from "./workflow-loader.ts";
@@ -52,6 +54,7 @@ export type NornClient = {
 		stop(run: string): Promise<NornRunInfo>;
 		kill(run: string): Promise<NornRunInfo>;
 		delete(run: string): Promise<DeletedNornRunInfo>;
+		prune(options: NornRunPruneOptions): Promise<NornRunPruneResult>;
 		logs(
 			run: string,
 			options?: { readonly follow?: boolean },
@@ -169,6 +172,19 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 						run,
 					])
 				).deleted,
+			prune: async (options) =>
+				(
+					await processRunner.readJson<{ prune: NornRunPruneResult }>([
+						"runs",
+						"prune",
+						...(options.deleteRuns ? ["--delete-runs"] : []),
+						...(options.all ? ["--all"] : []),
+						...(options.olderThan === null
+							? []
+							: ["--older-than", options.olderThan]),
+						...(options.dryRun ? ["--dry-run"] : []),
+					])
+				).prune,
 			logs: (run, options) =>
 				processRunner.readJsonLines([
 					"runs",

package/assets/packages/cli/src/generated-build-info.ts

@@ -2,8 +2,8 @@ import type { NornBuildInfo } from "./build-info.ts";
 
 export const NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.36679386408.1",
-  "commit": "3cb3189ec70f3b4407456061207294d685297b69",
+  "version": "0.1.0-tip.36824462948.1",
+  "commit": "c98b6febf7a42abc1201dfdceb1553fc9e91c08c",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/assets/packages/cli/src/internal/run-lease.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, readFile, rename, rm, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import type { NornRunHealth } from "@vimhead.dev/norn";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";
@@ -68,6 +68,28 @@ export class NornRunLease {
 			throw new Error("Run lease was lost");
 	}
 
+	async deleteRunDirectory(): Promise<void> {
+		await this.assertOwned();
+		if (this.heartbeat) clearInterval(this.heartbeat);
+		await this.heartbeatChain;
+		await this.assertOwned();
+		const runRoot = dirname(this.lockRoot);
+		const retiredRoot = join(
+			dirname(dirname(runRoot)),
+			`.pruned-run-${randomUUID()}`,
+		);
+		await rename(runRoot, retiredRoot);
+		this.isReleased = true;
+		try {
+			await rm(retiredRoot, { recursive: true, force: true });
+		} catch (error) {
+			throw new Error(
+				`Run was removed from the run list but directory cleanup failed: ${retiredRoot}`,
+				{ cause: error },
+			);
+		}
+	}
+
 	async release(): Promise<void> {
 		if (this.isReleased) return;
 		this.isReleased = true;

package/assets/packages/cli/src/internal/run-pruning.ts

@@ -0,0 +1,169 @@
+import type {
+	NornRunInfo,
+	NornRunPruneOptions,
+	NornRunPruneResult,
+} from "@vimhead.dev/norn";
+import { errorMessage } from "./errors.ts";
+import { getRunLeaseOwner, NornRunLease } from "./run-lease.ts";
+import { getRunInfo, listRuns } from "./run-state.ts";
+import { NornRunStore } from "./run-store.ts";
+
+const DURATION_UNITS: Readonly<Record<string, number>> = {
+	ms: 1,
+	s: 1000,
+	m: 60_000,
+	h: 3_600_000,
+	d: 86_400_000,
+	w: 604_800_000,
+};
+
+export function parseRunPruneOptions(
+	args: readonly string[],
+): NornRunPruneOptions {
+	const flags = new Set<string>();
+	let olderThan: string | null = null;
+	for (let index = 0; index < args.length; index++) {
+		const flag = args[index];
+		if (!["--delete-runs", "--all", "--dry-run", "--older-than"].includes(flag))
+			throw new Error(`runs prune: unknown argument ${flag}`);
+		if (flags.has(flag))
+			throw new Error(`runs prune: duplicate option ${flag}`);
+		flags.add(flag);
+		if (flag === "--older-than") {
+			const value = args[++index];
+			if (value === undefined || value.startsWith("--"))
+				throw new Error(
+					"runs prune: --older-than requires a duration such as 24h or 7d",
+				);
+			olderThan = value;
+		}
+	}
+	return {
+		deleteRuns: flags.has("--delete-runs"),
+		all: flags.has("--all"),
+		olderThan,
+		dryRun: flags.has("--dry-run"),
+	};
+}
+
+function parsePruneDuration(value: string): number {
+	const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/.exec(value);
+	const duration = match ? Number(match[1]) * DURATION_UNITS[match[2]] : NaN;
+	if (
+		!Number.isFinite(duration) ||
+		duration < 0 ||
+		duration > Number.MAX_SAFE_INTEGER
+	)
+		throw new Error(
+			`runs prune: invalid duration ${value}; use a non-negative number followed by ms, s, m, h, d, or w`,
+		);
+	return duration;
+}
+
+export class NornRunPruner {
+	private readonly olderThan: string | null;
+	private readonly cutoff: number | null;
+
+	constructor(
+		private readonly input: {
+			readonly projectRoot: string;
+			readonly options: NornRunPruneOptions;
+			readonly now: Date;
+		},
+	) {
+		if (input.options.all && !input.options.deleteRuns)
+			throw new Error("runs prune: --all requires --delete-runs");
+		if (input.options.all && input.options.olderThan !== null)
+			throw new Error(
+				"runs prune: --all and --older-than are mutually exclusive",
+			);
+		if (!Number.isFinite(input.now.getTime()))
+			throw new Error("Invalid pruning time");
+		this.olderThan = input.options.all
+			? null
+			: (input.options.olderThan ?? "24h");
+		this.cutoff =
+			this.olderThan === null
+				? null
+				: input.now.getTime() - parsePruneDuration(this.olderThan);
+	}
+
+	async prune(): Promise<NornRunPruneResult> {
+		const results: NornRunPruneResult["runs"][number][] = [];
+		for (const run of await listRuns(this.input.projectRoot)) {
+			const identity = { id: run.id, name: run.name, path: run.path };
+			let lease: NornRunLease | undefined;
+			try {
+				let reason = this.findIneligibilityReason(run);
+				if (!reason && (await getRunLeaseOwner(run.path)))
+					reason = "Run is owned by an executor";
+				if (reason) {
+					results.push({ ...identity, status: "skipped", reason });
+					continue;
+				}
+				if (this.input.options.dryRun) {
+					results.push({ ...identity, status: "planned" });
+					continue;
+				}
+				try {
+					lease = await NornRunLease.acquire(run.path);
+				} catch (error) {
+					if (
+						error instanceof Error &&
+						error.message.startsWith("Run is already active:")
+					) {
+						results.push({
+							...identity,
+							status: "skipped",
+							reason: "Run is owned by an executor",
+						});
+						continue;
+					}
+					throw error;
+				}
+				reason = this.findIneligibilityReason(await getRunInfo(run.path));
+				if (reason) {
+					results.push({ ...identity, status: "skipped", reason });
+					continue;
+				}
+				await lease.assertOwned();
+				if (this.input.options.deleteRuns) {
+					await lease.deleteRunDirectory();
+				} else {
+					const store = await NornRunStore.open(run.path);
+					await store.pruneCheckpointHistory(this.input.now.toISOString());
+				}
+				results.push({ ...identity, status: "pruned" });
+			} catch (error) {
+				results.push({
+					...identity,
+					status: "failed",
+					reason: errorMessage(error),
+				});
+			} finally {
+				await lease?.release();
+			}
+		}
+		return {
+			mode: this.input.options.deleteRuns ? "runs" : "checkpoints",
+			dryRun: this.input.options.dryRun,
+			olderThan: this.olderThan,
+			runs: results,
+		};
+	}
+
+	private findIneligibilityReason(run: NornRunInfo): string | undefined {
+		if (run.status !== "completed" && run.status !== "failed")
+			return `Run status is ${run.status}; only completed or failed runs are eligible`;
+		const finishedAt =
+			run.status === "failed"
+				? (run.failed?.failedAt ?? run.outcome?.completedAt ?? run.updatedAt)
+				: (run.outcome?.completedAt ?? run.updatedAt);
+		const finishedTime = Date.parse(finishedAt);
+		if (!Number.isFinite(finishedTime))
+			return "Run completion/failure time is invalid";
+		if (this.cutoff !== null && finishedTime >= this.cutoff)
+			return `Run finished less than or exactly ${this.olderThan} ago`;
+		return undefined;
+	}
+}

package/assets/packages/cli/src/internal/run-store.ts

@@ -21,6 +21,7 @@ import { gunzip, gzip } from "node:zlib";
 import type { NornRunCheckpoint } from "@vimhead.dev/norn";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import {
+	writeBytesAtomically,
 	writeJsonAtomically,
 	writeTextAtomically,
 } from "@vimhead.dev/norn-core/atomic-files";
@@ -31,6 +32,7 @@ const SNAPSHOT_VERSION = 1;
 const CURRENT_DIR_NAME = "current";
 const STORE_DIR_NAME = "store";
 const CHECKPOINTS_FILE_NAME = "checkpoints.json";
+const PRUNED_HISTORY_FILE_NAME = "checkpoint-history-pruned.json";
 
 export function runCurrentRoot(runRoot: string): string {
 	return join(runRoot, CURRENT_DIR_NAME);
@@ -57,15 +59,18 @@ export class NornRunStore {
 	static async open(root: string): Promise<NornRunStore> {
 		const runStore = new NornRunStore(root);
 		await access(runStore.currentRoot, constants.R_OK | constants.W_OK);
-		await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
+		if (!(await runStore.isCheckpointHistoryPruned()))
+			await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
 		return runStore;
 	}
 
 	async currentSnapshotRef(): Promise<string> {
+		await this.assertCheckpointHistoryAvailable();
 		return readFile(this.currentRefPath, "utf8").then((value) => value.trim());
 	}
 
 	async snapshotCurrent(message: string): Promise<NornRunCheckpoint> {
+		await this.assertCheckpointHistoryAvailable();
 		const previous = await this.readCheckpointHistory();
 		const checkpoint = this.createCheckpoint(
 			message,
@@ -89,6 +94,7 @@ export class NornRunStore {
 		ref: string,
 		prepare: ((stagedRunRoot: string) => Promise<void>) | undefined,
 	): Promise<void> {
+		await this.assertCheckpointHistoryAvailable();
 		const checkpoint = (await this.listCheckpoints()).find(
 			(entry) => entry.id === ref,
 		);
@@ -107,9 +113,55 @@ export class NornRunStore {
 	}
 
 	async listCheckpoints(): Promise<NornRunCheckpoint[]> {
+		if (await this.isCheckpointHistoryPruned()) return [];
 		return (await this.readCheckpointHistory()).checkpoints;
 	}
 
+	async pruneCheckpointHistory(prunedAt: string): Promise<void> {
+		if (!(await this.isCheckpointHistoryPruned()))
+			await writeJsonAtomically(this.prunedHistoryPath, {
+				version: 1,
+				prunedAt,
+			});
+		await writeJsonAtomically(this.checkpointsPath, []);
+		await rm(this.storeRoot, { recursive: true, force: true });
+	}
+
+	private get prunedHistoryPath(): string {
+		return join(this.runRoot, PRUNED_HISTORY_FILE_NAME);
+	}
+
+	private async isCheckpointHistoryPruned(): Promise<boolean> {
+		let content: string;
+		try {
+			content = await readFile(this.prunedHistoryPath, "utf8");
+		} catch (error) {
+			if (isNodeError(error) && error.code === "ENOENT") return false;
+			throw error;
+		}
+		const marker: unknown = JSON.parse(content);
+		if (
+			!marker ||
+			typeof marker !== "object" ||
+			!("version" in marker) ||
+			marker.version !== 1 ||
+			!("prunedAt" in marker) ||
+			typeof marker.prunedAt !== "string" ||
+			!Number.isFinite(Date.parse(marker.prunedAt))
+		)
+			throw new Error(
+				`Invalid pruned checkpoint history marker: ${this.prunedHistoryPath}`,
+			);
+		return true;
+	}
+
+	private async assertCheckpointHistoryAvailable(): Promise<void> {
+		if (await this.isCheckpointHistoryPruned())
+			throw new Error(
+				`Checkpoint history was pruned for this run: ${this.runRoot}`,
+			);
+	}
+
 	private async readCheckpointHistory(): Promise<{
 		readonly checkpoints: NornRunCheckpoint[];
 		readonly content?: string;
@@ -191,7 +243,10 @@ export class NornRunStore {
 			createdAt: checkpoint.createdAt,
 			entries,
 		};
-		await writeJsonAtomically(this.snapshotPath(snapshot.id), snapshot);
+		await writeBytesAtomically(
+			this.snapshotPath(snapshot.id),
+			await gzipBuffer(Buffer.from(JSON.stringify(snapshot))),
+		);
 		return snapshot;
 	}
 
@@ -363,12 +418,25 @@ export class NornRunStore {
 	}
 
 	private async readSnapshot(id: string): Promise<RunSnapshotManifest> {
+		let compressed: Buffer;
+		try {
+			compressed = await readFile(this.snapshotPath(id));
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+			return parseRunSnapshotManifest(
+				JSON.parse(await readFile(this.getLegacySnapshotPath(id), "utf8")),
+			);
+		}
 		return parseRunSnapshotManifest(
-			JSON.parse(await readFile(this.snapshotPath(id), "utf8")),
+			JSON.parse((await gunzipBuffer(compressed)).toString("utf8")),
 		);
 	}
 
 	private snapshotPath(id: string): string {
+		return join(this.snapshotsRoot, `${id}.json.gz`);
+	}
+
+	private getLegacySnapshotPath(id: string): string {
 		return join(this.snapshotsRoot, `${id}.json`);
 	}
 
@@ -378,7 +446,11 @@ export class NornRunStore {
 
 	private assertCheckpointPathMatchesId(checkpoint: NornRunCheckpoint): void {
 		const expectedPath = this.snapshotRelativePath(checkpoint.id);
-		if (checkpoint.path !== expectedPath)
+		const legacyPath = relative(
+			this.runRoot,
+			this.getLegacySnapshotPath(checkpoint.id),
+		);
+		if (checkpoint.path !== expectedPath && checkpoint.path !== legacyPath)
 			throw new Error(
 				`Run checkpoint path does not match id: ${checkpoint.id}`,
 			);

package/assets/packages/core/src/atomic-files.ts

@@ -13,6 +13,13 @@ export async function writeJsonAtomically(
 export async function writeTextAtomically(
 	path: string,
 	content: string,
+): Promise<void> {
+	await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+
+export async function writeBytesAtomically(
+	path: string,
+	content: Uint8Array,
 ): Promise<void> {
 	await mkdir(dirname(path), { recursive: true });
 	let existingMode: number | undefined;
@@ -23,7 +30,7 @@ export async function writeTextAtomically(
 	}
 	const tmpPath = `${path}.${randomUUID()}.tmp`;
 	try {
-		await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+		await writeFile(tmpPath, content, { mode: existingMode });
 		if (existingMode !== undefined) await chmod(tmpPath, existingMode);
 		await rename(tmpPath, path);
 	} catch (error) {

package/assets/packages/sdk/src/api.ts

@@ -383,6 +383,26 @@ export type DeletedNornRunInfo = {
 	readonly path: string;
 };
 
+export type NornRunPruneOptions = {
+	readonly deleteRuns: boolean;
+	readonly all: boolean;
+	readonly olderThan: string | null;
+	readonly dryRun: boolean;
+};
+
+export type NornRunPruneResult = {
+	readonly mode: "checkpoints" | "runs";
+	readonly dryRun: boolean;
+	readonly olderThan: string | null;
+	readonly runs: readonly {
+		readonly id: string;
+		readonly name: string;
+		readonly path: string;
+		readonly status: "planned" | "pruned" | "skipped" | "failed";
+		readonly reason?: string;
+	}[];
+};
+
 export type NornRunCheckpoint = {
 	readonly id: string;
 	readonly path: string;

package/dist/cli.js

@@ -48,6 +48,7 @@ import {
 import { readRunMetrics } from "./internal/metrics.js";
 import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.js";
 import { generateRunName } from "./internal/run-names.js";
+import { NornRunPruner, parseRunPruneOptions } from "./internal/run-pruning.js";
 import {
   assertRunVersion,
   getRunInfo,
@@ -394,6 +395,37 @@ var COMMANDS = [
       await signalRun(run, "SIGKILL");
     }
   },
+  {
+    id: "runs.prune",
+    path: ["runs", "prune"],
+    description: "Discard checkpoint history or entire failed/completed runs, preserving recent and nonterminal runs.",
+    usage: "norn runs prune [--delete-runs] [--older-than <duration>|--all] [--dry-run]",
+    options: [
+      "--delete-runs: delete entire eligible runs instead of only checkpoint storage",
+      "--older-than <duration>: time since completion/failure; default 24h; units ms, s, m, h, d, w",
+      "--all: ignore age; requires --delete-runs; incompatible with --older-than",
+      "--dry-run: report eligible runs without changing files"
+    ],
+    output: "JSON object under prune with mode, dryRun, olderThan, and per-run planned/pruned/skipped/failed results. Any failed result sets a nonzero exit status.",
+    examples: [
+      "norn runs prune --dry-run",
+      "norn runs prune --older-than 7d",
+      "norn runs prune --delete-runs --all"
+    ],
+    execute: async (args) => {
+      const options = parseRunPruneOptions(args);
+      const project = await findNornProject(process.cwd());
+      const pruner = new NornRunPruner({
+        projectRoot: project.projectRoot,
+        options,
+        now: /* @__PURE__ */ new Date()
+      });
+      const result = await pruner.prune();
+      writeJson({ prune: result });
+      if (result.runs.some((run) => run.status === "failed"))
+        process.exitCode = 1;
+    }
+  },
   {
     id: "runs.delete",
     path: ["runs", "delete"],
@@ -468,6 +500,7 @@ var HELP_COMMAND_ORDER = [
   "runs.stop",
   "runs.kill",
   "runs.delete",
+  "runs.prune",
   "project.init",
   "project.inspect",
   "pi",
@@ -495,6 +528,7 @@ var HUMAN_COMMAND_SUMMARIES = {
   "runs.stop": "Stop a running run.",
   "runs.kill": "Force-stop a running run.",
   "runs.delete": "Delete an inactive run.",
+  "runs.prune": "Prune checkpoint storage or old failed/completed runs.",
   "project.init": "Create a Norn project in the current directory.",
   "project.inspect": "Inspect the Norn project.",
   pi: "Run bundled Pi for authentication, providers, and model setup.",

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunMetrics } from "@vimhead.dev/norn";
+import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunPruneOptions, NornRunPruneResult, NornRunMetrics } from "@vimhead.dev/norn";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 export { NornProjectLoadError } from "./internal/errors.ts";
 export type NornClientInput = {
@@ -35,6 +35,7 @@ export type NornClient = {
         stop(run: string): Promise<NornRunInfo>;
         kill(run: string): Promise<NornRunInfo>;
         delete(run: string): Promise<DeletedNornRunInfo>;
+        prune(options: NornRunPruneOptions): Promise<NornRunPruneResult>;
         logs(run: string, options?: {
             readonly follow?: boolean;
         }): AsyncIterable<Record<string, unknown>>;

package/dist/client.js

@@ -79,6 +79,14 @@ function createNornClient(input = {}) {
         "delete",
         run
       ])).deleted,
+      prune: async (options) => (await processRunner.readJson([
+        "runs",
+        "prune",
+        ...options.deleteRuns ? ["--delete-runs"] : [],
+        ...options.all ? ["--all"] : [],
+        ...options.olderThan === null ? [] : ["--older-than", options.olderThan],
+        ...options.dryRun ? ["--dry-run"] : []
+      ])).prune,
       logs: (run, options) => processRunner.readJsonLines([
         "runs",
         "logs",

package/dist/generated-build-info.d.ts

@@ -1,7 +1,7 @@
 export declare const NORN_GENERATED_BUILD_INFO: {
     readonly kind: "npm-registry";
-    readonly version: "0.1.0-tip.36679386408.1";
-    readonly commit: "3cb3189ec70f3b4407456061207294d685297b69";
+    readonly version: "0.1.0-tip.36824462948.1";
+    readonly commit: "c98b6febf7a42abc1201dfdceb1553fc9e91c08c";
     readonly packageSpec: "@vimhead.dev/norn-cli@tip";
     readonly upgrade: {
         readonly supported: false;

package/dist/generated-build-info.js

@@ -1,8 +1,8 @@
 // src/generated-build-info.ts
 var NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.36679386408.1",
-  "commit": "3cb3189ec70f3b4407456061207294d685297b69",
+  "version": "0.1.0-tip.36824462948.1",
+  "commit": "c98b6febf7a42abc1201dfdceb1553fc9e91c08c",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/dist/internal/file-coordinator.js

@@ -10,6 +10,9 @@ function isNodeError(error) {
 
 // ../core/src/atomic-files.ts
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -19,7 +22,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/launch-request.js

@@ -19,6 +19,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -28,7 +31,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/run-lease.d.ts

@@ -17,6 +17,7 @@ export declare class NornRunLease {
     private constructor();
     static acquire(runRoot: string, processOwner?: NornRunProcessOwner): Promise<NornRunLease>;
     assertOwned(): Promise<void>;
+    deleteRunDirectory(): Promise<void>;
     release(): Promise<void>;
     private get ownerPath();
     private startHeartbeat;

package/dist/internal/run-lease.js

@@ -1,7 +1,7 @@
 // src/internal/run-lease.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir2, readFile, rm as rm2, stat as stat2 } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir as mkdir2, readFile, rename as rename2, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname2, join } from "node:path";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -17,6 +17,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -26,7 +29,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {
@@ -83,6 +86,27 @@ var NornRunLease = class _NornRunLease {
     if (!owner || owner.token !== this.token)
       throw new Error("Run lease was lost");
   }
+  async deleteRunDirectory() {
+    await this.assertOwned();
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    await this.heartbeatChain;
+    await this.assertOwned();
+    const runRoot = dirname2(this.lockRoot);
+    const retiredRoot = join(
+      dirname2(dirname2(runRoot)),
+      `.pruned-run-${randomUUID2()}`
+    );
+    await rename2(runRoot, retiredRoot);
+    this.isReleased = true;
+    try {
+      await rm2(retiredRoot, { recursive: true, force: true });
+    } catch (error) {
+      throw new Error(
+        `Run was removed from the run list but directory cleanup failed: ${retiredRoot}`,
+        { cause: error }
+      );
+    }
+  }
   async release() {
     if (this.isReleased) return;
     this.isReleased = true;

package/dist/internal/run-log.js

@@ -15,6 +15,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -24,7 +27,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/run-pruning.d.ts

@@ -0,0 +1,14 @@
+import type { NornRunPruneOptions, NornRunPruneResult } from "@vimhead.dev/norn";
+export declare function parseRunPruneOptions(args: readonly string[]): NornRunPruneOptions;
+export declare class NornRunPruner {
+    private readonly input;
+    private readonly olderThan;
+    private readonly cutoff;
+    constructor(input: {
+        readonly projectRoot: string;
+        readonly options: NornRunPruneOptions;
+        readonly now: Date;
+    });
+    prune(): Promise<NornRunPruneResult>;
+    private findIneligibilityReason;
+}

package/dist/internal/run-pruning.js

@@ -0,0 +1,141 @@
+// src/internal/run-pruning.ts
+import { errorMessage } from "./errors.js";
+import { getRunLeaseOwner, NornRunLease } from "./run-lease.js";
+import { getRunInfo, listRuns } from "./run-state.js";
+import { NornRunStore } from "./run-store.js";
+var DURATION_UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseRunPruneOptions(args) {
+  const flags = /* @__PURE__ */ new Set();
+  let olderThan = null;
+  for (let index = 0; index < args.length; index++) {
+    const flag = args[index];
+    if (!["--delete-runs", "--all", "--dry-run", "--older-than"].includes(flag))
+      throw new Error(`runs prune: unknown argument ${flag}`);
+    if (flags.has(flag))
+      throw new Error(`runs prune: duplicate option ${flag}`);
+    flags.add(flag);
+    if (flag === "--older-than") {
+      const value = args[++index];
+      if (value === void 0 || value.startsWith("--"))
+        throw new Error(
+          "runs prune: --older-than requires a duration such as 24h or 7d"
+        );
+      olderThan = value;
+    }
+  }
+  return {
+    deleteRuns: flags.has("--delete-runs"),
+    all: flags.has("--all"),
+    olderThan,
+    dryRun: flags.has("--dry-run")
+  };
+}
+function parsePruneDuration(value) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/.exec(value);
+  const duration = match ? Number(match[1]) * DURATION_UNITS[match[2]] : NaN;
+  if (!Number.isFinite(duration) || duration < 0 || duration > Number.MAX_SAFE_INTEGER)
+    throw new Error(
+      `runs prune: invalid duration ${value}; use a non-negative number followed by ms, s, m, h, d, or w`
+    );
+  return duration;
+}
+var NornRunPruner = class {
+  constructor(input) {
+    this.input = input;
+    if (input.options.all && !input.options.deleteRuns)
+      throw new Error("runs prune: --all requires --delete-runs");
+    if (input.options.all && input.options.olderThan !== null)
+      throw new Error(
+        "runs prune: --all and --older-than are mutually exclusive"
+      );
+    if (!Number.isFinite(input.now.getTime()))
+      throw new Error("Invalid pruning time");
+    this.olderThan = input.options.all ? null : input.options.olderThan ?? "24h";
+    this.cutoff = this.olderThan === null ? null : input.now.getTime() - parsePruneDuration(this.olderThan);
+  }
+  input;
+  olderThan;
+  cutoff;
+  async prune() {
+    const results = [];
+    for (const run of await listRuns(this.input.projectRoot)) {
+      const identity = { id: run.id, name: run.name, path: run.path };
+      let lease;
+      try {
+        let reason = this.findIneligibilityReason(run);
+        if (!reason && await getRunLeaseOwner(run.path))
+          reason = "Run is owned by an executor";
+        if (reason) {
+          results.push({ ...identity, status: "skipped", reason });
+          continue;
+        }
+        if (this.input.options.dryRun) {
+          results.push({ ...identity, status: "planned" });
+          continue;
+        }
+        try {
+          lease = await NornRunLease.acquire(run.path);
+        } catch (error) {
+          if (error instanceof Error && error.message.startsWith("Run is already active:")) {
+            results.push({
+              ...identity,
+              status: "skipped",
+              reason: "Run is owned by an executor"
+            });
+            continue;
+          }
+          throw error;
+        }
+        reason = this.findIneligibilityReason(await getRunInfo(run.path));
+        if (reason) {
+          results.push({ ...identity, status: "skipped", reason });
+          continue;
+        }
+        await lease.assertOwned();
+        if (this.input.options.deleteRuns) {
+          await lease.deleteRunDirectory();
+        } else {
+          const store = await NornRunStore.open(run.path);
+          await store.pruneCheckpointHistory(this.input.now.toISOString());
+        }
+        results.push({ ...identity, status: "pruned" });
+      } catch (error) {
+        results.push({
+          ...identity,
+          status: "failed",
+          reason: errorMessage(error)
+        });
+      } finally {
+        await lease?.release();
+      }
+    }
+    return {
+      mode: this.input.options.deleteRuns ? "runs" : "checkpoints",
+      dryRun: this.input.options.dryRun,
+      olderThan: this.olderThan,
+      runs: results
+    };
+  }
+  findIneligibilityReason(run) {
+    if (run.status !== "completed" && run.status !== "failed")
+      return `Run status is ${run.status}; only completed or failed runs are eligible`;
+    const finishedAt = run.status === "failed" ? run.failed?.failedAt ?? run.outcome?.completedAt ?? run.updatedAt : run.outcome?.completedAt ?? run.updatedAt;
+    const finishedTime = Date.parse(finishedAt);
+    if (!Number.isFinite(finishedTime))
+      return "Run completion/failure time is invalid";
+    if (this.cutoff !== null && finishedTime >= this.cutoff)
+      return `Run finished less than or exactly ${this.olderThan} ago`;
+    return void 0;
+  }
+};
+export {
+  NornRunPruner,
+  parseRunPruneOptions
+};

package/dist/internal/run-state.js

@@ -24,6 +24,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -33,7 +36,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {

package/dist/internal/run-store.d.ts

@@ -12,6 +12,10 @@ export declare class NornRunStore {
     restoreSnapshot(ref: string, prepare: ((stagedRunRoot: string) => Promise<void>) | undefined): Promise<void>;
     restoreCurrentSnapshot(): Promise<void>;
     listCheckpoints(): Promise<NornRunCheckpoint[]>;
+    pruneCheckpointHistory(prunedAt: string): Promise<void>;
+    private get prunedHistoryPath();
+    private isCheckpointHistoryPruned;
+    private assertCheckpointHistoryAvailable;
     private readCheckpointHistory;
     assertWorkspaceCanBeSnapshotted(_workspace: string): Promise<void>;
     private get objectsRoot();
@@ -29,6 +33,7 @@ export declare class NornRunStore {
     private materializedPath;
     private readSnapshot;
     private snapshotPath;
+    private getLegacySnapshotPath;
     private snapshotRelativePath;
     private assertCheckpointPathMatchesId;
     private objectPath;

package/dist/internal/run-store.js

@@ -34,6 +34,9 @@ async function writeJsonAtomically(path, value) {
 `);
 }
 async function writeTextAtomically(path, content) {
+  await writeBytesAtomically(path, Buffer.from(content, "utf8"));
+}
+async function writeBytesAtomically(path, content) {
   await mkdir(dirname(path), { recursive: true });
   let existingMode;
   try {
@@ -43,7 +46,7 @@ async function writeTextAtomically(path, content) {
   }
   const tmpPath = `${path}.${randomUUID()}.tmp`;
   try {
-    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    await writeFile(tmpPath, content, { mode: existingMode });
     if (existingMode !== void 0) await chmod(tmpPath, existingMode);
     await rename(tmpPath, path);
   } catch (error) {
@@ -59,6 +62,7 @@ var SNAPSHOT_VERSION = 1;
 var CURRENT_DIR_NAME = "current";
 var STORE_DIR_NAME = "store";
 var CHECKPOINTS_FILE_NAME = "checkpoints.json";
+var PRUNED_HISTORY_FILE_NAME = "checkpoint-history-pruned.json";
 function runCurrentRoot(runRoot) {
   return join(runRoot, CURRENT_DIR_NAME);
 }
@@ -82,13 +86,16 @@ var NornRunStore = class _NornRunStore {
   static async open(root) {
     const runStore = new _NornRunStore(root);
     await access(runStore.currentRoot, constants.R_OK | constants.W_OK);
-    await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
+    if (!await runStore.isCheckpointHistoryPruned())
+      await access(runStore.storeRoot, constants.R_OK | constants.W_OK);
     return runStore;
   }
   async currentSnapshotRef() {
+    await this.assertCheckpointHistoryAvailable();
     return readFile(this.currentRefPath, "utf8").then((value) => value.trim());
   }
   async snapshotCurrent(message) {
+    await this.assertCheckpointHistoryAvailable();
     const previous = await this.readCheckpointHistory();
     const checkpoint = this.createCheckpoint(
       message,
@@ -109,6 +116,7 @@ var NornRunStore = class _NornRunStore {
     return checkpoint;
   }
   async restoreSnapshot(ref, prepare) {
+    await this.assertCheckpointHistoryAvailable();
     const checkpoint = (await this.listCheckpoints()).find(
       (entry) => entry.id === ref
     );
@@ -125,8 +133,42 @@ var NornRunStore = class _NornRunStore {
     );
   }
   async listCheckpoints() {
+    if (await this.isCheckpointHistoryPruned()) return [];
     return (await this.readCheckpointHistory()).checkpoints;
   }
+  async pruneCheckpointHistory(prunedAt) {
+    if (!await this.isCheckpointHistoryPruned())
+      await writeJsonAtomically(this.prunedHistoryPath, {
+        version: 1,
+        prunedAt
+      });
+    await writeJsonAtomically(this.checkpointsPath, []);
+    await rm2(this.storeRoot, { recursive: true, force: true });
+  }
+  get prunedHistoryPath() {
+    return join(this.runRoot, PRUNED_HISTORY_FILE_NAME);
+  }
+  async isCheckpointHistoryPruned() {
+    let content;
+    try {
+      content = await readFile(this.prunedHistoryPath, "utf8");
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return false;
+      throw error;
+    }
+    const marker = JSON.parse(content);
+    if (!marker || typeof marker !== "object" || !("version" in marker) || marker.version !== 1 || !("prunedAt" in marker) || typeof marker.prunedAt !== "string" || !Number.isFinite(Date.parse(marker.prunedAt)))
+      throw new Error(
+        `Invalid pruned checkpoint history marker: ${this.prunedHistoryPath}`
+      );
+    return true;
+  }
+  async assertCheckpointHistoryAvailable() {
+    if (await this.isCheckpointHistoryPruned())
+      throw new Error(
+        `Checkpoint history was pruned for this run: ${this.runRoot}`
+      );
+  }
   async readCheckpointHistory() {
     try {
       const content = await readFile(this.checkpointsPath, "utf8");
@@ -196,7 +238,10 @@ var NornRunStore = class _NornRunStore {
       createdAt: checkpoint.createdAt,
       entries
     };
-    await writeJsonAtomically(this.snapshotPath(snapshot.id), snapshot);
+    await writeBytesAtomically(
+      this.snapshotPath(snapshot.id),
+      await gzipBuffer(Buffer.from(JSON.stringify(snapshot)))
+    );
     return snapshot;
   }
   async snapshotEntries(root) {
@@ -346,11 +391,23 @@ var NornRunStore = class _NornRunStore {
     return path;
   }
   async readSnapshot(id) {
+    let compressed;
+    try {
+      compressed = await readFile(this.snapshotPath(id));
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+      return parseRunSnapshotManifest(
+        JSON.parse(await readFile(this.getLegacySnapshotPath(id), "utf8"))
+      );
+    }
     return parseRunSnapshotManifest(
-      JSON.parse(await readFile(this.snapshotPath(id), "utf8"))
+      JSON.parse((await gunzipBuffer(compressed)).toString("utf8"))
     );
   }
   snapshotPath(id) {
+    return join(this.snapshotsRoot, `${id}.json.gz`);
+  }
+  getLegacySnapshotPath(id) {
     return join(this.snapshotsRoot, `${id}.json`);
   }
   snapshotRelativePath(id) {
@@ -358,7 +415,11 @@ var NornRunStore = class _NornRunStore {
   }
   assertCheckpointPathMatchesId(checkpoint) {
     const expectedPath = this.snapshotRelativePath(checkpoint.id);
-    if (checkpoint.path !== expectedPath)
+    const legacyPath = relative(
+      this.runRoot,
+      this.getLegacySnapshotPath(checkpoint.id)
+    );
+    if (checkpoint.path !== expectedPath && checkpoint.path !== legacyPath)
       throw new Error(
         `Run checkpoint path does not match id: ${checkpoint.id}`
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn-cli",
-  "version": "0.1.0-tip.36679386408.1",
+  "version": "0.1.0-tip.36824462948.1",
   "description": "Harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "@earendil-works/pi-coding-agent": "0.99.1",
     "jiti": "^2.7.0",
     "typebox": "^1.3.34",
-    "@vimhead.dev/norn": "0.1.0-tip.36679386408.1"
+    "@vimhead.dev/norn": "0.1.0-tip.36824462948.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"