@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/cli.js

@@ -9,25 +9,61 @@ function isNodeError(error) {
 // src/cli.ts
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import { Value } from "typebox/value";
-import { NORN_BUILD_INFO } from "./build-info.js";
-import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation } from "./documentation.js";
+import {
+  NORN_BUILD_INFO
+} from "./build-info.js";
+import {
+  renderNornDocumentationIntro,
+  resolveDocumentationCacheRoot,
+  resolveNornDocumentation
+} from "./documentation.js";
 import { NornEngine } from "./internal/engine.js";
 import { resolveNornAgentDirectory } from "./internal/agent-directory.js";
-import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.js";
-import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest } from "./internal/launch-request.js";
+import {
+  errorMessage,
+  NornProjectLoadError,
+  NornRunStoppedError
+} from "./internal/errors.js";
+import {
+  clearRunResumeRequest,
+  readRunLaunchRequest,
+  readRunResumeRequest,
+  writeRunLaunchRequest,
+  writeRunResumeRequest
+} from "./internal/launch-request.js";
 import { readRunMetrics } from "./internal/metrics.js";
 import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.js";
 import { generateRunName } from "./internal/run-names.js";
-import { assertRunVersion, getRunInfo, listRuns, mergeInterruptedWorkflowArgs, resolveRunRoot } from "./internal/run-state.js";
+import {
+  assertRunVersion,
+  getRunInfo,
+  listRuns,
+  mergeInterruptedWorkflowArgs,
+  resolveRunRoot
+} from "./internal/run-state.js";
 import { NornRunStore } from "./internal/run-store.js";
 import { prepareRunWorkerDirectory } from "./internal/worker-directory.js";
-import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./workflow-loader.js";
+import {
+  discoverNornProject,
+  findNornProject,
+  inspectNornWorkflow,
+  loadNornProject,
+  NORN_PROJECT_FILE_NAME
+} from "./workflow-loader.js";
 var RUNS_ROOT = join(".norn", "runs");
 var RUN_WAIT_INTERVAL_MS = 1e3;
 var CLI_DESCRIPTION = "Norn is a harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents. Build workflows with the Norn SDK; use this JSON-native CLI to discover workflows, start or resume runs, inspect evidence, and manage the installed runtime.";
@@ -37,9 +73,16 @@ var COMMANDS = [
     path: ["pi"],
     description: "Run Norn's bundled Pi CLI for interactive authentication, provider packages, model configuration, or direct Pi use. No Norn project is required.",
     usage: "norn pi [pi arguments...]",
-    arguments: ["pi arguments: forwarded unchanged; use norn pi --help for Pi's CLI contract"],
+    arguments: [
+      "pi arguments: forwarded unchanged; use norn pi --help for Pi's CLI contract"
+    ],
     output: "Pi's native terminal, text, JSON, or RPC output and exit status; not wrapped in Norn JSON.",
-    examples: ["norn pi", "norn pi install npm:pi-cursor-sdk", "norn pi --list-models cursor", "norn pi --help"],
+    examples: [
+      "norn pi",
+      "norn pi install npm:pi-cursor-sdk",
+      "norn pi --list-models cursor",
+      "norn pi --help"
+    ],
     execute: (args) => runPi([...args])
   },
   {
@@ -67,9 +110,16 @@ var COMMANDS = [
     path: ["help"],
     description: "Use when reading JSON help for all Norn commands, one command group, or one command.",
     usage: "norn help [command-or-group]",
-    arguments: ["command-or-group: optional command path such as runs or runs start"],
+    arguments: [
+      "command-or-group: optional command path such as runs or runs start"
+    ],
     output: "JSON object with help metadata under help.",
-    examples: ["norn help", "norn help runs", "norn help runs start", "norn --help"],
+    examples: [
+      "norn help",
+      "norn help runs",
+      "norn help runs start",
+      "norn --help"
+    ],
     execute: (args) => writeCliHelp(args)
   },
   {
@@ -81,7 +131,9 @@ var COMMANDS = [
     examples: ["norn docs inspect"],
     execute: async (args, documentationSource) => {
       assertNoExtraArgs("docs inspect", args);
-      writeJson({ documentation: await resolveCliDocumentation(documentationSource) });
+      writeJson({
+        documentation: await resolveCliDocumentation(documentationSource)
+      });
     }
   },
   {
@@ -93,10 +145,15 @@ var COMMANDS = [
     examples: ["norn docs intro"],
     execute: async (args, documentationSource) => {
       assertNoExtraArgs("docs intro", args);
-      writeJson({ intro: renderNornDocumentationIntro({
-        documentation: await resolveCliDocumentation(documentationSource),
-        invocation: documentationSource.kind === "embedded" ? [process.execPath] : [process.execPath, fileURLToPath(new URL("../bin/norn.mjs", import.meta.url))]
-      }) });
+      writeJson({
+        intro: renderNornDocumentationIntro({
+          documentation: await resolveCliDocumentation(documentationSource),
+          invocation: documentationSource.kind === "embedded" ? [process.execPath] : [
+            process.execPath,
+            fileURLToPath(new URL("../bin/norn.mjs", import.meta.url))
+          ]
+        })
+      });
     }
   },
   {
@@ -128,7 +185,10 @@ var COMMANDS = [
     path: ["workflows", "list"],
     description: "Use when selecting a Norn workflow for a user task; defaults to entrypoint workflows.",
     usage: "norn workflows list [--entrypoints|--all]",
-    options: ["--entrypoints: list entrypoint workflows", "--all: include internal workflow steps"],
+    options: [
+      "--entrypoints: list entrypoint workflows",
+      "--all: include internal workflow steps"
+    ],
     output: "JSON object with workflow summaries under workflows, isComplete, and registration diagnostics. Successful discovery can be incomplete; start/resume remain strict.",
     examples: ["norn workflows list", "norn workflows list --all"],
     execute: listWorkflows
@@ -142,7 +202,12 @@ var COMMANDS = [
     output: "JSON object with workflow details, isComplete, and registration diagnostics. workflow is null if unavailable in an incomplete catalog or its schema cannot be inspected; an unknown id in a complete catalog is an error.",
     examples: ["norn workflows inspect example.plan"],
     execute: async (args) => {
-      const workflowId = requiredArg("workflows inspect", args, 0, "workflow id");
+      const workflowId = requiredArg(
+        "workflows inspect",
+        args,
+        0,
+        "workflow id"
+      );
       assertNoExtraArgs("workflows inspect", args.slice(1));
       await inspectWorkflow(workflowId);
     }
@@ -155,7 +220,9 @@ var COMMANDS = [
     arguments: ["workflow-id: fully qualified workflow id to start"],
     stdin: 'Optional JSON object: {"args":{...},"config":{"workflowOrScopeId":{...}}}.',
     output: "JSON object with started run info under run.",
-    examples: [`printf '{"args":{"task":"Add tests"}}' | norn runs start example.plan`],
+    examples: [
+      `printf '{"args":{"task":"Add tests"}}' | norn runs start example.plan`
+    ],
     execute: async (args) => {
       const workflowId = requiredArg("runs start", args, 0, "workflow id");
       await startRun(workflowId, args.slice(1));
@@ -169,7 +236,9 @@ var COMMANDS = [
     arguments: ["run: run id, generated name, or run path"],
     stdin: 'Optional JSON object: {"args":{...}}. Interrupted runs require a patch containing only editable gate fields; pending-resume runs do not accept args.',
     output: "JSON object with resumed run info under run.",
-    examples: [`printf '{"args":{"decision":"accept"}}' | norn runs resume quiet-river-lantern`],
+    examples: [
+      `printf '{"args":{"decision":"accept"}}' | norn runs resume quiet-river-lantern`
+    ],
     execute: async (args) => {
       const run = requiredArg("runs resume", args, 0, "run");
       await resumeRun(run, args.slice(1));
@@ -228,7 +297,9 @@ var COMMANDS = [
       assertNoExtraArgs("runs checkpoints", args.slice(1));
       const project = await findNornProject(process.cwd());
       const runRoot = await resolveRunRoot(project.projectRoot, run);
-      writeJson({ checkpoints: await (await NornRunStore.open(runRoot)).listCheckpoints() });
+      writeJson({
+        checkpoints: await (await NornRunStore.open(runRoot)).listCheckpoints()
+      });
     }
   },
   {
@@ -255,7 +326,10 @@ var COMMANDS = [
     arguments: ["run: run id, generated name, or run path"],
     options: ["--follow: continue streaming until the run stops"],
     output: "JSON Lines stream of run events.",
-    examples: ["norn runs logs quiet-river-lantern", "norn runs logs quiet-river-lantern --follow"],
+    examples: [
+      "norn runs logs quiet-river-lantern",
+      "norn runs logs quiet-river-lantern --follow"
+    ],
     execute: async (args) => {
       const run = requiredArg("runs logs", args, 0, "run");
       const logArgs = args.slice(1);
@@ -268,7 +342,10 @@ var COMMANDS = [
     path: ["runs", "rollback"],
     description: "Use when restoring a failed or stopped run to a checkpoint and marking it pending resume.",
     usage: "norn runs rollback <run> <checkpoint-id>",
-    arguments: ["run: run id, generated name, or run path", "checkpoint-id: checkpoint id from runs.checkpoints"],
+    arguments: [
+      "run: run id, generated name, or run path",
+      "checkpoint-id: checkpoint id from runs.checkpoints"
+    ],
     output: "JSON object with rolled-back run info under run.",
     examples: ["norn runs rollback quiet-river-lantern checkpoint-1"],
     execute: async (args) => {
@@ -338,7 +415,9 @@ var COMMANDS = [
     path: ["upgrade"],
     description: "Use when upgrading this Norn CLI installation according to explicit build metadata.",
     usage: "norn upgrade [--dry-run]",
-    options: ["--dry-run: report the upgrade plan without changing files or running installers"],
+    options: [
+      "--dry-run: report the upgrade plan without changing files or running installers"
+    ],
     output: "JSON object with upgrade status, plan, or unsupported reason under upgrade.",
     examples: ["norn upgrade --dry-run", "norn upgrade"],
     execute: upgradeNorn
@@ -416,11 +495,13 @@ async function main(args, documentationSource) {
   try {
     await runCommand(args, documentationSource);
   } catch (error) {
-    writeJson({ error: {
-      code: errorCode(error),
-      message: errorMessage(error),
-      ...error instanceof NornProjectLoadError ? { isComplete: error.isComplete, diagnostics: error.diagnostics } : {}
-    } });
+    writeJson({
+      error: {
+        code: errorCode(error),
+        message: errorMessage(error),
+        ...error instanceof NornProjectLoadError ? { isComplete: error.isComplete, diagnostics: error.diagnostics } : {}
+      }
+    });
     process.exitCode = 1;
   }
 }
@@ -445,7 +526,11 @@ async function runCommand(args, documentationSource) {
 async function listCliCommands(args) {
   assertKnownFlags("commands list", args, ["--all"]);
   const shouldIncludeHidden = args.includes("--all");
-  writeJson({ commands: COMMANDS.filter((command) => shouldIncludeHidden || !command.hidden).map(cliCommandInfo) });
+  writeJson({
+    commands: COMMANDS.filter(
+      (command) => shouldIncludeHidden || !command.hidden
+    ).map(cliCommandInfo)
+  });
 }
 async function inspectCliCommand(args) {
   const commandId = requiredArg("commands inspect", args, 0, "command id");
@@ -482,8 +567,13 @@ function writeCliHelp(path) {
     process.stdout.write(renderCommandHelp(command));
     return;
   }
-  const groupCommands = sortedCommandsForHelp(visibleCommands().filter((candidate) => path.length === 0 || startsWithPath(candidate.path, path)));
-  if (groupCommands.length === 0) throw new Error(`Unknown norn help topic: ${path.join(" ")}`);
+  const groupCommands = sortedCommandsForHelp(
+    visibleCommands().filter(
+      (candidate) => path.length === 0 || startsWithPath(candidate.path, path)
+    )
+  );
+  if (groupCommands.length === 0)
+    throw new Error(`Unknown norn help topic: ${path.join(" ")}`);
   process.stdout.write(renderGroupHelp(path, groupCommands));
 }
 function renderGroupHelp(path, commands) {
@@ -526,27 +616,42 @@ function renderCommandHelp(command) {
 function renderCommandSummary(commands) {
   const commandNames = commands.map((command) => command.path.join(" "));
   const width = Math.max(...commandNames.map((name) => name.length));
-  return commands.map((command, index) => `  ${commandNames[index].padEnd(width)}  ${commandHumanSummary(command)}`).join("\n");
+  return commands.map(
+    (command, index) => `  ${commandNames[index].padEnd(width)}  ${commandHumanSummary(command)}`
+  ).join("\n");
 }
 function helpSection(title, lines) {
   return ["", `${title}:`, ...lines.map((line) => `  ${line}`)];
 }
 function groupHelpUsage(path) {
-  if (path.length === 0) return ["norn <command> [args]", "norn help <command>", "norn --version"];
+  if (path.length === 0)
+    return ["norn <command> [args]", "norn help <command>", "norn --version"];
   const prefix = `norn ${path.join(" ")}`;
-  return [`${prefix} <command> [args]`, `norn help ${path.join(" ")} <command>`, "norn --version"];
+  return [
+    `${prefix} <command> [args]`,
+    `norn help ${path.join(" ")} <command>`,
+    "norn --version"
+  ];
 }
 function findCliCommand(args) {
-  return sortedCommandsByPathLength(COMMANDS).find((command) => startsWithPath(args, command.path));
+  return sortedCommandsByPathLength(COMMANDS).find(
+    (command) => startsWithPath(args, command.path)
+  );
 }
 function findExactCliCommand(path) {
-  return COMMANDS.find((command) => command.path.length === path.length && startsWithPath(command.path, path));
+  return COMMANDS.find(
+    (command) => command.path.length === path.length && startsWithPath(command.path, path)
+  );
 }
 function sortedCommandsByPathLength(commands) {
-  return [...commands].sort((left, right) => right.path.length - left.path.length);
+  return [...commands].sort(
+    (left, right) => right.path.length - left.path.length
+  );
 }
 function sortedCommandsForHelp(commands) {
-  return [...commands].sort((left, right) => commandHelpOrder(left) - commandHelpOrder(right));
+  return [...commands].sort(
+    (left, right) => commandHelpOrder(left) - commandHelpOrder(right)
+  );
 }
 function commandHelpOrder(command) {
   const index = HELP_COMMAND_ORDER.indexOf(command.id);
@@ -565,7 +670,11 @@ async function resolveCliDocumentation(source) {
   return resolveNornDocumentation({
     source,
     build: { ...NORN_BUILD_INFO, version: await readPackageVersion() },
-    cacheRoot: resolveDocumentationCacheRoot({ platform: process.platform, home: homedir(), environment: process.env })
+    cacheRoot: resolveDocumentationCacheRoot({
+      platform: process.platform,
+      home: homedir(),
+      environment: process.env
+    })
   });
 }
 async function versionInfo() {
@@ -573,11 +682,15 @@ async function versionInfo() {
 }
 async function readPackageVersion() {
   try {
-    const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-    if (typeof packageJson.version !== "string") throw new Error("Invalid Norn package version");
+    const packageJson = JSON.parse(
+      await readFile(new URL("../package.json", import.meta.url), "utf8")
+    );
+    if (typeof packageJson.version !== "string")
+      throw new Error("Invalid Norn package version");
     return packageJson.version;
   } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") return NORN_BUILD_INFO.version;
+    if (isNodeError(error) && error.code === "ENOENT")
+      return NORN_BUILD_INFO.version;
     throw error;
   }
 }
@@ -587,10 +700,14 @@ async function upgradeNorn(args) {
   const currentVersion = await readPackageVersion();
   const build = NORN_BUILD_INFO;
   if (build.kind !== "github-release-binary") {
-    writeJson({ upgrade: unsupportedUpgrade(build, currentVersion, build.upgrade.reason) });
+    writeJson({
+      upgrade: unsupportedUpgrade(build, currentVersion, build.upgrade.reason)
+    });
     return;
   }
-  writeJson({ upgrade: await upgradeGithubReleaseBinary(build, currentVersion, dryRun) });
+  writeJson({
+    upgrade: await upgradeGithubReleaseBinary(build, currentVersion, dryRun)
+  });
 }
 function unsupportedUpgrade(build, currentVersion, reason) {
   return {
@@ -604,13 +721,27 @@ function unsupportedUpgrade(build, currentVersion, reason) {
 async function upgradeGithubReleaseBinary(build, currentVersion, dryRun) {
   const plan = githubReleaseBinaryUpgradePlan(build, currentVersion, dryRun);
   if (dryRun) return { ...plan, status: "planned" };
-  if (process.platform === "win32") return unsupportedUpgrade(build, currentVersion, "Replacing a running Windows executable is not supported yet.");
+  if (process.platform === "win32")
+    return unsupportedUpgrade(
+      build,
+      currentVersion,
+      "Replacing a running Windows executable is not supported yet."
+    );
   const binary = await downloadReleaseAsset(plan.downloadUrl);
   const checksumText = await downloadReleaseText(plan.checksumUrl);
-  const expectedChecksum = parseSha256Checksum(checksumText, build.checksumAssetName);
+  const expectedChecksum = parseSha256Checksum(
+    checksumText,
+    build.checksumAssetName
+  );
   const actualChecksum = createHash("sha256").update(Buffer.from(binary)).digest("hex");
-  if (actualChecksum !== expectedChecksum) throw new Error(`Downloaded Norn binary checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`);
-  const tempPath = join(dirname(plan.targetPath), `.norn-upgrade-${process.pid}-${build.assetName}`);
+  if (actualChecksum !== expectedChecksum)
+    throw new Error(
+      `Downloaded Norn binary checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`
+    );
+  const tempPath = join(
+    dirname(plan.targetPath),
+    `.norn-upgrade-${process.pid}-${build.assetName}`
+  );
   try {
     await writeFile(tempPath, binary);
     await chmod(tempPath, 493);
@@ -642,17 +773,24 @@ function githubReleaseDownloadUrl(build, assetName) {
 }
 async function downloadReleaseAsset(url) {
   const response = await fetch(url);
-  if (!response.ok) throw new Error(`Failed to download Norn release asset: ${url} returned ${response.status}`);
+  if (!response.ok)
+    throw new Error(
+      `Failed to download Norn release asset: ${url} returned ${response.status}`
+    );
   return new Uint8Array(await response.arrayBuffer());
 }
 async function downloadReleaseText(url) {
   const response = await fetch(url);
-  if (!response.ok) throw new Error(`Failed to download Norn release metadata: ${url} returned ${response.status}`);
+  if (!response.ok)
+    throw new Error(
+      `Failed to download Norn release metadata: ${url} returned ${response.status}`
+    );
   return response.text();
 }
 function parseSha256Checksum(text, checksumAssetName) {
   const checksum = text.trim().split(/\s+/)[0] ?? "";
-  if (!/^[a-f0-9]{64}$/i.test(checksum)) throw new Error(`Invalid Norn checksum asset: ${checksumAssetName}`);
+  if (!/^[a-f0-9]{64}$/i.test(checksum))
+    throw new Error(`Invalid Norn checksum asset: ${checksumAssetName}`);
   return checksum.toLowerCase();
 }
 function requiredArg(command, args, index, label) {
@@ -661,18 +799,30 @@ function requiredArg(command, args, index, label) {
   return value;
 }
 function assertNoExtraArgs(command, args) {
-  if (args.length > 0) throw new Error(`${command} does not accept CLI arguments: ${args.join(" ")}`);
+  if (args.length > 0)
+    throw new Error(
+      `${command} does not accept CLI arguments: ${args.join(" ")}`
+    );
 }
 function assertKnownFlags(command, args, flags) {
   const allowedFlags = new Set(flags);
   const unsupportedFlags = args.filter((arg) => !allowedFlags.has(arg));
-  if (unsupportedFlags.length > 0) throw new Error(`${command} has unsupported flags or arguments: ${unsupportedFlags.join(" ")}`);
+  if (unsupportedFlags.length > 0)
+    throw new Error(
+      `${command} has unsupported flags or arguments: ${unsupportedFlags.join(" ")}`
+    );
 }
 async function listWorkflows(args) {
   assertKnownFlags("workflows list", args, ["--entrypoints", "--all"]);
   const entrypointsOnly = workflowListEntrypointsOnly(args);
-  const { workflows, isComplete, diagnostics } = await discoverNornProject(process.cwd());
-  writeJson({ workflows: entrypointsOnly ? workflows.filter((workflow) => workflow.isEntrypoint) : workflows, isComplete, diagnostics });
+  const { workflows, isComplete, diagnostics } = await discoverNornProject(
+    process.cwd()
+  );
+  writeJson({
+    workflows: entrypointsOnly ? workflows.filter((workflow) => workflow.isEntrypoint) : workflows,
+    isComplete,
+    diagnostics
+  });
 }
 async function inspectWorkflow(workflowId) {
   writeJson(await inspectNornWorkflow({ cwd: process.cwd(), workflowId }));
@@ -680,25 +830,39 @@ async function inspectWorkflow(workflowId) {
 function workflowListEntrypointsOnly(args) {
   const entrypoints = args.includes("--entrypoints");
   const all = args.includes("--all");
-  if (entrypoints && all) throw new Error("Use either --entrypoints or --all, not both");
+  if (entrypoints && all)
+    throw new Error("Use either --entrypoints or --all, not both");
   return !all;
 }
 async function initProject() {
   const projectRoot = process.cwd();
   const projectPath = resolve(projectRoot, NORN_PROJECT_FILE_NAME);
-  if (await isFile(projectPath)) throw new Error(`Norn project already exists: ${projectPath}`);
+  if (await isFile(projectPath))
+    throw new Error(`Norn project already exists: ${projectPath}`);
   await mkdir(resolve(projectRoot, RUNS_ROOT), { recursive: true });
-  await writeFile(projectPath, `${JSON.stringify({ version: 1, workflows: [], includes: [], config: {} }, null, 2)}
-`, "utf8");
+  await writeFile(
+    projectPath,
+    `${JSON.stringify({ version: 1, workflows: [], includes: [], config: {} }, null, 2)}
+`,
+    "utf8"
+  );
   await ensureGitignoreExcludesRunState(projectRoot);
-  writeJson({ project: { path: projectPath, root: projectRoot, runsRoot: resolve(projectRoot, RUNS_ROOT) } });
+  writeJson({
+    project: {
+      path: projectPath,
+      root: projectRoot,
+      runsRoot: resolve(projectRoot, RUNS_ROOT)
+    }
+  });
 }
 async function listCurrentProjectRuns() {
   const project = await findNornProject(process.cwd());
   return listRuns(project.projectRoot);
 }
 async function inspectProject() {
-  const { project, isComplete, diagnostics } = await discoverNornProject(process.cwd());
+  const { project, isComplete, diagnostics } = await discoverNornProject(
+    process.cwd()
+  );
   writeJson({ project, isComplete, diagnostics });
 }
 async function startRun(workflowId, commandArgs) {
@@ -711,13 +875,33 @@ async function startRun(workflowId, commandArgs) {
   Value.Decode(workflow.args, args);
   const configOverride = input.config;
   const id = randomUUID();
-  const name = generateRunName(new Set((await listRuns(project.projectRoot)).map((run) => run.name)));
+  const name = generateRunName(
+    new Set((await listRuns(project.projectRoot)).map((run) => run.name))
+  );
   const runRoot = resolve(project.projectRoot, RUNS_ROOT, id);
   await mkdir(runRoot, { recursive: true });
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeRunLaunchRequest(runRoot, { version: 2, type: "run", id, name, workflowId, args, configOverride, createdAt });
+  await writeRunLaunchRequest(runRoot, {
+    version: 2,
+    type: "run",
+    id,
+    name,
+    workflowId,
+    args,
+    configOverride,
+    createdAt
+  });
   await startDetachedExecuteRun(id, project.projectRoot);
-  writeJson({ run: startedRunInfo({ id, name, workflow, runRoot, projectRoot: project.projectRoot, createdAt }) });
+  writeJson({
+    run: startedRunInfo({
+      id,
+      name,
+      workflow,
+      runRoot,
+      projectRoot: project.projectRoot,
+      createdAt
+    })
+  });
 }
 async function resumeRun(run, args) {
   assertNoStructuredInputArgs("runs resume", args);
@@ -730,7 +914,14 @@ async function resumeRun(run, args) {
     const runInfo = await getRunInfo(runRoot);
     assertRunVersion(runInfo.version);
     const args2 = await parseResumeArgs(runInfo, input.args);
-    request = { version: 2, type: "resume", id: runInfo.id, requestId: randomUUID(), args: args2, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    request = {
+      version: 2,
+      type: "resume",
+      id: runInfo.id,
+      requestId: randomUUID(),
+      args: args2,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
     await writeRunResumeRequest(runRoot, request);
   } finally {
     await lease.release();
@@ -745,16 +936,33 @@ async function resumeRun(run, args) {
 }
 async function parseResumeArgs(runInfo, args) {
   if (runInfo.status === "interrupted") {
-    if (args === void 0) throw new Error(`Interrupted workflow resume requires args: ${runInfo.name}`);
-    if (!runInfo.currentWorkflowId) throw new Error(`Run has no current workflow: ${runInfo.name}`);
+    if (args === void 0)
+      throw new Error(
+        `Interrupted workflow resume requires args: ${runInfo.name}`
+      );
+    if (!runInfo.currentWorkflowId)
+      throw new Error(`Run has no current workflow: ${runInfo.name}`);
     const project = await loadNornProject(process.cwd());
     const workflow = project.registry.workflowById(runInfo.currentWorkflowId);
-    if (!workflow) throw new Error(`Unknown workflow for resumed run: ${runInfo.currentWorkflowId}`);
-    Value.Decode(workflow.args, mergeInterruptedWorkflowArgs(runInfo.interruption?.args, args, runInfo.interruption?.fields));
+    if (!workflow)
+      throw new Error(
+        `Unknown workflow for resumed run: ${runInfo.currentWorkflowId}`
+      );
+    Value.Decode(
+      workflow.args,
+      mergeInterruptedWorkflowArgs(
+        runInfo.interruption?.args,
+        args,
+        runInfo.interruption?.fields
+      )
+    );
     return args;
   }
   if (runInfo.status === "pendingResume") {
-    if (args !== void 0) throw new Error(`Pending-resume workflows do not accept args: ${runInfo.name}`);
+    if (args !== void 0)
+      throw new Error(
+        `Pending-resume workflows do not accept args: ${runInfo.name}`
+      );
     return void 0;
   }
   throw new Error(`Run must be rolled back before resuming: ${runInfo.name}`);
@@ -769,7 +977,8 @@ async function waitForInactiveRun(projectRoot, run) {
     runRoot ??= await resolveWaitableRunRoot(projectRoot, run);
     try {
       const runInfo = await readRunInspection(runRoot);
-      if (runInfo.status !== "running" || runInfo.health === "unhealthy") return runInfo;
+      if (runInfo.status !== "running" || runInfo.health === "unhealthy")
+        return runInfo;
     } catch (error) {
       if (!isNodeError(error) || error.code !== "ENOENT") throw error;
     }
@@ -780,7 +989,10 @@ async function resolveWaitableRunRoot(sessionCwd, run) {
   try {
     return await resolveRunRoot(sessionCwd, run);
   } catch (error) {
-    for (const candidate of [resolve(sessionCwd, run), resolve(sessionCwd, RUNS_ROOT, run)]) {
+    for (const candidate of [
+      resolve(sessionCwd, run),
+      resolve(sessionCwd, RUNS_ROOT, run)
+    ]) {
       if (await isDirectory(candidate)) return candidate;
     }
     throw error;
@@ -813,31 +1025,55 @@ async function ensureGitignoreExcludesRunState(projectRoot) {
   }
   if (currentText.split(/\r?\n/).includes(runStatePattern)) return;
   const separator = currentText.length === 0 || currentText.endsWith("\n") ? "" : "\n";
-  await writeFile(gitignorePath, `${currentText}${separator}${runStatePattern}
-`, "utf8");
+  await writeFile(
+    gitignorePath,
+    `${currentText}${separator}${runStatePattern}
+`,
+    "utf8"
+  );
 }
 async function executeRun(runId) {
   const abortController = new AbortController();
-  process.once("SIGTERM", () => abortController.abort(new NornRunStoppedError()));
-  process.once("SIGINT", () => abortController.abort(new NornRunStoppedError()));
+  process.once(
+    "SIGTERM",
+    () => abortController.abort(new NornRunStoppedError())
+  );
+  process.once(
+    "SIGINT",
+    () => abortController.abort(new NornRunStoppedError())
+  );
   const location = await findNornProject(process.cwd());
   const runRoot = resolve(location.projectRoot, RUNS_ROOT, runId);
   const request = await readOptionalRunLaunchRequest(runRoot) ?? await readRunResumeRequest(runRoot);
   try {
-    const agentDir = resolveNornAgentDirectory({ home: homedir(), environment: process.env });
+    const agentDir = resolveNornAgentDirectory({
+      home: homedir(),
+      environment: process.env
+    });
     process.chdir(await prepareRunWorkerDirectory(runRoot));
     const project = await loadNornProject(location.projectRoot);
-    const engine = new NornEngine({ cwd: project.projectRoot, agentDir, signal: abortController.signal, gateMode: "pause", config: project.projectConfig });
+    const engine = new NornEngine({
+      cwd: project.projectRoot,
+      agentDir,
+      signal: abortController.signal,
+      gateMode: "pause",
+      config: project.projectConfig
+    });
     engine.registerWorkflows(project.definitions);
     if (request.type === "run") {
       const workflow = project.registry.workflowById(request.workflowId);
       if (!workflow) throw new Error(`Unknown workflow: ${request.workflowId}`);
-      await engine.runWorkflow(workflow, request.args, { id: request.id, name: request.name, configOverride: request.configOverride });
+      await engine.runWorkflow(workflow, request.args, {
+        id: request.id,
+        name: request.name,
+        configOverride: request.configOverride
+      });
     } else {
       await engine.resumeRequestedWorkflow({ runRoot, request });
     }
   } finally {
-    if (request.type === "run") await rm(join(runRoot, "launch-request.json"), { force: true });
+    if (request.type === "run")
+      await rm(join(runRoot, "launch-request.json"), { force: true });
     else await removeResumeRequest({ runRoot, request });
   }
 }
@@ -854,7 +1090,10 @@ async function rollbackRun(run, args) {
   assertNoExtraArgs("runs rollback", args.slice(1));
   const project = await findNornProject(process.cwd());
   const runRoot = await resolveRunRoot(project.projectRoot, run);
-  const engine = new NornEngine({ cwd: project.projectRoot, gateMode: "pause" });
+  const engine = new NornEngine({
+    cwd: project.projectRoot,
+    gateMode: "pause"
+  });
   writeJson({ run: await engine.rollbackRun(runRoot, checkpointId) });
 }
 async function inspectRun(run) {
@@ -874,7 +1113,8 @@ async function deleteRun(run) {
   const project = await findNornProject(process.cwd());
   const runRoot = await resolveRunRoot(project.projectRoot, run);
   const runInfo = await getRunInfo(runRoot);
-  if (runInfo.status === "running") throw new Error(`Stop run before deleting it: ${runInfo.name}`);
+  if (runInfo.status === "running")
+    throw new Error(`Stop run before deleting it: ${runInfo.name}`);
   await rm(runRoot, { recursive: true, force: true });
   return { id: runInfo.id, name: runInfo.name, path: runInfo.path };
 }
@@ -890,7 +1130,8 @@ async function writeRunLogs(run, options) {
   let written = 0;
   while (true) {
     const events = await readRunEvents(runRoot);
-    for (const event of events.slice(written)) process.stdout.write(`${JSON.stringify(event)}
+    for (const event of events.slice(written))
+      process.stdout.write(`${JSON.stringify(event)}
 `);
     written = events.length;
     if (!options.follow) return;
@@ -912,7 +1153,8 @@ async function startDetachedExecuteRun(runId, projectRoot) {
   child.unref();
 }
 function detachedExecuteRunArgs(runId) {
-  if (NORN_BUILD_INFO.kind === "github-release-binary") return ["execute-run", runId];
+  if (NORN_BUILD_INFO.kind === "github-release-binary")
+    return ["execute-run", runId];
   const scriptPath = process.argv[1];
   return scriptPath && isAbsolute(scriptPath) && /\.(?:c?m?js|ts)$/.test(scriptPath) ? [scriptPath, "execute-run", runId] : ["execute-run", runId];
 }
@@ -922,7 +1164,10 @@ function startedRunInfo(input) {
     id: input.id,
     name: input.name,
     path: input.runRoot,
-    paths: { project: input.projectRoot, workspace: join(input.runRoot, "current", "workspace") },
+    paths: {
+      project: input.projectRoot,
+      workspace: join(input.runRoot, "current", "workspace")
+    },
     entrypointWorkflowId: input.workflow.id,
     currentWorkflowId: input.workflow.id,
     status: "running",
@@ -941,7 +1186,9 @@ async function readOptionalRunLaunchRequest(runRoot) {
 }
 async function readRunEvents(runRoot) {
   try {
-    const manifest = JSON.parse(await readFile(join(runRoot, "current", "manifest.json"), "utf8"));
+    const manifest = JSON.parse(
+      await readFile(join(runRoot, "current", "manifest.json"), "utf8")
+    );
     return manifest.events ?? [];
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") return [];
@@ -979,16 +1226,23 @@ function parseResumeRunInput(value) {
   return { args: input.args };
 }
 function parseStructuredInputObject(command, value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${command} reads a JSON object from stdin`);
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${command} reads a JSON object from stdin`);
   return value;
 }
 function assertStructuredInputKeys(command, input, allowedKeys) {
   const allowed = new Set(allowedKeys);
   const unexpected = Object.keys(input).filter((key) => !allowed.has(key));
-  if (unexpected.length > 0) throw new Error(`${command} stdin JSON has unsupported keys: ${unexpected.join(", ")}`);
+  if (unexpected.length > 0)
+    throw new Error(
+      `${command} stdin JSON has unsupported keys: ${unexpected.join(", ")}`
+    );
 }
 function assertNoStructuredInputArgs(command, args) {
-  if (args.length > 0) throw new Error(`${command} reads structured input from stdin, not CLI arguments: ${args.join(" ")}`);
+  if (args.length > 0)
+    throw new Error(
+      `${command} reads structured input from stdin, not CLI arguments: ${args.join(" ")}`
+    );
 }
 function sendSignal(processGroupId, pid, signal) {
   try {