@krapht/ork 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/run-DBUAq-Uu.mjs

@@ -1,1452 +0,0 @@
-import { B as appendRecorder, Dn as endLinksOf, Dt as startRun, Et as walkSummary, Fi as AGENT_DRIVERS, Ii as DRIVER_IDS, J as parseInputPairs, Jn as machineRulesOf, K as createReplay, Kn as gitRulesOf, Mi as readyDriver, Pn as liveStatus, R as openStore, Sn as deliverFollowUp, Sr as renderTemplate, Ti as retiredDriverHint, V as createRecorder, Wr as placeFiles, Xr as inside, Y as resolveInputs, Zn as findFollowUp, ct as createCalls, er as createSignals, ft as DETACHED_ENV, gn as createFollowUps, gr as createFeedback, h as resolveBase, ht as NOT_STARTED, kt as userMessageText, li as beforeOf, ln as sessionDriver, lt as adoptedCalls, mr as runGh, n as resumedOptions, nn as inspectProject, q as replayLoopAnswers, qn as loadProject, qr as runDirOf, rn as git, rt as createRelay, t as createWorkspace, tr as endOf, vn as checkFollowUpsDue, wr as startControl, xi as isClaudeNode, xr as parseTemplate, xt as planNodeSession, z as storePath, zn as templateOf } from "./src-8cOPOgrT.mjs";
-import { _ as clearOutputFiles, a as builtinExecutors, b as runScrubber, d as maskedEnv, f as maskedNamesOfRun, i as onPath, l as clearStateFiles, m as sessionEnv, n as missingProgramMessage, r as missingPrograms, t as envProblems, v as namedMcpEntries, y as resultOf } from "./src-I_RyKu6_.mjs";
-import { n as newRunId } from "./find-BTikxc54.mjs";
-import { h as nodeSession, n as ORK_VERSION } from "./__build_info__-D6mXC4cD.mjs";
-import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { d as formatEvent, f as formatRunEvent, m as createTerminalHuman, p as callsShown, t as attachRun } from "./attach-CEGbRg1D.mjs";
-import { a as refusedBuiltin, s as workflowArg, t as WORKFLOW_DIR } from "./workflows-DHHi-APg.mjs";
-import { a as formatReport, c as checksHere, d as runReadyDriver, f as unfitLines, i as walkLoaded, l as chooseReadyDriver, o as warningLines, s as budgetWarningLines, t as loadWorkflow, u as overrideRefusal } from "./validate-BxayjjkV.mjs";
-import { a as createView, o as styler } from "./verdict-CMvPCpWC.mjs";
-import { i as runLimits, r as limitsRefusal, t as chatNotice } from "./limits-VQqsBoQk.mjs";
-import path from "node:path";
-import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
-import { homedir } from "node:os";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { defineCommand } from "citty";
-// ../core/src/follow-ups/take.ts
-const put = (rows, f, run, at) => {
-	const next = {
-		...f,
-		takenBy: run,
-		updatedAt: at
-	};
-	rows.putFollowUp(next);
-	return next;
-};
-/**
-* Why `f` is held by the run that took it, as the end of `taken by run <id>,
-* <note>`; `undefined` when it is free. A run the store does not know counts as
-* live while the mark is recent, so a run that fails its preflight frees its
-* follow-ups when the window ends.
-*/
-const heldNote = (f, isLive, now) => {
-	if (f.takenBy === void 0) return void 0;
-	const live = isLive(f.takenBy);
-	if (live !== void 0) return live ? "still running" : void 0;
-	return now - Date.parse(f.updatedAt) < 12e4 ? "not started yet; free in under 2 minutes" : void 0;
-};
-/** Whether another run holds `f`: it is not free to take again. */
-const heldByLive = (f, run, isLive, now) => f.takenBy !== run && heldNote(f, isLive, now) !== void 0;
-/**
-* The project's due `agent` follow-ups no live run has taken (`ids`), and those
-* a live run holds (`held`), so a second `--follow-ups due` doesn't take them
-* twice.
-*/
-const availableDue = (rows, project, isLive, run = "", now = () => (/* @__PURE__ */ new Date()).toISOString()) => {
-	const at = Date.parse(now());
-	const due = rows.followUps(project).filter((f) => f.for === "agent" && f.status === "due");
-	return {
-		ids: due.filter((f) => !heldByLive(f, run, isLive, at)).map((f) => f.id),
-		held: due.filter((f) => heldByLive(f, run, isLive, at))
-	};
-};
-/**
-* `ork run start --follow-ups <ids>`: the open `agent` follow-ups among `ids`
-* become `run`'s brief; why each other id wasn't taken. One a live run took is
-* refused; one a finished, failed or crashed run took can be taken again.
-*/
-const takeFollowUps = (rows, taking, now = () => (/* @__PURE__ */ new Date()).toISOString()) => {
-	const taken = [];
-	const refused = [];
-	const at = Date.parse(now());
-	for (const id of taking.ids) {
-		const f = rows.followUp(taking.project, id);
-		if (f === void 0) refused.push(`${id}: there is no such follow-up`);
-		else if (f.for !== "agent") refused.push(`${id}: it is for ${f.for}`);
-		else if (f.status === "done" || f.status === "dropped") refused.push(`${id}: it is ${f.status}`);
-		else {
-			const note = f.takenBy === taking.run ? void 0 : heldNote(f, taking.isLive, at);
-			if (note === void 0) taken.push(put(rows, f, taking.run, now()));
-			else refused.push(`${id}: taken by run ${f.takenBy}, ${note}`);
-		}
-	}
-	return {
-		taken,
-		refused
-	};
-};
-/** `ORK_HEAVY_SLOTS` as a count; anything but a positive integer is the default. */
-const heavySlots = (env = process.env) => {
-	const count = Number(env["ORK_HEAVY_SLOTS"]);
-	return Number.isInteger(count) && count > 0 ? count : 2;
-};
-const codeOf = (error) => error instanceof Error && "code" in error ? error.code : void 0;
-const alive = (pid) => {
-	if (pid <= 0) return false;
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return codeOf(error) === "EPERM";
-	}
-};
-const read = (file) => {
-	try {
-		const value = JSON.parse(readFileSync(file, "utf8"));
-		if (typeof value !== "object" || value === null || !("id" in value && "run" in value && "node" in value && "pid" in value)) return;
-		const { id, run, node, pid } = value;
-		return typeof id === "string" && typeof run === "string" && typeof node === "string" && typeof pid === "number" ? {
-			id,
-			run,
-			node,
-			pid
-		} : void 0;
-	} catch {
-		return;
-	}
-};
-const listed = (dir) => {
-	try {
-		return readdirSync(dir).filter((name) => name.endsWith(".json")).toSorted();
-	} catch {
-		return [];
-	}
-};
-/** Written whole (a rename), so no reader sees half a record. */
-const writeWhole = (file, record) => {
-	const draft = `${file}.${record.id}.tmp`;
-	writeFileSync(draft, JSON.stringify(record), { mode: 384 });
-	renameSync(draft, file);
-};
-/** Deletes a record if it is still `id`'s. */
-const dropIf = (file, id) => {
-	if (read(file)?.id === id) rmSync(file, { force: true });
-};
-let tickets = 0;
-/** A ticket's name: sorted by when it was queued. */
-const ticketName = (id) => `${String(Date.now()).padStart(15, "0")}-${String(process.pid).padStart(8, "0")}-${String(tickets += 1).padStart(6, "0")}-${id}.json`;
-/** The ledger in `dir`, with `slots` slots. */
-const fileSlotLedger = (options) => {
-	const { dir, slots } = options;
-	const queue = path.join(dir, "queue");
-	const slotFile = (index) => path.join(dir, `slot-${String(index)}.json`);
-	const records = () => Array.from({ length: slots }, (_, index) => {
-		const file = slotFile(index);
-		return {
-			file,
-			held: read(file)
-		};
-	});
-	const holders = () => records().flatMap(({ held }) => held === void 0 ? [] : [held]);
-	const sweep = () => {
-		const gone = [];
-		for (const file of [...records().map((record) => record.file), ...listed(queue).map((name) => path.join(queue, name))]) {
-			const held = read(file);
-			if (held === void 0 || alive(held.pid)) continue;
-			dropIf(file, held.id);
-			gone.push(held);
-		}
-		return gone;
-	};
-	/** Links `draft` into a free slot; true when it got one. */
-	const tryTake = (draft) => {
-		for (const { file, held } of records()) {
-			if (held !== void 0) continue;
-			try {
-				linkSync(draft, file);
-				return true;
-			} catch (error) {
-				if (codeOf(error) !== "EEXIST") throw error;
-			}
-		}
-		return false;
-	};
-	const take = async (holder, { signal, onWait }) => {
-		mkdirSync(queue, {
-			recursive: true,
-			mode: 448
-		});
-		const record = {
-			id: randomUUID(),
-			...holder
-		};
-		const ticket = path.join(queue, ticketName(record.id));
-		writeWhole(ticket, record);
-		let told = false;
-		try {
-			for (;;) {
-				if (signal.aborted) return null;
-				sweep();
-				const free = records().filter(({ held }) => held === void 0).length;
-				if (listed(queue).indexOf(path.basename(ticket)) < free && tryTake(ticket)) {
-					const release = () => {
-						for (const { file, held } of records()) if (held?.id === record.id) dropIf(file, record.id);
-					};
-					return release;
-				}
-				if (!told) {
-					told = true;
-					onWait?.(holders());
-				}
-				try {
-					await setTimeout$1(options.pollMs ?? 500, void 0, { signal });
-				} catch {
-					return null;
-				}
-			}
-		} finally {
-			rmSync(ticket, { force: true });
-		}
-	};
-	return {
-		take,
-		holders,
-		sweep
-	};
-};
-/** The machine's ledger: `~/.ork/slots`, `ORK_HEAVY_SLOTS` slots. */
-const machineSlotLedger = (options = {}) => fileSlotLedger({
-	dir: path.join(options.home ?? homedir(), ".ork", "slots"),
-	slots: heavySlots(options.env)
-});
-// ../core/src/machine/lock-ledger.ts
-/**
-* @file The machine-wide ledger of named locks (RFC-016): one run at a time
-*   holds a lock, such as the branch it integrates into. Each lock is a slot
-*   ledger with one slot (ADR-080's mechanism: hard-link records, tickets first
-*   come, first served, a dead holder's record swept), in its own folder under
-*   `~/.ork/locks`, named by a hash of its key. A `branch:<name>` lock is keyed
-*   by the origin's URL (without its user part) and the branch, so clones of
-*   one remote share it; any other name by the project's root and the name.
-*/
-const BRANCH = "branch:";
-/**
-* A remote's URL as a key: no scheme, no user part (where a token may sit), no
-* `.git`; `git@host:path` and `https://host/path` read the same.
-*/
-const remoteKey = (url) => {
-	const trimmed = url.trim().replace(/\/+$/u, "").replace(/\.git$/u, "");
-	const scheme = /^[a-z][\d+.a-z-]*:\/\//iu.exec(trimmed);
-	if (scheme !== null) return trimmed.slice(scheme[0].length).replace(/^[^/@]*@/u, "");
-	const scp = /^(?:[^/@]+@)?([^/:]+):(?!\/)(.*)$/u.exec(trimmed);
-	return scp === null ? trimmed : `${scp[1] ?? ""}/${scp[2] ?? ""}`;
-};
-/** The origin's URL as a key, or `undefined` when the repo has no origin. */
-const originOf = async (repo) => {
-	const result = await git(repo, [
-		"remote",
-		"get-url",
-		"origin"
-	]);
-	const url = result.stdout.trim();
-	return result.code === 0 && url !== "" ? remoteKey(url) : void 0;
-};
-/**
-* A lock's key: `branch:<origin>#<branch>` for a branch lock (the repo's own
-* folder when it has no origin), else `<project>#<name>`.
-*/
-const lockKey = async (name, place) => name.startsWith(BRANCH) ? `${BRANCH}${await originOf(place.repo) ?? path.resolve(place.repo)}#${name.slice(7)}` : `${path.resolve(place.project)}#${name}`;
-/**
-* Whether a lock's key falls back to the repo's own path: a `branch:` lock in a
-* repo with no origin, which no other clone shares.
-*/
-const lockIsLocal = async (name, place) => name.startsWith(BRANCH) && await originOf(place.repo) === void 0;
-/** A key's folder name: a hash, so no URL or path is written as a name. */
-const folderOf = (key) => createHash("sha256").update(key).digest("hex").slice(0, 32);
-/** The locks in `dir`, for a run in `repo` of `project`. */
-const fileLockLedgers = (options) => ({ of: async (name) => fileSlotLedger({
-	dir: path.join(options.dir, folderOf(await lockKey(name, options))),
-	slots: 1,
-	...options.pollMs === void 0 ? {} : { pollMs: options.pollMs }
-}) });
-/** Where the machine's locks are: `~/.ork/locks`. */
-const machineLocksDir = (home = homedir()) => path.join(home, ".ork", "locks");
-/** The machine's locks (in `home`'s), for a run in `repo` of `project`. */
-const machineLockLedgers = (repo, project, home) => fileLockLedgers({
-	repo,
-	project,
-	dir: machineLocksDir(home)
-});
-/** Drops every lock's records and tickets whose process is gone; returns them. */
-const sweepLocks = (dir) => {
-	let folders;
-	try {
-		folders = readdirSync(dir);
-	} catch {
-		return [];
-	}
-	return folders.flatMap((folder) => fileSlotLedger({
-		dir: path.join(dir, folder),
-		slots: 1
-	}).sweep());
-};
-// src/runs/chat.ts
-/**
-* @file `ork chat`'s two paths. A node of a live run gets the message through
-*   the store and the run's socket, and the run's bus pushes it into the node's
-*   session (specs/messaging.md#chat; `tellLiveRun` and `nodeSession` are in
-*   core). A node of a finished run gets it by resuming its last Claude session
-*   where it ran, as the run's sessions were set up (ADR-065), and the exchange
-*   is added to the run's record.
-*/
-/**
-* The declared node a spawned worker or an item of a fanned node is an instance
-* of.
-*/
-const instanceOf = (nodes, id) => id in nodes ? void 0 : templateOf(id, new Set(Object.keys(nodes)));
-/** The run's sessions loaded the machine's Claude setup, so this one does. */
-const machineClaudeOf = (events) => events.some(({ event }) => event.type === "run.started" && event.settings?.machineClaude === true) ? { machineClaude: true } : {};
-/**
-* Resumes a finished node's last session with the user's message, prints the
-* session, and adds it to the run's record. Returns why it could not.
-*/
-const resumeChat = async (options) => {
-	const { store, run, node } = options;
-	const events = store.events(run.id, 0);
-	const { session, outputs } = nodeSession(events, node);
-	if (!session.known) return `${node} is not a node of run ${run.id}.`;
-	if (!session.chattable) return `${node} is not a leader or worker; only they have sessions to talk to.`;
-	if (session.sessionId === void 0) return `${node} has no Claude session to resume in run ${run.id}.`;
-	const cwd = session.cwd ?? session.checkout?.path;
-	if (cwd === void 0 || !existsSync(cwd)) return `${node}'s session ran in ${cwd ?? "a folder Ork did not record"}, which is gone (a merged worktree is removed), so it cannot be resumed.`;
-	const { workflow, place, workflowDir } = loadWorkflow(run.file, path.dirname(run.file), void 0, store.projects());
-	if (workflow === null) return `The workflow ${run.file} is gone or no longer valid.`;
-	const notice = chatNotice(store, place, options.home);
-	if (notice !== null) options.out(notice);
-	const runDir = runDirOf(place, run.id);
-	const template = instanceOf(workflow.nodes, node);
-	const plan = planNodeSession(workflow, node, {
-		cwd,
-		inputs: {},
-		outputs,
-		inPlace: session.checkout === void 0,
-		workflowDir,
-		projectRoot: run.project,
-		orkDir: place.dir,
-		pluginDir: path.join(runDir, "plugins", node),
-		...options.budgetLeftUsd === void 0 ? {} : { budgetLeftUsd: options.budgetLeftUsd },
-		...session.checkout === void 0 ? {} : { checkout: session.checkout },
-		...template === void 0 ? {} : { template }
-	});
-	if (!plan.ok) return plan.error;
-	const declared = workflow.nodes[template ?? node];
-	const itemModel = declared !== void 0 && isClaudeNode(declared) && declared.model?.includes("{{") === true ? session.model : void 0;
-	const servers = namedMcpEntries(run.project, plan.mcp);
-	if (!servers.ok) return servers.error;
-	let driver = options.driver ?? session.driver ?? plan.driver;
-	if (driver === void 0) {
-		const ready = readyDriver(await (options.driverChecks ?? checksHere)());
-		if (!ready.ok) return ["No agent driver is ready here.", ...ready.hints].join(" ");
-		driver = ready.driver;
-	}
-	const record = appendRecorder(store, run.id, runDir);
-	record({
-		type: "user.message",
-		node,
-		body: options.body,
-		delivered: "resumed"
-	});
-	const started = (await options.runtime(driver, placeFiles(place).runs)).start({
-		...plan.spec,
-		...itemModel === void 0 ? {} : { model: itemModel },
-		...servers.value,
-		resume: session.sessionId,
-		prompt: options.body,
-		...machineClaudeOf(events)
-	}, { human: options.human });
-	if (options.signal?.aborted === true) started.interrupt();
-	options.signal?.addEventListener("abort", () => {
-		started.interrupt();
-	}, { once: true });
-	const tools = /* @__PURE__ */ new Map();
-	let failure = null;
-	for await (const event of started.events) {
-		record({
-			type: "node.event",
-			id: node,
-			event
-		});
-		for (const line of formatEvent(node, event, tools)) options.out(line);
-		if (event.type === "session.finished" && event.outcome.subtype === "error_driver") failure = event.outcome.errors.join("; ");
-	}
-	return failure;
-};
-// src/run/node-notes.ts
-/**
-* @file What a run of one node (`ork run --node`) leaves out, said before its
-*   session starts: the messages, steps and `forEach` it does not run. A node
-*   with `forEach` (RFC-013) runs once with no item when it has `items`, and is
-*   refused when it has `from`, as the node that reports its list is not run.
-*   And, after it, its run summary: how the node ended
-*   (specs/runtime/session-ends.md).
-*/
-/** A warning line, as the run prints it. */
-const noteLines = (lines) => lines.map((line) => `${style(["yellow", "bold"], "warning")} ${line}`);
-/** Why a node can't run alone, or what a run of it leaves out. */
-const oneNodeNotes = (workflow, id) => {
-	const node = workflow.nodes[id];
-	if (node === void 0) return { warnings: [] };
-	const each = "forEach" in node ? node.forEach : void 0;
-	if (each !== void 0 && "from" in each) return {
-		error: `\`${id}\` runs once for each item of ${each.from}, a list another node reports, and a run of one node does not run that node; run the whole workflow, or give it \`items\` of its own`,
-		warnings: []
-	};
-	const steps = [...beforeOf(node, workflow.defaults) === void 0 ? [] : ["before"], ..."verify" in node && node.verify !== void 0 ? ["verify"] : []];
-	return { warnings: [
-		..."notify" in node && node.notify ? [`${id}'s notify: does nothing here: a run of one node has no message bus.`] : [],
-		...each === void 0 ? [] : [`${id}'s forEach: does not fan out in a run of one node: it runs once, with no item.`],
-		...steps.map((step) => `${id}'s ${step}: does not run in a run of one node.`)
-	] };
-};
-/** The `node.finished` fields that say how it ended: its error and its end. */
-const endedFields = (result) => ({
-	...result.error === void 0 ? {} : { error: result.error },
-	end: endOf(result)
-});
-/** The one-node run's result, its reason the node's message. */
-const oneNodeResult = (runId, id, result, ok) => {
-	const costUsd = result.usage?.costUsd ?? 0;
-	return {
-		runId,
-		status: ok ? "succeeded" : "failed",
-		costUsd,
-		nodes: [{
-			id,
-			runs: 1,
-			ok: result.ok,
-			output: result.output,
-			costUsd,
-			...endedFields(result)
-		}],
-		reasons: result.error === void 0 ? [] : [`${id}: ${result.error}`],
-		worktrees: [],
-		skipped: 0,
-		failuresHandled: 0
-	};
-};
-// src/follow-ups/context.ts
-/**
-* @file What `ork follow-ups` and a run share: the project's `followUps` rule,
-*   the sink a run hands its sessions' `follow_up` tool, the due check that
-*   runs before every call (a `gh` that fails only warns), and the follow-ups
-*   `ork run --follow-ups` takes as a run's brief.
-*/
-/** The project's `followUps` rule, when it sets one. */
-const followUpsRule = (place) => loadProject(place.root, placeFiles(place).rules).project?.followUps;
-/** What a run hands its sessions: each `follow_up` call, kept as the rule says. */
-const followUpSink = (options) => (input, at) => {
-	const rule = followUpsRule(options.place);
-	return deliverFollowUp(input, {
-		store: options.store,
-		project: options.place.root,
-		worktree: at.cwd,
-		...rule === void 0 ? {} : { rule },
-		...options.home === void 0 ? {} : { home: options.home },
-		...options.gh === void 0 ? {} : { gh: options.gh }
-	});
-};
-/** Gh's own words when it has no login. */
-const SIGNED_OUT = /not logged in|gh auth login/iu;
-/**
-* A gh error's first line, without a trailing period, so the notice is one
-* line.
-*/
-const oneLine = (error) => (error.trim().split("\n")[0] ?? "").trim().replace(/\.$/u, "");
-/**
-* Moves the project's follow-ups whose time has come to due, as every `ork
-* follow-ups` call does first. `gh` failing only warns, through `warn`: one
-* line per call, however many refs failed.
-*/
-const refreshDue = async (store, project, warn, gh = runGh) => {
-	try {
-		const checked = await checkFollowUpsDue({
-			rows: store,
-			project,
-			gh
-		});
-		const [first] = checked.errors;
-		if (first !== void 0) warn(checked.errors.some((error) => SIGNED_OUT.test(error)) ? "Can't check PRs: `gh` isn't signed in. After-merge follow-ups stay waiting; run `gh auth login` yourself." : `Can't check PRs: ${oneLine(first)}. After-merge follow-ups stay waiting.`);
-		return checked.due;
-	} catch (error) {
-		warn(`couldn't check what is due: ${error instanceof Error ? error.message : String(error)}`);
-		return [];
-	}
-};
-/** The text a run starts from when it takes these follow-ups as its brief. */
-const briefOf = (followUps) => ["Do these follow-ups left by earlier changes:", ...followUps.flatMap((f) => [
-	"",
-	`## ${f.title} (${f.id})`,
-	...f.body === "" ? [] : [f.body],
-	...f.where.length === 0 ? [] : [`Files: ${f.where.join(", ")}`]
-])].join("\n");
-/**
-* Whether a run is going, as `ork ps` decides: running with its process alive.
-* `undefined` for a run the store does not know yet: core holds its mark for a
-* short while, as the run may be about to begin.
-*/
-const runIsLive = (store) => (runId) => {
-	const [run] = store.lookup(runId);
-	return run === void 0 ? void 0 : liveStatus(run) === "running";
-};
-const nothing = () => {};
-/**
-* The follow-ups `ids` (or prefixes) name, when every one can be taken as a
-* brief; nothing is written, so a run that fails to start leaves them alone.
-*/
-const checkTakeable = (store, project, ids) => {
-	const full = [];
-	const lines = [];
-	for (const id of ids) {
-		const found = findFollowUp(store, project, id);
-		if (found.ok) full.push(found.followUp.id);
-		else lines.push(found.error);
-	}
-	const { taken, refused } = takeFollowUps({
-		followUp: (p, id) => store.followUp(p, id),
-		followUps: (p) => store.followUps(p),
-		putFollowUp: nothing
-	}, {
-		project,
-		run: "",
-		ids: full,
-		isLive: runIsLive(store)
-	});
-	const all = [...lines, ...refused];
-	return all.length > 0 ? {
-		ok: false,
-		lines: all.map((line) => `--follow-ups: ${line}`)
-	} : {
-		ok: true,
-		followUps: taken
-	};
-};
-// src/run/origin.ts
-/**
-* @file Where a run's feedback comes from, beyond what its events say: Ork's
-*   version (bound from the CLI's `package.json`) and the workflow file's
-*   content hash; and the feedback and `follow_up` ports of the one node `ork
-*   run --node` runs.
-*/
-/** Ork's version and the workflow's hash, for the run's feedback records. */
-/** The Ork version a run records in `run.started` and `run.resumed`. */
-const ORK_RUN_VERSION = ORK_VERSION;
-const feedbackOrigin = (workflowFile) => {
-	const origin = { version: ORK_VERSION };
-	try {
-		origin.workflowHash = createHash("sha256").update(readFileSync(workflowFile)).digest("hex").slice(0, 12);
-	} catch {}
-	return origin;
-};
-/**
-* Node `id`'s feedback port (with a graph) and `follow_up` port, kept as the
-* project's rule says; both mask the values of what its run masks.
-*/
-const nodeReports = (options, { workflow, graph, record }) => {
-	const { place, id } = options;
-	const scrub = runScrubber(maskedNamesOfRun(workflow, place, options.store.projects()), process.env);
-	const sink = followUpSink(options);
-	return {
-		...graph === null ? {} : { feedback: createFeedback({
-			graph,
-			onEvent: record,
-			scrub
-		}).port(id) },
-		followUps: createFollowUps({
-			runId: options.runId,
-			sink,
-			scrub
-		}).port(id, options.cwd)
-	};
-};
-// src/run/node.ts
-/**
-* @file `ork run --node`: checks a workflow and its inputs, plans one Claude
-*   node's session, streams it to the terminal, and records it as a run of one
-*   node.
-*/
-const succeeded = (outcome) => outcome?.report !== null && outcome?.report !== void 0 && outcome.report.status !== "fail";
-/**
-* Runs one Claude node of a workflow on its own: checks the workflow and the
-* inputs, plans the session, and streams it to the terminal.
-*/
-const runNode = async (options) => {
-	const failed = (lines) => {
-		for (const line of lines) options.err(line);
-		return {
-			exitCode: 1,
-			outcome: null
-		};
-	};
-	const { report, workflow, graph, place, workflowDir } = loadWorkflow(options.file, options.cwd, options.home, options.store.projects());
-	if (workflow === null) return failed(formatReport(report));
-	for (const line of warningLines(report)) options.err(line);
-	const pairs = parseInputPairs(options.inputs);
-	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
-	const inputs = resolveInputs(workflow, pairs.raw);
-	if (!inputs.ok) return failed(inputs.errors);
-	const notes = oneNodeNotes(workflow, options.nodeId);
-	if (notes.error !== void 0) return failed([notes.error]);
-	const limits = runLimits(options.store, place, options.home);
-	const refused = limitsRefusal(limits, workflow);
-	if (refused.length > 0) return failed(refused);
-	const left = limits.now().leftUsd;
-	const projectRoot = place.root;
-	const runId = options.runId ?? newRunId(options.store, "node-");
-	const runDir = runDirOf(place, runId);
-	const cwd = inside(projectRoot, options.cwd) ? options.cwd : projectRoot;
-	const plan = planNodeSession(workflow, options.nodeId, {
-		...left === void 0 ? {} : { budgetLeftUsd: left },
-		cwd,
-		inputs: inputs.inputs,
-		inPlace: options.inPlace,
-		workflowDir,
-		projectRoot,
-		orkDir: place.dir,
-		pluginDir: path.join(runDir, "plugins", options.nodeId)
-	});
-	if (!plan.ok) return failed([plan.error]);
-	const servers = namedMcpEntries(projectRoot, plan.mcp);
-	if (!servers.ok) return failed([servers.error]);
-	const named = sessionDriver({
-		override: options.driver,
-		named: plan.driver,
-		pinned: plan.pinned
-	});
-	if (options.driver !== void 0 && named === options.driver) {
-		const refusal = await overrideRefusal(options.driver, options.driverChecks);
-		if (refusal.length > 0) return failed(refusal);
-	}
-	const ready = named === void 0 ? chooseReadyDriver([options.nodeId], true, await (options.driverChecks ?? checksHere)()) : null;
-	if (ready?.ok === false) return failed(ready.lines);
-	if (ready?.line !== void 0) options.err(ready.line);
-	const driver = named ?? ready?.driver;
-	if (driver === void 0) return failed(["No agent driver is ready here."]);
-	const only = {
-		override: driver,
-		only: options.nodeId
-	};
-	const unfit = unfitLines(workflow, options.drivers, only);
-	if (unfit.length > 0) return failed(unfit);
-	const warnings = [
-		...budgetWarningLines(workflow, options.drivers, only),
-		...notes.warnings,
-		...plan.warnings
-	];
-	for (const line of noteLines(warnings)) options.err(line);
-	const id = options.nodeId;
-	const recorder = createRecorder(options.store, {
-		id: runId,
-		workflow: workflow.name,
-		file: path.resolve(options.cwd, options.file),
-		project: projectRoot
-	}, runDir);
-	const started = Promise.withResolvers();
-	const control = await startControl({
-		store: options.store,
-		runId,
-		emit: (event) => {
-			record(event);
-		},
-		onStop: () => {
-			started.promise.then((session) => session.interrupt());
-		},
-		onMessage: (node, body) => {
-			if (node !== id) return;
-			(async () => {
-				(await started.promise).send(userMessageText(body));
-				record({
-					type: "user.message",
-					node,
-					body,
-					delivered: "now"
-				});
-			})();
-		},
-		...options.human === void 0 ? {} : { local: options.human },
-		...options.home === void 0 ? {} : { home: options.home }
-	});
-	const signals = createSignals(feedbackOrigin(path.resolve(options.cwd, options.file)));
-	const view = createView();
-	const record = (raw) => {
-		for (const event of signals(raw)) {
-			control.publish(recorder(event));
-			if (event.type === "feedback.recorded" && !options.json) for (const line of formatRunEvent(event, id.length, /* @__PURE__ */ new Map(), false, options.verbose, view)) options.out(line);
-		}
-	};
-	const nodeType = workflow.nodes[id]?.type ?? "agent.worker";
-	record({
-		type: "run.started",
-		runId,
-		workflow: workflow.name,
-		entries: [id],
-		nodes: [{
-			id,
-			type: nodeType
-		}],
-		...options.machineClaude === true ? { settings: { machineClaude: true } } : {}
-	});
-	record({
-		type: "node.started",
-		id,
-		nodeType,
-		round: 1
-	});
-	const runtime = await options.runtime(driver, placeFiles(place).runs);
-	if (options.machineClaude === true) plan.spec.machineClaude = true;
-	const session = runtime.start({
-		...plan.spec,
-		...servers.value
-	}, {
-		human: control.human,
-		...nodeReports({
-			...options,
-			place,
-			runId,
-			id,
-			cwd
-		}, {
-			workflow,
-			graph,
-			record
-		})
-	});
-	started.resolve(session);
-	options.onSession?.(session);
-	const tools = /* @__PURE__ */ new Map();
-	let outcome = null;
-	for await (const event of session.events) {
-		record({
-			type: "node.event",
-			id,
-			event
-		});
-		if (event.type === "session.finished") outcome = event.outcome;
-		if (options.json) options.out(JSON.stringify(event));
-		else for (const line of formatEvent(options.nodeId, event, tools, options.verbose, view)) options.out(line);
-	}
-	const result = resultOf(outcome);
-	record({
-		type: "node.finished",
-		id,
-		round: 1,
-		ok: result.ok,
-		output: result.output,
-		...result.usage === void 0 ? {} : { usage: result.usage },
-		...endedFields(result)
-	});
-	record({
-		type: "run.finished",
-		result: oneNodeResult(runId, id, result, succeeded(outcome))
-	});
-	await control.close();
-	return {
-		exitCode: succeeded(outcome) ? 0 : 1,
-		outcome
-	};
-};
-/** Every value of a repeatable flag: `--input a=1 --input=b=2`. */
-// src/run/show-calls.ts
-/**
-* @file A foreground caller's terminal shows the runs it calls (ADR-081): each
-*   `call.started` attaches to the called run under its call node, at any
-*   depth, and asks its decisions when a person is at the terminal. Once the
-*   caller has ended, following stops for a called run that still runs; one the
-*   caller stopped gets a moment to end first.
-*/
-/** How long a called run the caller stopped is followed while it stops. */
-const STOP_GRACE_MS = 5e3;
-const running = (store, id) => {
-	const [record] = store.lookup(id);
-	return record !== void 0 && liveStatus(record) === "running";
-};
-const showCalls = (options) => {
-	const { store, showCalls: show } = options;
-	const shown = [];
-	return {
-		/** Attaches to the run a `call.started` of the caller names. */
-		onEvent: (event) => {
-			if (event.type !== "call.started" || show === void 0 || options.json) return;
-			const stop = new AbortController();
-			const done = attachRun(store, event.run, options.out, {
-				basePath: [event.node],
-				signal: stop.signal,
-				...show.ask === void 0 ? { hintNoTerminal: true } : { human: show.ask },
-				...options.home === void 0 ? {} : { home: options.home }
-			}).catch((error) => {
-				options.err(`run ${event.run} could not be shown here: ${error instanceof Error ? error.message : String(error)}`);
-			});
-			shown.push({
-				run: event.run,
-				stop,
-				done
-			});
-		},
-		/**
-		* The caller has ended `status`: stops following the called runs still
-		* running, at once, or after a moment when the caller stopped them, and
-		* names those that still run.
-		*/
-		end: async (status) => {
-			const stopped = status === "interrupted" || status === "timed_out";
-			const timers = shown.filter(({ run }) => running(store, run)).map(({ stop }) => setTimeout(() => {
-				stop.abort();
-			}, stopped ? STOP_GRACE_MS : 0));
-			await Promise.all(shown.map(({ done }) => done));
-			for (const timer of timers) clearTimeout(timer);
-			const say = styler(createView().term);
-			for (const { run } of shown.filter(({ run: id }) => running(store, id))) options.out(say("dim", `↳ run ${run} still running · ork attach ${run}`));
-		}
-	};
-};
-// src/run/calls.ts
-/**
-* @file What a run needs to reach other runs: its port for `workflow.call`
-*   nodes (RFC-004), its relay when links are on (RFC-003), and the budget a
-*   caller has capped it to. A called run being resumed keeps its caller and
-*   its cap, which the run recorded, and a run's called runs load the machine's
-*   Claude setup when it does (ADR-065).
-*/
-const callPorts = (options) => {
-	const { graph, store, runId, home, human, runtime, out } = options;
-	const linksOff = graph.workflow.rules?.links === "off";
-	const cap = options.budgetCap ?? options.resume?.settings.budgetCap;
-	const calledBy = options.calledBy ?? options.resume?.settings.calledBy;
-	const baseRef = options.baseRef ?? options.resume?.settings.baseRef;
-	const trigger = options.trigger ?? options.resume?.settings.trigger;
-	const untrusted = options.untrusted ?? options.resume?.settings.untrusted;
-	const machineClaude = options.machineClaude ?? options.resume?.settings.machineClaude ?? false;
-	const shown = showCalls(options);
-	const own = graph.workflow.limits?.budgetUsd;
-	const budgetUsd = cap === void 0 ? own : Math.min(cap, own ?? Number.POSITIVE_INFINITY);
-	return {
-		graph: {
-			...graph,
-			workflow: {
-				...graph.workflow,
-				limits: {
-					...graph.workflow.limits,
-					...budgetUsd === void 0 ? {} : { budgetUsd }
-				}
-			}
-		},
-		calls: createCalls({
-			store,
-			runId,
-			place: options.place,
-			emit: (event) => {
-				options.emit(event);
-				shown.onEvent(event);
-			},
-			home,
-			adopt: adoptedCalls(store, runId),
-			newId: () => newRunId(store),
-			machineClaude,
-			detach: options.detach,
-			env: maskedEnv(maskedNamesOfRun(graph.workflow, options.place, store.projects())),
-			resumeSession: (run, node, body, signal) => {
-				const { blocked, leftUsd } = runLimits(store, options.place, home).now();
-				return blocked === void 0 ? resumeChat({
-					store,
-					run,
-					node,
-					body,
-					runtime,
-					human,
-					out,
-					signal,
-					...home === void 0 ? {} : { home },
-					...leftUsd === void 0 ? {} : { budgetLeftUsd: leftUsd }
-				}) : Promise.resolve(`${NOT_STARTED}${blocked}.`);
-			}
-		}),
-		shown,
-		followUps: followUpSink({
-			store,
-			place: options.place,
-			home,
-			gh: options.gh
-		}),
-		...linksOff ? {} : { relay: createRelay({
-			store,
-			runId,
-			home,
-			human
-		}) },
-		settings: {
-			...linksOff ? { links: "off" } : {},
-			...cap === void 0 ? {} : { budgetCap: cap },
-			...calledBy === void 0 ? {} : { calledBy },
-			...baseRef === void 0 ? {} : { baseRef },
-			...trigger === void 0 ? {} : { trigger },
-			...untrusted === void 0 ? {} : { untrusted },
-			...machineClaude ? { machineClaude } : {}
-		}
-	};
-};
-// src/run/live-handlers.ts
-/**
-* Takes what is on its way before the run ends: with no socket, a program's
-* message may not have been seen yet. Each command waits on `started`, so
-* waiting on it too lets them all land first.
-*/
-const takeLastCommands = (control, started) => async () => {
-	control.check();
-	await started;
-};
-/** `ork pause`, `ork continue` and `ork stop --node`, on the run as it is. */
-const liveControl = (live) => (command, node) => {
-	const { handle } = live;
-	if (handle === void 0) return false;
-	if (command === "pause") return handle.pause(node);
-	if (command === "continue") return handle.proceed(node);
-	return node !== void 0 && handle.stopNode(node);
-};
-const liveHandlers = (started) => {
-	const when = (act) => {
-		started.then(act);
-	};
-	return {
-		onStop: () => {
-			when((run) => {
-				run.interrupt();
-			});
-		},
-		onMessage: (node, body) => {
-			when((run) => {
-				run.tell(node, body);
-			});
-		},
-		onRelay: (node, from, body) => {
-			when((run) => {
-				run.receive(node, from, body);
-			});
-		},
-		onScript: (node, from, body) => {
-			when((run) => {
-				run.receive(node, from, body, "script");
-			});
-		},
-		onNotice: (node, text) => {
-			when((run) => {
-				run.notice(node, text);
-			});
-		}
-	};
-};
-// src/run/checkout.ts
-/**
-* @file Before a run with worktree nodes: the project must be a git repository
-*   with a commit, its instructions, skills and agents must be committed
-*   (worktrees get only committed files, unless `--allow-dirty`), and the
-*   project's `git.base` must name a commit, which root worktrees start from.
-*/
-/** Why a run refuses to start with uncommitted agent files. */
-const dirtyAgentMessage = (files) => [
-	"These instructions, skills or agents have uncommitted changes, and the worktrees only get committed files:",
-	...files.slice(0, 20).map((f) => `  ${f}`),
-	...files.length > 20 ? [`  … and ${String(files.length - 20)} more`] : [],
-	"Commit or stash them, or pass --allow-dirty to run with the committed versions."
-];
-/** Claude nodes that get their own worktree. */
-const worktreeNodes = (workflow) => Object.entries(workflow.nodes).filter(([, node]) => isClaudeNode(node) && node.type !== "agent.subagent" && (node.isolation ?? workflow.defaults?.isolation ?? "worktree") === "worktree").map(([id]) => id);
-/**
-* The project's folder for a message. Outside git, the place's root is the
-* folder of the workflow file, which is `<project>/.ork/workflows` for a
-* project's own workflow.
-*/
-const projectFolder = (root) => {
-	const tail = path.sep + WORKFLOW_DIR;
-	return root.endsWith(tail) ? root.slice(0, -tail.length) : root;
-};
-/** Checks the project for a run's worktrees, and resolves `git.base`. */
-const prepareCheckout = async (workflow, options, inputs) => {
-	const isolated = worktreeNodes(workflow);
-	if (isolated.length === 0 || options.inPlace) return {
-		ok: true,
-		base: ""
-	};
-	const project = await inspectProject(options.cwd);
-	if (project === null) return {
-		ok: false,
-		lines: [`${isolated.join(", ")} ${isolated.length === 1 ? "needs" : "need"} a git worktree, but ${projectFolder(options.cwd)} is not in a git repository with a commit; make a first commit (\`git commit --allow-empty -m "Start"\`) first, or pass --in-place to run them here`]
-	};
-	if (project.dirtyAgentFiles.length > 0 && options.allowDirty !== true) return {
-		ok: false,
-		lines: dirtyAgentMessage(project.dirtyAgentFiles)
-	};
-	if (project.dirtyOther > 0) options.err(`${style(["yellow", "bold"], "warning")} ${String(project.dirtyOther)} uncommitted change(s) in this checkout are not in the worktrees`);
-	try {
-		const base = await resolveBase(project.root, gitRulesOf(workflow), inputs);
-		return {
-			ok: true,
-			root: project.root,
-			base
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			lines: [error instanceof Error ? error.message : String(error)]
-		};
-	}
-};
-// src/run/lock-notes.ts
-/**
-* @file The note `ork run` prints at the start for a `branch:` lock that has no
-*   origin to key by (RFC-016): the lock is local to the folder, so no other
-*   clone shares it. Only a `branch:` lock gets one.
-*/
-/**
-* The notes, one per distinct `branch:` lock the run names that is local to
-* `repo`.
-*/
-const localLockNotes = async (workflow, inputs, repo) => {
-	const names = /* @__PURE__ */ new Set();
-	for (const node of Object.values(workflow.nodes)) {
-		const lock = "lock" in node ? node.lock : void 0;
-		if (lock === void 0) continue;
-		const parsed = parseTemplate(lock);
-		if (parsed.ok) names.add(renderTemplate(parsed.parts, {
-			inputs,
-			nodes: {}
-		}));
-	}
-	return (await Promise.all([...names].map(async (name) => await lockIsLocal(name, { repo }) ? name : void 0))).filter((name) => name !== void 0).map((name) => `${name} is local to ${path.resolve(repo)}: no origin, so no other clone shares it`);
-};
-// src/run/preflight.ts
-const preflight = async (options, given) => {
-	const { workflow, place, projects } = given;
-	const installed = options.installed ?? (options.tools === void 0 ? (p) => onPath(p) : () => true);
-	const missing = missingPrograms(workflow, installed);
-	if (missing.length > 0) return {
-		ok: false,
-		lines: missingProgramMessage(missing)
-	};
-	const unset = envProblems(workflow, place, projects, options.resume?.history, options.err);
-	if (unset.length > 0) return {
-		ok: false,
-		lines: unset
-	};
-	const limits = runLimits(options.store, place, options.home);
-	const refused = limitsRefusal(limits, workflow, options.resume?.history);
-	if (refused.length > 0) return {
-		ok: false,
-		lines: refused
-	};
-	const driver = await runReadyDriver(given.effective, {
-		override: options.driver,
-		recorded: options.resume?.settings.readyDriver,
-		checks: options.driverChecks
-	});
-	if (!driver.ok) return {
-		ok: false,
-		lines: driver.lines
-	};
-	if (driver.line !== void 0) options.err(driver.line);
-	const unfit = unfitLines(given.effective, options.drivers, {
-		override: options.driver,
-		ready: driver.driver ?? options.resume?.settings.readyDriver
-	});
-	if (unfit.length > 0) return {
-		ok: false,
-		lines: unfit
-	};
-	const budget = budgetWarningLines(given.effective, options.drivers, {
-		override: options.driver,
-		ready: driver.driver ?? options.resume?.settings.readyDriver
-	});
-	for (const line of noteLines(budget)) options.err(line);
-	const checkout = await prepareCheckout(workflow, {
-		...options,
-		cwd: place.root
-	}, given.inputs);
-	if (!checkout.ok) return {
-		ok: false,
-		lines: checkout.lines
-	};
-	const local = await localLockNotes(workflow, given.inputs, checkout.root ?? place.root);
-	for (const line of noteLines(local)) options.err(line);
-	return {
-		...checkout,
-		limits: limits.now,
-		...driver.driver === void 0 ? {} : { readyDriver: driver.driver }
-	};
-};
-// src/run/workflow.ts
-/**
-* @file `ork run` for a whole workflow: checks the workflow, its inputs and the
-*   project (git, uncommitted agent files), sets up the worktree workspace, and
-*   streams the scheduler's run. `ork resume` comes through here too, with the
-*   run's recorded state.
-*/
-/**
-* Runs a whole workflow: checks it and its inputs, then hands the compiled
-* graph to the scheduler with the built-in node types, and streams the run.
-*/
-const runWorkflowFile = async (options) => {
-	const failed = (lines) => {
-		for (const line of lines) options.err(line);
-		return {
-			exitCode: 1,
-			result: null
-		};
-	};
-	const loaded = loadWorkflow(options.file, options.cwd, options.home, options.store.projects());
-	const { workflow, graph, place, workflowDir, textHash } = loaded;
-	if (options.expectWorkflow !== void 0 && options.expectWorkflow !== textHash) return failed([`${options.file} isn't what was accepted: it changed after ork watch read it. Accept it again with \`ork watch --accept\`.`]);
-	if (workflow === null || graph === null) return failed(formatReport(loaded.report));
-	const { report } = options.resume === void 0 ? await walkLoaded(loaded) : loaded;
-	for (const line of warningLines(report)) options.err(line);
-	if (report.walk?.complete === false) options.err(walkSummary(report.walk));
-	const pairs = parseInputPairs(options.inputs);
-	if (!pairs.ok) return failed([`--input: ${pairs.error}`]);
-	const recorded = Object.fromEntries(Object.entries(options.resume?.inputs ?? {}).map(([k, v]) => [k, String(v)]));
-	const inputs = resolveInputs(workflow, {
-		...recorded,
-		...pairs.raw
-	});
-	if (!inputs.ok) return failed(inputs.errors);
-	const projects = options.store.projects();
-	const ready = await preflight(options, {
-		workflow,
-		effective: graph.workflow,
-		place,
-		projects,
-		inputs: inputs.inputs
-	});
-	if (!ready.ok) return failed(ready.lines);
-	const { root, base } = ready;
-	const cwd = root ?? (inside(place.root, options.cwd) ? options.cwd : place.root);
-	const runId = options.runId ?? newRunId(options.store);
-	const runDir = runDirOf(place, runId);
-	if (options.resume !== void 0) options.store.reopen(runId);
-	const record = options.resume === void 0 ? createRecorder(options.store, {
-		id: runId,
-		workflow: workflow.name,
-		file: path.resolve(options.cwd, options.file),
-		project: place.root,
-		...options.calledBy === void 0 ? {} : { parent: options.calledBy.split("/")[0] ?? "" }
-	}, runDir) : appendRecorder(options.store, runId, runDir);
-	const width = Math.max(...Object.keys(workflow.nodes).map((id) => id.length));
-	const tools = /* @__PURE__ */ new Map();
-	const view = createView();
-	const started = Promise.withResolvers();
-	const live = {};
-	const control = await startControl({
-		store: options.store,
-		runId,
-		emit: (event) => {
-			onEvent(event);
-		},
-		...liveHandlers(started.promise),
-		onControl: liveControl(live),
-		...options.human === void 0 ? {} : { local: options.human },
-		...options.home === void 0 ? {} : { home: options.home },
-		...options.intervalMs === void 0 ? {} : { intervalMs: options.intervalMs }
-	});
-	const signals = createSignals(feedbackOrigin(path.resolve(options.cwd, options.file)));
-	const onEvent = (raw) => {
-		for (const event of signals(raw)) {
-			control.publish(record(event));
-			if (options.json) options.out(JSON.stringify(event));
-			else for (const line of formatRunEvent(event, width, tools, options.human !== void 0, options.verbose, view)) options.out(line);
-		}
-	};
-	const workspace = root === void 0 ? void 0 : createWorkspace({
-		graph,
-		runId,
-		root,
-		head: options.baseRef ?? options.resume?.settings.baseRef ?? base,
-		inputs: inputs.inputs,
-		onEvent,
-		...resumedOptions(options.resume)
-	});
-	const maskedNames = maskedNamesOfRun(workflow, place, projects);
-	const executorOptions = {
-		runtimeFor: (driver) => options.runtime(driver, placeFiles(place).runs),
-		inPlace: options.inPlace,
-		maskedNames,
-		store: storePath(options.home)
-	};
-	if (options.driver !== void 0) executorOptions.driver = options.driver;
-	if (ready.readyDriver !== void 0) executorOptions.readyDriver = ready.readyDriver;
-	if (options.tools !== void 0) executorOptions.tools = options.tools;
-	const script = process.argv[1];
-	if (script !== void 0 && onPath(script)) executorOptions.orkBin = script;
-	const replay = options.resume === void 0 ? void 0 : createReplay(options.resume.history, options.resume.cutOff, options.resume.mail, options.resume.earlier, options.resume.fanOuts);
-	if (replay !== void 0) onEvent({
-		type: "run.resumed",
-		kept: replay.kept(),
-		ork: ORK_RUN_VERSION
-	});
-	const ports = callPorts({
-		...options,
-		graph,
-		runId,
-		place,
-		human: control.human,
-		emit: onEvent
-	});
-	if (ports.settings.machineClaude === true) executorOptions.machineClaude = true;
-	clearOutputFiles(runDir, options.err);
-	const handle = startRun({
-		graph: ports.graph,
-		calls: ports.calls,
-		runId,
-		runDir,
-		inputs: inputs.inputs,
-		cwd,
-		executors: builtinExecutors(executorOptions),
-		human: options.resume === void 0 ? control.human : replayLoopAnswers(control.human, options.resume.loopAnswers),
-		onEvent,
-		orkVersion: ORK_RUN_VERSION,
-		settings: {
-			inPlace: options.inPlace,
-			...options.driver === void 0 ? {} : { driver: options.driver },
-			...ready.readyDriver === void 0 ? {} : { readyDriver: ready.readyDriver },
-			...ports.settings
-		},
-		followUps: ports.followUps,
-		...ports.relay === void 0 ? {} : { relay: ports.relay },
-		...replay === void 0 ? {} : { replay },
-		workflowDir,
-		projectRoot: root ?? place.root,
-		orkDir: place.dir,
-		...workspace === void 0 ? {} : { workspace },
-		scrub: runScrubber(maskedNames, process.env),
-		limits: ready.limits,
-		machine: {
-			rules: machineRulesOf(loadProject(place.root, placeFiles(place).rules).project),
-			ledger: machineSlotLedger(options.home === void 0 ? {} : { home: options.home })
-		},
-		locks: machineLockLedgers(root ?? place.root, place.root, options.home),
-		beforeFinish: takeLastCommands(control, started.promise)
-	});
-	live.handle = handle;
-	started.resolve(handle);
-	options.onRun?.(handle);
-	const result = await handle.done;
-	await ports.shown.end(result.status);
-	clearOutputFiles(runDir, options.err);
-	if (result.status === "succeeded") clearStateFiles(runDir, options.err);
-	await endLinksOf(options.store, runId, result.status, options.home);
-	await control.close();
-	return {
-		exitCode: result.status === "succeeded" ? 0 : 1,
-		result
-	};
-};
-// src/commands/run.ts
-/**
-* @file `ork run`: the command and its flags. It runs a whole workflow, or one
-*   Claude node with `--node`, with questions and permission prompts answered
-*   on the terminal.
-*/
-const flagValues = (rawArgs, flag) => {
-	const values = [];
-	for (const [index, arg] of rawArgs.entries()) if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
-	else if (arg === flag) {
-		const value = rawArgs[index + 1];
-		if (value !== void 0) values.push(value);
-	}
-	return values;
-};
-const isDriver = (value) => AGENT_DRIVERS.some((d) => d.id === value);
-/** Why `--driver` refuses a value: a retired id names its replacement. */
-const badDriver = (value) => `--${retiredDriverHint(value) ?? `driver must be one of ${AGENT_DRIVERS.map((d) => d.id).join(", ")}, got \`${value}\``}`;
-/** Loads the drivers only when a run starts, so other commands stay fast. */
-const loadRuntime = async (driver, runs) => (await import("./src-D4JSymhK.mjs")).createRuntime(driver, sessionEnv(process.env), runs);
-/**
-* Ctrl-C asks the run to stop, and so does a terminal closing or a polite kill,
-* so that the run ends tidily and leaves no result unscrubbed.
-*/
-const onInterrupt = (stop) => {
-	let asked = false;
-	const interrupt = () => {
-		if (asked) return;
-		asked = true;
-		writeErr(style("dim", "\ninterrupting…"));
-		stop();
-	};
-	process.once("SIGINT", interrupt);
-	process.once("SIGTERM", interrupt);
-	process.once("SIGHUP", interrupt);
-};
-/** The terminal that answers a run's questions; none in a detached run. */
-const terminalHuman = () => {
-	const detached = process.env[DETACHED_ENV] === "1";
-	if (detached) writeErr(style("dim", "detached run: no terminal asks; answer with ork attach or ork decide"));
-	return detached ? void 0 : createTerminalHuman({
-		input: process.stdin,
-		output: process.stderr,
-		interactive: process.stdin.isTTY,
-		interrupt: () => {
-			process.kill(process.pid, "SIGINT");
-		}
-	});
-};
-const run = defineCommand({
-	meta: {
-		name: "run",
-		description: "Run a workflow, or one Claude node of it with --node"
-	},
-	args: {
-		workflow: {
-			type: "positional",
-			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
-			required: true
-		},
-		node: {
-			type: "string",
-			description: "Run only this Claude node"
-		},
-		input: {
-			type: "string",
-			description: "A workflow input, name=value (repeatable)"
-		},
-		"follow-ups": {
-			type: "string",
-			description: "Follow-up ids an agent does, or `due` for every due one (repeatable or comma-separated): they become the run's brief, done when it publishes"
-		},
-		driver: {
-			type: "string",
-			description: `${DRIVER_IDS.join(", ")} (default: the driver ready here)`
-		},
-		"in-place": {
-			type: "boolean",
-			description: "Run worktree nodes in this checkout, without worktrees",
-			default: false
-		},
-		"allow-dirty": {
-			type: "boolean",
-			description: "Run although instructions or skills have uncommitted changes (worktrees get the committed versions)",
-			default: false
-		},
-		"machine-claude": {
-			type: "boolean",
-			description: "Sessions load this machine's Claude setup: its MCP servers and Claude's memory (default: clean sessions)",
-			default: false
-		},
-		json: {
-			type: "boolean",
-			description: "Print the events as JSON lines",
-			default: false
-		},
-		verbose: {
-			type: "boolean",
-			description: "Show each tool call whole, and why each failed node stopped, with its scrubbed details",
-			default: false
-		},
-		detach: {
-			type: "boolean",
-			description: "Run in the background; follow it with ork logs -f, answer with ork decide",
-			default: false
-		},
-		"run-id": {
-			type: "string",
-			description: "Internal: the id `--detach` picked for the run"
-		},
-		"called-by": {
-			type: "string",
-			description: "Internal: the workflow.call that started this run"
-		},
-		"budget-cap": {
-			type: "string",
-			description: "Internal: what the caller has left of its budget"
-		},
-		"base-ref": {
-			type: "string",
-			description: "Internal: what this run's worktrees start from"
-		},
-		trigger: {
-			type: "string",
-			description: "Internal: the trigger that started this run"
-		},
-		"expect-workflow": {
-			type: "string",
-			description: "Internal: the hash the workflow's text must have"
-		},
-		untrusted: {
-			type: "string",
-			description: "Internal: an input from what a trigger's check reported"
-		}
-	},
-	run: async ({ args, rawArgs }) => {
-		if (args.driver !== void 0 && !isDriver(args.driver)) {
-			writeErr(badDriver(args.driver));
-			process.exitCode = 1;
-			return;
-		}
-		const { prepareFollowUps: prepare, followUpsFlagFine: flagFine } = await import("./brief-DH66xmj8.mjs");
-		const cwd = process.cwd();
-		if (refusedBuiltin([args.workflow], cwd) || !flagFine(rawArgs)) return;
-		const target = workflowArg(args.workflow, cwd);
-		const store = openStore();
-		if (args.detach) {
-			try {
-				const { startDetached } = await import("./detached-Dakw5RZj.mjs");
-				await startDetached(store, {
-					rawArgs,
-					cwd,
-					target,
-					node: args.node
-				});
-			} finally {
-				store.close();
-			}
-			return;
-		}
-		const taken = await prepare(store, rawArgs, args["run-id"], target);
-		if (taken === void 0) {
-			store.close();
-			return;
-		}
-		const human = terminalHuman();
-		const common = {
-			file: target.file,
-			cwd,
-			...taken,
-			inPlace: args["in-place"],
-			...args["machine-claude"] ? { machineClaude: true } : {},
-			json: args.json,
-			verbose: args.verbose,
-			runtime: loadRuntime,
-			store,
-			...human === void 0 ? {} : { human },
-			out: write,
-			err: writeErr,
-			...args.driver === void 0 ? {} : { driver: args.driver }
-		};
-		try {
-			const { exitCode } = args.node === void 0 || args.node === "" ? await runWorkflowFile({
-				...common,
-				allowDirty: args["allow-dirty"],
-				...args["called-by"] === void 0 ? {} : { calledBy: args["called-by"] },
-				...args["budget-cap"] === void 0 ? {} : { budgetCap: Number(args["budget-cap"]) },
-				...args["base-ref"] === void 0 ? {} : { baseRef: args["base-ref"] },
-				...args["expect-workflow"] === void 0 ? {} : { expectWorkflow: args["expect-workflow"] },
-				...args.trigger === void 0 ? {} : {
-					trigger: args.trigger,
-					untrusted: flagValues(rawArgs, "--untrusted")
-				},
-				...human === void 0 ? {} : { showCalls: callsShown(human, process.stdin.isTTY) },
-				onRun: (handle) => {
-					onInterrupt(handle.interrupt);
-				}
-			}) : await runNode({
-				...common,
-				nodeId: args.node,
-				onSession: (session) => {
-					onInterrupt(() => {
-						session.interrupt();
-					});
-				}
-			});
-			process.exitCode = exitCode;
-		} finally {
-			human?.close();
-			store.close();
-		}
-	}
-});
-export { machineSlotLedger as _, onInterrupt as a, takeFollowUps as b, runWorkflowFile as c, followUpsRule as d, refreshDue as f, sweepLocks as g, machineLocksDir as h, loadRuntime as i, briefOf as l, resumeChat as m, flagValues as n, run as o, runIsLive as p, isDriver as r, terminalHuman as s, badDriver as t, checkTakeable as u, availableDue as v, heldNote as y };