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

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;
@@ -458,6 +478,11 @@ export type NornAgentBeforeSessionStartContext = {
 	readonly events: EventBus;
 };
 
+export type NornAgentModelReference = {
+	readonly provider: string;
+	readonly id: string;
+};
+
 export type NornAgentCreateSessionInput = {
 	readonly customTools?: readonly ToolDefinition[];
 	readonly label: string;
@@ -466,7 +491,10 @@ export type NornAgentCreateSessionInput = {
 	readonly beforeSessionStart?: (
 		context: NornAgentBeforeSessionStartContext,
 	) => MaybePromise<void>;
-	readonly model?: CreateAgentSessionOptions["model"];
+	readonly models: readonly [
+		NornAgentModelReference,
+		...NornAgentModelReference[],
+	];
 	readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
 	readonly systemPrompt?: string;
 	readonly appendSystemPrompt?: readonly 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.37307659560.1";
+    readonly commit: "31ff51915f9cd5da805d67b7a4b23c2f10a6de59";
     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.37307659560.1",
+  "commit": "31ff51915f9cd5da805d67b7a4b23c2f10a6de59",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/dist/internal/agents.d.ts

@@ -8,7 +8,6 @@ type NornAgentRunnerInput = {
     readonly id: string;
     readonly runRoot: string;
     readonly signal?: AbortSignal;
-    readonly model?: CreateAgentSessionOptions["model"];
     readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
     readonly agentDir?: string;
     readonly logs: NornRunLogs;
@@ -20,6 +19,7 @@ export declare class NornAgentRunner {
     private readonly responseToolFactory;
     constructor(input: NornAgentRunnerInput);
     createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession>;
+    private selectModel;
     prompt<ResponseSchema extends TSchema>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
 }
 export {};

package/dist/internal/agents.js

@@ -76,6 +76,7 @@ var NornAgentRunner = class {
         ...loader.getExtensions().extensions.flatMap((extension) => [...extension.tools.keys()])
       ]
     });
+    const model = this.selectModel({ models: agentInput.models, services });
     let session;
     try {
       ({ session } = await createAgentSessionFromServices({
@@ -83,7 +84,7 @@ var NornAgentRunner = class {
         sessionManager: SessionManager.create(cwd, sessionDir),
         tools: withAgentResponseTool(agentInput.tools),
         customTools: [this.responseToolFactory.create(), ...customTools],
-        model: agentInput.model ?? this.input.model,
+        model,
         thinkingLevel: agentInput.thinkingLevel ?? this.input.thinkingLevel
       }));
       await agentInput.beforeSessionStart?.({ events: eventBus });
@@ -91,7 +92,8 @@ var NornAgentRunner = class {
       await this.input.logger.record({
         type: "agent.spawned",
         label: agentInput.label,
-        cwd
+        cwd,
+        model: { provider: model.provider, id: model.id }
       });
       return new CreatedNornAgentSession({
         ...this.input,
@@ -112,6 +114,35 @@ var NornAgentRunner = class {
       throw error;
     }
   }
+  selectModel(input) {
+    if (!Array.isArray(input.models) || input.models.length === 0)
+      throw new Error("Agent models must be a non-empty ordered list");
+    for (const [index, reference] of input.models.entries()) {
+      if (!reference || typeof reference.provider !== "string" || reference.provider.trim().length === 0 || typeof reference.id !== "string" || reference.id.trim().length === 0)
+        throw new Error(
+          `Agent models[${index}] requires non-empty provider and id strings`
+        );
+    }
+    const reasons = [];
+    for (const reference of input.models) {
+      const name = `${reference.provider}/${reference.id}`;
+      const model = input.services.modelRuntime.getModel(
+        reference.provider,
+        reference.id
+      );
+      if (!model) {
+        reasons.push(`${name}: not registered`);
+        continue;
+      }
+      if (!input.services.modelRuntime.hasConfiguredAuth(reference.provider)) {
+        reasons.push(`${name}: no configured credentials`);
+        continue;
+      }
+      return model;
+    }
+    throw new Error(`No usable agent models:
+${reasons.join("\n")}`);
+  }
   async prompt(agentInput) {
     const agent = await this.createSession(agentInput);
     try {

package/dist/internal/execution-context.d.ts

@@ -7,7 +7,6 @@ type NornExecutionContextInput = {
     readonly id: string;
     readonly runRoot: string;
     readonly signal?: AbortSignal;
-    readonly model?: CreateAgentSessionOptions["model"];
     readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
     readonly agentDir?: string;
     readonly responseCollector: NornAgentResponseCollector;

package/dist/internal/execution-context.js

@@ -42,7 +42,6 @@ var NornExecutionContext = class {
       id: this.input.id,
       runRoot: this.input.runRoot,
       signal: this.input.signal,
-      model: this.input.model,
       thinkingLevel: this.input.thinkingLevel,
       agentDir: this.input.agentDir,
       logs: this.input.logs,

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;