@krapht/ork 1.0.0-alpha.15 → 1.0.0-alpha.16

package/dist/{src-Dr_fTSu-.mjs → src-DN-RPsil.mjs}

@@ -66,7 +66,10 @@ const experimentsOn = ({ env = process.env, project, where, registry = EXPERIMEN
 /** Unknown names as errors, for the checks every workflow goes through. */
 const experimentDiagnostics = (options) => {
 	const state = experimentsOn(options);
-	return state.ok ? [] : state.unknown.map(({ message }) => error("experiment.unknown", message, []));
+	if (state.ok) return [];
+	const at = options?.at;
+	const inProject = options?.project?.experimental ?? [];
+	return state.unknown.map(({ name, source, message }) => source === "project" && at !== void 0 ? Object.assign(error("experiment.unknown", `names an unknown experiment \`${name}\`; known: ${knownExperiments(options?.registry)}`, []), at(["experimental", inProject.indexOf(name)])) : error("experiment.unknown", message, []));
 };
 // ../integrations/src/integration.ts
 /** Declares an integration with its option types checked. */
@@ -563,9 +566,11 @@ const IsolationSchema = z.enum([
 	"shared",
 	"readonly"
 ]);
-const BudgetSchema = z.number().positive();
+const MONEY_MESSAGE = "must be a number above 0";
+const TOKENS_MESSAGE = "must be a whole number above 0";
+const BudgetSchema = z.number(MONEY_MESSAGE).positive(MONEY_MESSAGE);
 /** A cap in tokens: input, output and cache-write; cache reads don't count. */
-const TokenBudgetSchema = z.number().int().positive();
+const TokenBudgetSchema = z.number(TOKENS_MESSAGE).int(TOKENS_MESSAGE).positive(TOKENS_MESSAGE);
 /** Caps across runs (RFC-007), in Claude Code's estimated dollars. */
 const QuotasSchema = z.strictObject({
 	dayUsd: BudgetSchema.optional().describe("Most to spend in a calendar day."),
@@ -573,7 +578,7 @@ const QuotasSchema = z.strictObject({
 	weekUsd: BudgetSchema.optional().describe("Most to spend in a calendar week, from Monday."),
 	monthUsd: BudgetSchema.optional().describe("Most to spend in a calendar month.")
 });
-const UNITS = {
+const UNITS$1 = {
 	s: 1e3,
 	m: 6e4,
 	h: 36e5
@@ -583,7 +588,7 @@ const timeoutMs = (timeout) => {
 	const match = /^(\d+)([smh])$/u.exec(timeout ?? "");
 	if (match === null) return void 0;
 	const [, amount = "0", unit = "s"] = match;
-	return Number(amount) * (UNITS[unit] ?? 1e3);
+	return Number(amount) * (UNITS$1[unit] ?? 1e3);
 };
 /** The most a timer can hold; a longer one fires at once. */
 const LONGEST_MS = 2 ** 31 - 1;
@@ -1282,6 +1287,8 @@ const newerVersion = (issues, raw) => {
 * @file Workflow and project YAML: parsing with source positions for
 *   diagnostics, and the workflow's byte-stable canonical serializer.
 */
+/** The message, led by `file:line:col: ` when it is in another file. */
+const diagnosticText = (d) => d.file === void 0 ? d.message : `${d.file}:${d.line ?? 1}:${d.column ?? 1}: ${d.message}`;
 const SCHEMA_URL = "https://raw.githubusercontent.com/mimshins/ork/main/packages/schema/workflow.schema.json";
 const createLocate = (doc, counter) => (path) => {
 	for (let depth = path.length; depth >= 0; depth -= 1) {
@@ -3133,6 +3140,12 @@ const BUILTIN_AGENTS = {
 *   reached through several folders counts once, under its real path. Reads,
 *   never writes.
 */
+/** Where an agent was found: lowest to highest precedence. */
+const AGENT_SOURCES = [
+	"builtin",
+	"user",
+	"project"
+];
 const hashOf = (...parts) => createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 12);
 const isDir = (target) => {
 	try {
@@ -4959,6 +4972,8 @@ const RETRY = "This may pass: `ork resume` tries again.";
 const usd$1 = (n) => `$${Number.isInteger(n) ? String(n) : n.toFixed(2)}`;
 const paren = (value) => value === void 0 ? "" : ` (${value})`;
 const colon = (reason) => reason === void 0 ? "" : `: ${reason}`;
+/** A cap as `used N of M`, or `M` alone when the spend is not known. */
+const usedOf = (cap, used) => used === void 0 ? cap : `used ${used} of ${cap}`;
 const info = (label, actor, message, hint, flags = {}) => ({
 	label,
 	message,
@@ -4975,7 +4990,7 @@ const END_KINDS = {
 	no_report: info("No report", "agent", () => "ended without handing in a report", "Check that its brief says what to report; its session is in the Logs panel."),
 	invalid_report: info("Invalid report", "agent", (f) => `handed in a report that breaks its declared output${colon(f.reason)}`, "Check that its brief asks for every field its `output.schema` declares."),
 	turn_limit: info("Turn limit", "workflow", (f) => `reached its turn limit${paren(f.maxTurns === void 0 ? void 0 : String(f.maxTurns))}`, "Raise its `maxTurns`, or give it a smaller task."),
-	budget_limit: info("Budget limit", "workflow", (f) => `reached its budget${paren([...f.budgetUsd === void 0 ? [] : [usd$1(f.budgetUsd)], ...f.budgetTokens === void 0 ? [] : [`${String(f.budgetTokens)} tokens`]].join(", ") || void 0)}`, "Raise `budgetUsd` or `budgetTokens` on the node, or the same in the workflow's `limits`, then `ork resume`."),
+	budget_limit: info("Budget limit", "workflow", (f) => `reached its budget${paren([...f.budgetUsd === void 0 ? [] : [usedOf(usd$1(f.budgetUsd), f.usedUsd === void 0 ? void 0 : usd$1(f.usedUsd))], ...f.budgetTokens === void 0 ? [] : [`${usedOf(String(f.budgetTokens), f.usedTokens === void 0 ? void 0 : String(f.usedTokens))} tokens`]].join(", ") || void 0)}`, "Raise `budgetUsd` or `budgetTokens` on the node, or the same in the workflow's `limits`, then `ork resume`."),
 	timed_out: info("Timed out", "workflow", (f) => `reached its timeout${paren(f.timeout)}`, "Raise its `timeout`, or give it a smaller task."),
 	context_too_long: info("Context too long", "workflow", () => "outgrew its model's context", "Give it a smaller task or less context, or a model with a larger context."),
 	plan_limit: info("Plan limit", "account", (f) => `ran into a usage limit${paren(f.window?.replaceAll("_", " "))}`, `Wait until the limit resets. ${RETRY}`, {
@@ -5386,18 +5401,25 @@ const loadProject = (projectRoot, file = path.join(projectRoot, PROJECT_FILE)) =
 	if (!existsSync(file)) return { diagnostics: [] };
 	const parsed = parseProject(readFileSync(file, "utf8"));
 	const label = shownPath(file, projectRoot);
-	if (parsed.ok) return {
-		project: parsed.project,
-		diagnostics: [],
-		where: (at) => {
-			const position = parsed.locate(at);
-			return position === null ? label : `${label}:${position.line}:${position.column}`;
-		}
-	};
-	return { diagnostics: parsed.diagnostics.map((d) => {
-		const at = d.line === void 0 ? "" : `:${d.line}:${d.column ?? 1}`;
-		return error(d.code, `${label}${at}: ${d.message}`, []);
-	}) };
+	if (parsed.ok) {
+		const at = (key) => ({
+			file: label,
+			...parsed.locate(key)
+		});
+		return {
+			project: parsed.project,
+			diagnostics: [],
+			where: (key) => {
+				const position = parsed.locate(key);
+				return position === null ? label : `${label}:${position.line}:${position.column}`;
+			},
+			at
+		};
+	}
+	return { diagnostics: parsed.diagnostics.map((d) => Object.assign(error(d.code, d.message, []), { file: label }, d.line === void 0 ? {} : {
+		line: d.line,
+		column: d.column ?? 1
+	})) };
 };
 /** Where the user's own settings live. */
 const USER_SETTINGS_FILE = path.join(".ork", "settings.yaml");
@@ -5813,6 +5835,7 @@ const runTree = (events) => {
 		}
 		node.state = "running";
 		node.runs += 1;
+		if (event.description !== void 0) node.description = event.description;
 	} else if (event.type === "node.held") {
 		const node = nodes.get(event.id);
 		if (node !== void 0) node.held = true;
@@ -6426,6 +6449,7 @@ const followUpProblem = (input) => {
 		"after-deploy"
 	].includes(input.due) && !date) return "`due` is now, after-merge, after-deploy or a YYYY-MM-DD date";
 	if (input.kind === "message" && input.draft === void 0) return "a message needs its `draft` (to, channel, text), which the maintainer sends";
+	if (input.steps?.some((step) => step.text.trim() === "") === true) return "each step needs its text";
 	return null;
 };
 /** The project a `project:<name>` follow-up is for, or `undefined`. */
@@ -6757,6 +6781,19 @@ port: (node, cwd) => {
 		return result;
 	} };
 } });
+// ../core/src/follow-ups/types.ts
+const FOLLOW_UP_KINDS = [
+	"change",
+	"message",
+	"task",
+	"check"
+];
+const FOLLOW_UP_STATUSES = [
+	"waiting",
+	"due",
+	"done",
+	"dropped"
+];
 // ../core/src/project/mcp-file.ts
 /**
 * @file The project's `.mcp.json`, the file Claude Code reads too, so a server
@@ -7006,7 +7043,17 @@ const itemNodeOf = (node) => {
 	const { forEach, ...item } = node;
 	return item;
 };
+/**
+* What any node reports when its `timeout` expires; known on every type, since
+* the timeout may come from `defaults` or the project.
+*/
+const TIMED_OUT_FIELD = "timedOut";
+/** The fields a node reports, or null when they can't be known ahead. */
 const outputFieldsOf = (node) => {
+	const fields = typeFieldsOf(node);
+	return fields === null ? null : [...fields, TIMED_OUT_FIELD];
+};
+const typeFieldsOf = (node) => {
 	if (forEachOf$1(node) !== void 0) return GATHERED_FIELDS;
 	if (isToolNode(node)) return [
 		...TOOL_OUTPUT_FIELDS,
@@ -7984,6 +8031,21 @@ const checkItemSettings = (workflow, edges) => {
 	const nodes = Object.entries(workflow.nodes).flatMap(([id, node]) => isClaudeNode(node) ? FIELDS$1.flatMap((field) => checkNodeField(workflow, says, id, field)) : []);
 	return [...defaults, ...nodes];
 };
+// ../core/src/graph/leader-budget.ts
+/**
+* @file The `budget.leader` warning: a leader with nodes to delegate to and no
+*   cap of its own under a run budget. Its session sets aside what is left of
+*   the run's budget in that unit, and a leader's reserve is never waited on
+*   (ADR-077), so the nodes it owns are refused. A compiler warning, like
+*   `loop.uncapped`, on the effective workflow: it never stops a run.
+*/
+const UNITS = ["budgetUsd", "budgetTokens"];
+/** One warning per leader and run budget its own cap leaves open. */
+const leaderBudgetWarnings = (workflow) => Object.entries(workflow.nodes).flatMap(([id, node]) => {
+	if (node.type !== "agent.leader" || !isClaudeNode(node)) return [];
+	if (!Object.values(workflow.nodes).some((child) => child.parent === id && (child.type === "agent.leader" || child.type === "agent.worker"))) return [];
+	return UNITS.filter((unit) => workflow.limits?.[unit] !== void 0 && (node[unit] ?? workflow.defaults?.[unit]) === void 0).map((unit) => warning("budget.leader", `leader \`${id}\` has no ${unit} of its own, so its session sets aside all that is left of limits.${unit} and the nodes it owns are refused; give it a ${unit}, or set one in defaults`, ["nodes", id]));
+});
 // ../core/src/graph/script.ts
 /**
 * @file Checks on the programs a workflow declares (RFC-006): a tool node's and
@@ -8062,7 +8124,11 @@ const modelDriverProblems = (id, node, workflow) => {
 };
 /** Per-type checks that need the rest of the graph. */
 const checkNodes = (workflow, edges) => {
-	const diagnostics = [...checkScripts(workflow), ...checkItemSettings(workflow, edges)];
+	const diagnostics = [
+		...checkScripts(workflow),
+		...checkItemSettings(workflow, edges),
+		...leaderBudgetWarnings(workflow)
+	];
 	for (const [id, node] of Object.entries(workflow.nodes)) {
 		const path = ["nodes", id];
 		const incoming = edges.filter((e) => e.to === id);
@@ -8702,73 +8768,590 @@ const gitOk = async (cwd, args, env = {}) => {
 };
 /** Output lines without the trailing empty one. */
 const lines = (text) => text.split("\n").filter((line) => line !== "");
-// ../core/src/machine/priority.ts
+/** Gitignored files a session needs as much in a worktree as in the clone. */
+const LOCAL_AGENT_FILES = ["CLAUDE.local.md", ".claude/settings.local.json"];
+/** Where the project's instructions, skills and agents live. */
+const AGENT_PATHSPECS = [
+	":(glob)**/CLAUDE.md",
+	":(glob)**/AGENTS.md",
+	".claude",
+	".agents"
+];
+/** Symlinked agent folders (e.g. `.claude/skills -> ../.ai/skills`), as targets. */
+const symlinkTargets = (root) => {
+	const targets = [];
+	for (const dir of [".claude", ".agents"]) {
+		const base = path.join(root, dir);
+		if (!existsSync(base) || !lstatSync(base).isDirectory()) continue;
+		for (const name of [
+			"skills",
+			"agents",
+			"commands",
+			"rules"
+		]) {
+			const link = path.join(base, name);
+			if (!existsSync(link) || !lstatSync(link).isSymbolicLink()) continue;
+			const target = path.resolve(base, readlinkSync(link));
+			const relative = path.relative(root, target);
+			if (!relative.startsWith("..") && !path.isAbsolute(relative)) targets.push(relative);
+		}
+	}
+	return [...new Set(targets)];
+};
+const statusPaths = async (root, pathspecs) => {
+	const out = await gitOk(root, [
+		"status",
+		"--porcelain=v1",
+		"--untracked-files=all",
+		"--",
+		...pathspecs
+	]);
+	return lines(out).map((line) => line.slice(3));
+};
+/** The project's git root, head, and what a worktree would be missing. */
+const inspectProject = async (cwd) => {
+	const top = await git(cwd, ["rev-parse", "--show-toplevel"]);
+	if (top.code !== 0) return null;
+	const root = top.stdout.trim();
+	const head = await git(root, ["rev-parse", "HEAD"]);
+	if (head.code !== 0) return null;
+	const agent = await statusPaths(root, [...AGENT_PATHSPECS, ...symlinkTargets(root)]);
+	const all = await statusPaths(root, ["."]);
+	return {
+		root,
+		head: head.stdout.trim(),
+		dirtyAgentFiles: agent,
+		dirtyOther: all.length - agent.length
+	};
+};
 /**
-* @file Starting a child at the project's priority (`priority:`): `low`, the
-*   default, starts it below Ork's own (under `nice`; on macOS also utility QoS
-*   through `taskpolicy`), so the user's own apps come first; `normal` leaves
-*   it. Only children: the `ork` process itself stays at normal priority.
+* The gitignored files to copy into a new worktree: every local agent file, and
+* what the repo's `.worktreeinclude` lists (Claude Code's convention). Only
+* files that are also gitignored qualify, so tracked files are never copied.
 */
-/** MacOS's tool for a program's QoS. */
-const TASKPOLICY = "/usr/sbin/taskpolicy";
-/** The POSIX tool that starts a program at a lower priority. */
-const NICE = "/usr/bin/nice";
-/** How far `nice` lowers a `low` child: the same as `PRIORITY_BELOW_NORMAL`. */
-const NICE_STEP = String(constants$1.priority.PRIORITY_BELOW_NORMAL);
+const localFiles = async (root) => {
+	const include = path.join(root, ".worktreeinclude");
+	const candidates = lines(await gitOk(root, [
+		"ls-files",
+		"--others",
+		"--ignored",
+		...LOCAL_AGENT_FILES.map((f) => `--exclude=${f}`),
+		...existsSync(include) ? [`--exclude-from=${include}`] : []
+	]));
+	if (candidates.length === 0) return [];
+	const ignored = await git(root, [
+		"check-ignore",
+		"--",
+		...candidates
+	]);
+	return lines(ignored.stdout);
+};
+const copyInto = (from, to, files) => {
+	const copied = [];
+	for (const file of files) {
+		const target = path.join(to, file);
+		if (existsSync(target) || !existsSync(path.join(from, file))) continue;
+		mkdirSync(path.dirname(target), { recursive: true });
+		cpSync(path.join(from, file), target, { verbatimSymlinks: true });
+		copied.push(file);
+	}
+	return copied;
+};
 /**
-* Whether `bin` is a program `spawn` would find, so a wrapper can't hide its
-* absence.
+* Creates a worktree at `path` from `base`, with the local files: on a new
+* `branch`, or detached when there is none (`commit: never`). An existing
+* branch is checked out again only when this run created it (`known`): a
+* resumed run's branch outlives its removed worktree. Any other existing branch
+* stops it: Ork never takes over a branch it did not create.
 */
-const programFound = (bin, env) => bin.includes("/") ? existsSync(bin) : (env["PATH"] ?? "").split(path.delimiter).some((dir) => dir !== "" && existsSync(path.join(dir, bin)));
+const createWorktree = async (options) => {
+	const { root, branch, base } = options;
+	const target = options.path;
+	mkdirSync(path.dirname(target), { recursive: true });
+	if (branch === void 0) {
+		await gitOk(root, [
+			"worktree",
+			"add",
+			"--detach",
+			target,
+			base
+		]);
+		return {
+			path: target,
+			copied: copyInto(root, target, await localFiles(root)),
+			reused: false
+		};
+	}
+	const exists = (await git(root, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`refs/heads/${branch}`
+	])).code === 0;
+	if (exists && options.known !== true) throw new Error(`branch ${branch} already exists, and this run did not create it; Ork never takes over a branch it did not create`);
+	await gitOk(root, exists ? [
+		"worktree",
+		"add",
+		target,
+		branch
+	] : [
+		"worktree",
+		"add",
+		"-b",
+		branch,
+		target,
+		base
+	]);
+	return {
+		path: target,
+		branch,
+		copied: copyInto(root, target, await localFiles(root)),
+		reused: exists
+	};
+};
+/** Copies files that exist in `from` and are missing in the worktree. */
+const carryFiles = (from, worktree, files) => copyInto(from, worktree, files.filter((f) => !path.isAbsolute(f) && !f.split(/[\\/]/u).includes("..")));
+/** What git keeps in a worktree's git dir while a rebase, merge or pick runs. */
+const UNDERWAY = [
+	"rebase-merge",
+	"rebase-apply",
+	"MERGE_HEAD",
+	"CHERRY_PICK_HEAD",
+	"REVERT_HEAD"
+];
+/** Whether a rebase, merge, cherry-pick or revert is underway in `worktree`. */
+const gitOperationUnderway = async (worktree) => {
+	const paths = await gitOk(worktree, ["rev-parse", ...UNDERWAY.flatMap((name) => ["--git-path", name])]);
+	return lines(paths).some((file) => existsSync(path.resolve(worktree, file)));
+};
 /**
-* What to spawn for `bin args` at `priority`. For `low`, when the program is
-* there: under `nice`, so it and what it starts run lower from the first
-* instruction, and on macOS under utility QoS as well; else the program itself,
-* which {@link lowerChild} lowers once it has started.
+* Commits what a session left uncommitted. The repo's hooks run; when they
+* refuse, the error says why and the worktree keeps the changes. A worktree
+* mid-rebase (or merge, cherry-pick, revert) is left exactly as it is: its
+* changes are the operation's to finish, as a conflict resolver's are.
 */
-const startAt = (priority, bin, args, env = process.env) => {
-	if (priority !== "low" || !programFound(bin, env)) return [bin, [...args]];
-	const niced = existsSync(NICE) ? [
-		NICE,
-		"-n",
-		NICE_STEP,
-		bin
-	] : [bin];
-	const [first = bin, ...rest] = process.platform === "darwin" && existsSync(TASKPOLICY) ? [
-		TASKPOLICY,
-		"-c",
-		"utility",
-		...niced
-	] : niced;
-	return [first, [...rest, ...args]];
+const commitLeftovers = async (worktree, message) => {
+	if (await gitOperationUnderway(worktree)) return false;
+	const status = await gitOk(worktree, ["status", "--porcelain"]);
+	if (lines(status).length === 0) return false;
+	await gitOk(worktree, ["add", "-A"]);
+	await gitOk(worktree, [
+		"commit",
+		"-m",
+		message
+	]);
+	return true;
 };
 /**
-* Lowers a started child's priority for `low` where {@link startAt} had no
-* `nice` to start it under (Windows), best effort; what it starts later
-* inherits it. Under `nice` it does nothing: `nice` lowers relative to the
-* priority it finds, so lowering here too could land first and the two add up.
+* Moves a worktree's branch up to `branch` when it is behind and has nothing of
+* its own, e.g. a child's branch after its owner merged it and moved on.
 */
-const lowerChild = (priority, pid) => {
-	if (priority !== "low" || pid === void 0 || existsSync(NICE)) return;
-	try {
-		setPriority(pid, constants$1.priority.PRIORITY_BELOW_NORMAL);
-	} catch {}
-};
-// ../core/src/run/machine.ts
+const fastForward = async (worktree, branch) => (await git(worktree, [
+	"merge",
+	"--ff-only",
+	"-q",
+	branch
+])).code === 0;
 /**
-* @file A node's share of the machine (the `machine` of its context): the
-*   project's priority for its commands, and a machine-wide slot around each
-*   heavy one. A wait is never silent: `slot.waiting` names who holds the
-*   slots, `slot.taken` ends it, and the node's clock (its owners' and the
-*   run's too) stands still meanwhile, so a timeout counts from the slot.
+* Merges `branch` into the checkout at `into` with `--no-ff`; aborts on
+* conflict.
 */
-/** A wait for a slot, as `ork logs`, `ork tree` and the UI say it. */
-const slotWaitLine = (holders) => holders.length === 0 ? "waiting for a check slot" : `waiting for a check slot, held by ${holders.join(", ")}`;
-const none = () => {};
-/** The port for one activation; none for a run that shares nothing. */
-const machinePort = (options, runId, id, clock) => {
-	const { machine } = options;
-	if (machine === void 0) return void 0;
+const mergeBranch = async (into, branch, message) => {
+	const merged = await git(into, [
+		"merge",
+		"--no-ff",
+		"--no-edit",
+		"-m",
+		message,
+		branch
+	]);
+	if (merged.code === 0) return { ok: true };
+	const conflicts = lines((await git(into, [
+		"diff",
+		"--name-only",
+		"--diff-filter=U"
+	])).stdout);
+	await git(into, ["merge", "--abort"]);
+	return {
+		ok: false,
+		conflicts,
+		error: (merged.stdout + merged.stderr).trim().split("\n").at(-1) ?? "the merge failed"
+	};
+};
+const removeWorktree = async (root, worktree, force = false) => {
+	await gitOk(root, [
+		"worktree",
+		"remove",
+		...force ? ["--force"] : [],
+		worktree
+	]);
+};
+// ../core/src/worktree/clean.ts
+/**
+* @file What `ork worktrees clean` and `ork worktrees remove` do with what
+*   list.ts reads: the plan (what goes, what's kept and why), by one rule for
+*   every caller, and carrying it out. The CLI and the Worktrees panel both
+*   plan here, so neither removes what the other would keep.
+*/
+/** What names an item for `remove`: its branch, or its worktree's path. */
+const keyOf = (item) => item.branch ?? item.path ?? `${item.runId}/${item.nodeId}`;
+/** The reasons no `force` overrides: removing would break something. */
+const MAIN_CHECKOUT = "checked out in the main checkout";
+const RUN_GOING = "its run is still going";
+const NOT_ORKS = "not created by Ork";
+const kept = (item, skip) => ({
+	item,
+	removeWorktree: false,
+	deleteBranch: false,
+	skip
+});
+/** What clean does with one item. */
+const cleanStep = (item, options) => {
+	if (!item.recorded) return kept(item, NOT_ORKS);
+	if (item.inMainCheckout) return kept(item, MAIN_CHECKOUT);
+	if (item.heldBy !== void 0) return kept(item, `checked out in ${item.heldBy}`);
+	if (options.live?.has(item.runId) === true) return kept(item, RUN_GOING);
+	if (item.dirty && !options.force) return kept(item, "uncommitted changes");
+	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return kept(item, "commits on no branch");
+	const removable = item.path !== null && !item.missing;
+	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
+		item,
+		removeWorktree: removable,
+		deleteBranch: false,
+		skip: "branch not merged"
+	};
+	return {
+		item,
+		removeWorktree: removable,
+		deleteBranch: options.branches && item.branch !== void 0
+	};
+};
+/** Whether a step drops a worktree whose folder is gone, by its own path. */
+const stepPrunes = (step) => step.item.missing && step.item.path !== null && step.skip === void 0;
+/** Whether a step does anything. */
+const stepActs = (step) => step.removeWorktree || step.deleteBranch || stepPrunes(step);
+/**
+* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
+* unmerged branch, or a detached worktree holding commits no branch has, is
+* kept unless `force`; one checked out in the main checkout or in a worktree
+* Ork didn't create, whose run is still going, or an `ork/` branch no run
+* recorded creating, is kept even then.
+*/
+const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => filter.key === void 0 || keyOf(item) === filter.key).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
+/**
+* Carries out one step; what it did goes into `done` as it goes. It touches
+* only its own item: a missing worktree is dropped by its own path (`git
+* worktree remove`), never by `git worktree prune`, which would drop every
+* missing worktree in the repository, the user's own included.
+*/
+const applyStep = async (root, step, force, done) => {
+	const { item } = step;
+	if (stepPrunes(step) && !step.removeWorktree && item.path !== null) {
+		await gitOk(root, [
+			"worktree",
+			"remove",
+			item.path
+		]);
+		done.push(`pruned ${item.path}`);
+	}
+	if (step.removeWorktree && item.path !== null) {
+		await removeWorktree(root, item.path, force);
+		done.push(`removed ${item.path}`);
+	}
+	if (step.deleteBranch && item.branch !== void 0) {
+		await gitOk(root, [
+			"branch",
+			force ? "-D" : "-d",
+			item.branch
+		]);
+		done.push(`deleted ${item.branch}`);
+	}
+};
+/**
+* Carries out a clean plan, step by step. What it did goes into `done` as it
+* goes, so a caller still has it when git fails halfway.
+*/
+const applyClean = async (root, steps, force, done = []) => {
+	for (const step of steps) await applyStep(root, step, force, done);
+	return done;
+};
+// ../core/src/list-filters/tables.ts
+/**
+* @file The field tables of the lists whose rows live in core (RFC-017): `ork
+*   ps`, `feedback list`, `follow-ups list`, `decide --list`, `worktrees list`
+*   and `usage`. Each says which flags filter it and what `--ids` prints; each
+*   list's default (follow-ups due and waiting, feedback without the dismissed,
+*   `ps`'s 20 of this project) stays its command's.
+*/
+/**
+* A scope-only field: a registered project's id or root, or `all`; the caller
+* reads the store for it, and refuses one not registered.
+*/
+const projectField = () => ({
+	name: "project",
+	description: "A registered project's id or root, or all (default: the one you are in)",
+	type: "text",
+	all: true
+});
+/** What `--status` matches on `ork ps`: the stored status, or the live one. */
+const RUN_LIST_STATUSES = [
+	"running",
+	"paused",
+	"crashed",
+	"succeeded",
+	"failed",
+	"budget_exhausted",
+	"quota_exhausted",
+	"timed_out",
+	"interrupted"
+];
+const runStatusOf = (run) => run.listed ?? run.status;
+/** `ork ps`. */
+const runListTable = {
+	fields: [
+		{
+			name: "status",
+			description: `Only runs in this status, or all: ${RUN_LIST_STATUSES.join(", ")}`,
+			type: "enum",
+			values: RUN_LIST_STATUSES,
+			all: true,
+			get: runStatusOf
+		},
+		{
+			name: "workflow",
+			description: "Only this workflow's runs",
+			type: "text",
+			get: (run) => run.workflow
+		},
+		projectField(),
+		{
+			name: "since",
+			description: "Only runs started since an age (24h, 30d, 12w), a day (2026-11-01), or all",
+			type: "since",
+			all: true,
+			get: (run) => run.startedAt
+		},
+		{
+			name: "until",
+			description: "Only runs started on or before this day (2026-11-01)",
+			type: "until",
+			get: (run) => run.startedAt
+		}
+	],
+	id: (run) => run.id
+};
+/** A feedback item's statuses, in triage's order. */
+const FEEDBACK_STATUSES = [
+	"new",
+	"triaged",
+	"accepted",
+	"dismissed",
+	"published",
+	"resolved"
+];
+const feedbackStatusOf = (item) => item.status;
+/** `ork feedback list`. */
+const feedbackListTable = {
+	fields: [
+		{
+			name: "status",
+			description: `Only items in this status, or all (dismissed too): ${FEEDBACK_STATUSES.join(", ")}`,
+			type: "enum",
+			values: FEEDBACK_STATUSES,
+			all: true,
+			get: feedbackStatusOf
+		},
+		{
+			name: "kind",
+			description: `Only items of this kind: ${FEEDBACK_KINDS.join(", ")}`,
+			type: "enum",
+			values: FEEDBACK_KINDS,
+			get: (item) => item.kind
+		},
+		{
+			name: "severity",
+			description: `Only items of this severity: ${FEEDBACK_SEVERITIES.join(", ")}`,
+			type: "enum",
+			values: FEEDBACK_SEVERITIES,
+			get: (item) => item.severity
+		},
+		{
+			name: "workflow",
+			description: "Only items this workflow's runs reported",
+			type: "text",
+			get: (item) => item.workflows
+		},
+		{
+			name: "run",
+			description: "Only items this run reported",
+			type: "text",
+			get: (item) => item.runs
+		}
+	],
+	id: (item) => item.id
+};
+/**
+* What `--due` matches: when a follow-up comes due; `date` is any with a
+* `YYYY-MM-DD` date.
+*/
+const FOLLOW_UP_DUES = [
+	"now",
+	"after-merge",
+	"after-deploy",
+	"date"
+];
+/** `ork follow-ups list`. */
+const followUpListTable = {
+	fields: [
+		{
+			name: "status",
+			description: `Only follow-ups in this status, or all (default: due and waiting): ${FOLLOW_UP_STATUSES.join(", ")}`,
+			type: "enum",
+			values: FOLLOW_UP_STATUSES,
+			all: true,
+			get: (f) => f.status
+		},
+		{
+			name: "for",
+			description: "Only those for agent, me, project:<name> or person:<name>",
+			type: "for",
+			get: (f) => f.for
+		},
+		{
+			name: "kind",
+			description: `Only follow-ups of this kind: ${FOLLOW_UP_KINDS.join(", ")}`,
+			type: "enum",
+			values: FOLLOW_UP_KINDS,
+			get: (f) => f.kind
+		},
+		{
+			name: "due",
+			description: `Only those due this way: ${FOLLOW_UP_DUES.join(", ")} (any dated one)`,
+			type: "enum",
+			values: FOLLOW_UP_DUES,
+			get: (f) => /^\d{4}-\d{2}-\d{2}$/u.test(f.due) ? "date" : f.due
+		},
+		projectField()
+	],
+	id: (f) => f.id
+};
+/** `ork decide --list`: every field scopes the store read. */
+const decisionListTable = {
+	fields: [
+		{
+			name: "workflow",
+			description: "Only the decisions of this workflow's runs",
+			type: "text"
+		},
+		{
+			name: "run",
+			description: "Only this run's decisions (a run id or a prefix of one)",
+			type: "text"
+		},
+		projectField()
+	],
+	id: (decision) => decision.id
+};
+/** `ork worktrees list`; the id is what `ork worktrees remove` takes. */
+const worktreeListTable = {
+	fields: [{
+		name: "run",
+		description: "Only this run's worktrees",
+		type: "text",
+		get: (item) => item.runId
+	}, projectField()],
+	id: keyOf
+};
+/**
+* `ork usage`: parse only, its values go straight into `store.usage`'s
+* `UsageFilter`, which filters; its rows have no id.
+*/
+const usageListTable = { fields: [
+	{
+		name: "workflow",
+		description: "Only this workflow",
+		type: "text"
+	},
+	projectField(),
+	{
+		name: "since",
+		description: "Whole days counting today (30d, 12w), exact hours (24h), a day (2026-11-01), or all",
+		type: "since",
+		all: true
+	},
+	{
+		name: "until",
+		description: "The last day to include",
+		type: "until"
+	}
+] };
+// ../core/src/machine/priority.ts
+/**
+* @file Starting a child at the project's priority (`priority:`): `low`, the
+*   default, starts it below Ork's own (under `nice`; on macOS also utility QoS
+*   through `taskpolicy`), so the user's own apps come first; `normal` leaves
+*   it. Only children: the `ork` process itself stays at normal priority.
+*/
+/** MacOS's tool for a program's QoS. */
+const TASKPOLICY = "/usr/sbin/taskpolicy";
+/** The POSIX tool that starts a program at a lower priority. */
+const NICE = "/usr/bin/nice";
+/** How far `nice` lowers a `low` child: the same as `PRIORITY_BELOW_NORMAL`. */
+const NICE_STEP = String(constants$1.priority.PRIORITY_BELOW_NORMAL);
+/**
+* Whether `bin` is a program `spawn` would find, so a wrapper can't hide its
+* absence.
+*/
+const programFound = (bin, env) => bin.includes("/") ? existsSync(bin) : (env["PATH"] ?? "").split(path.delimiter).some((dir) => dir !== "" && existsSync(path.join(dir, bin)));
+/**
+* What to spawn for `bin args` at `priority`. For `low`, when the program is
+* there: under `nice`, so it and what it starts run lower from the first
+* instruction, and on macOS under utility QoS as well; else the program itself,
+* which {@link lowerChild} lowers once it has started.
+*/
+const startAt = (priority, bin, args, env = process.env) => {
+	if (priority !== "low" || !programFound(bin, env)) return [bin, [...args]];
+	const niced = existsSync(NICE) ? [
+		NICE,
+		"-n",
+		NICE_STEP,
+		bin
+	] : [bin];
+	const [first = bin, ...rest] = process.platform === "darwin" && existsSync(TASKPOLICY) ? [
+		TASKPOLICY,
+		"-c",
+		"utility",
+		...niced
+	] : niced;
+	return [first, [...rest, ...args]];
+};
+/**
+* Lowers a started child's priority for `low` where {@link startAt} had no
+* `nice` to start it under (Windows), best effort; what it starts later
+* inherits it. Under `nice` it does nothing: `nice` lowers relative to the
+* priority it finds, so lowering here too could land first and the two add up.
+*/
+const lowerChild = (priority, pid) => {
+	if (priority !== "low" || pid === void 0 || existsSync(NICE)) return;
+	try {
+		setPriority(pid, constants$1.priority.PRIORITY_BELOW_NORMAL);
+	} catch {}
+};
+// ../core/src/run/machine.ts
+/**
+* @file A node's share of the machine (the `machine` of its context): the
+*   project's priority for its commands, and a machine-wide slot around each
+*   heavy one. A wait is never silent: `slot.waiting` names who holds the
+*   slots, `slot.taken` ends it, and the node's clock (its owners' and the
+*   run's too) stands still meanwhile, so a timeout counts from the slot.
+*/
+/** A wait for a slot, as `ork logs`, `ork tree` and the UI say it. */
+const slotWaitLine = (holders) => holders.length === 0 ? "waiting for a check slot" : `waiting for a check slot, held by ${holders.join(", ")}`;
+const none = () => {};
+/** The port for one activation; none for a run that shares nothing. */
+const machinePort = (options, runId, id, clock) => {
+	const { machine } = options;
+	if (machine === void 0) return void 0;
 	const { rules, ledger } = machine;
 	return {
 		priority: rules.priority,
@@ -9815,6 +10398,17 @@ const reportOf = (child, result) => {
 	if (result.error !== void 0) report.error = result.error;
 	return report;
 };
+/** A job with the task's description clipped once; blank is none. */
+const jobOf = (id, task, template) => {
+	const job = {
+		id,
+		brief: task.brief
+	};
+	if (template !== void 0) job.template = template;
+	const description = task.description?.replaceAll(/[\s\p{Cc}]+/gu, " ").trim().slice(0, 80);
+	if (description !== void 0 && description !== "") job.description = description;
+	return job;
+};
 const createOwnership = (hooks) => {
 	const { graph, leader } = hooks;
 	const owner = graph.nodes.get(leader);
@@ -9848,11 +10442,10 @@ const createOwnership = (hooks) => {
 			return {
 				reports: await Promise.all(jobs.map(async (job) => {
 					if (!("brief" in job)) return job;
-					const child = { id: job.id };
-					if (job.template !== void 0) child.template = job.template;
+					const { brief, ...child } = job;
 					const result = await hooks.runChild(child, {
 						from: leader,
-						text: job.brief
+						text: brief
 					});
 					return reportOf(job.id, result);
 				})),
@@ -9871,10 +10464,7 @@ const createOwnership = (hooks) => {
 			}
 			if (seen.has(task.child) || hooks.isRunning(task.child)) return rejected(task.child, templates.includes(task.child) && maxWorkers > 0 ? "already running; use spawn_worker for another instance" : "already running");
 			seen.add(task.child);
-			return {
-				id: task.child,
-				brief: task.brief
-			};
+			return jobOf(task.child, task);
 		});
 		return runJobs(jobs);
 	};
@@ -9893,11 +10483,7 @@ const createOwnership = (hooks) => {
 			if (spawned.length >= maxWorkers) return rejected(task.template, `no workers left to spawn (maxWorkers: ${String(maxWorkers)})`);
 			const id = nextInstance(task.template);
 			spawned.push(id);
-			return {
-				id,
-				template: task.template,
-				brief: task.brief
-			};
+			return jobOf(id, task, task.template);
 		});
 		return runJobs(jobs);
 	};
@@ -10350,6 +10936,7 @@ const startedEvent = (activation, nodeType, round, agent) => {
 		round
 	};
 	if (activation.brief !== void 0) event.owner = activation.brief.from;
+	if (activation.description !== void 0) event.description = activation.description;
 	if (agent !== void 0) event.agent = agent;
 	const { item } = activation;
 	if (item !== void 0) event.item = {
@@ -11802,7 +12389,7 @@ const startRun = (options) => {
 		if (stopped !== null) return;
 		stopped = status;
 		reasons.push(reason);
-		queue.length = 0;
+		for (const { id } of queue.splice(0)) summary(id);
 	};
 	const enqueue = (id, input) => {
 		if (stopped !== null) return;
@@ -12888,7 +13475,8 @@ const checkWorkflowText = (text, { place, workflowDir, registered, home }) => {
 		...loaded.diagnostics,
 		...experimentDiagnostics({
 			project: loaded.project,
-			where: loaded.where
+			where: loaded.where,
+			at: loaded.at
 		}),
 		...compiled.diagnostics,
 		...checkCallTargets(parsed.workflow, place, registered),
@@ -12897,7 +13485,7 @@ const checkWorkflowText = (text, { place, workflowDir, registered, home }) => {
 			projectRoot
 		})
 	]) {
-		const position = parsed.locate(diagnostic.path);
+		const position = diagnostic.file === void 0 ? parsed.locate(diagnostic.path) : null;
 		diagnostics.push(position === null ? diagnostic : {
 			...diagnostic,
 			...position
@@ -13505,7 +14093,7 @@ const explainWorkflowText = (text, file, nodeId, where) => {
 		const first = diagnostics.find((d) => d.severity === "error");
 		return {
 			ok: false,
-			error: `The workflow has errors, so it can't be planned${first === void 0 ? "." : `: ${first.message}`}`
+			error: `The workflow has errors, so it can't be planned${first === void 0 ? "." : `: ${diagnosticText(first)}`}`
 		};
 	}
 	const result = explainSession(workflow, graph, nodeId, {
@@ -15379,333 +15967,115 @@ const parseInputPairs = (pairs) => {
 // ../core/src/run/replay.ts
 const NO_FAN_OUTS = {
 	lists: /* @__PURE__ */ new Map(),
-	items: /* @__PURE__ */ new Map()
-};
-/** Whether an activation's input carries a result this run made anew. */
-const carries = (fresh, input) => {
-	if (input === void 0) return false;
-	if (fresh.has(input)) return true;
-	const results = input["results"];
-	if (results === null || typeof results !== "object") return false;
-	return Object.values(results).some((value) => value !== null && typeof value === "object" && fresh.has(value));
-};
-/**
-* Hands each node's recorded results back in order, until the node runs anew
-* once (it failed or never finished last time, or its input is new); from then
-* on it always runs. A node cut off mid-session continues that session, once.
-*/
-const createReplay = (history, cutOff = /* @__PURE__ */ new Map(), mail, earlier, fanOuts = NO_FAN_OUTS) => {
-	const sessions = new Map(cutOff);
-	const used = /* @__PURE__ */ new Map();
-	const anew = /* @__PURE__ */ new Set();
-	const fresh = /* @__PURE__ */ new WeakSet();
-	/** Fanned nodes whose list was resolved anew: their items can't be replayed. */
-	const renewed = /* @__PURE__ */ new Set();
-	const takeItem = (activation, of) => {
-		const recorded = fanOuts.items.get(activation.id)?.get(activation.round ?? 0);
-		if (recorded !== void 0 && !renewed.has(of) && !carries(fresh, activation.input)) return recorded;
-		anew.add(activation.id);
-		return null;
-	};
-	return {
-		take: (activation) => {
-			const { id } = activation;
-			if (activation.brief !== void 0 || anew.has(id)) return null;
-			if (activation.item !== void 0) return takeItem(activation, activation.item.of);
-			const index = used.get(id) ?? 0;
-			const recorded = history.get(id)?.[index];
-			if (recorded === void 0 || carries(fresh, activation.input)) {
-				anew.add(id);
-				return null;
-			}
-			used.set(id, index + 1);
-			return recorded;
-		},
-		ran: (result) => {
-			fresh.add(result.output);
-		},
-		cutOff: (activation) => {
-			const session = activation.brief === void 0 && (activation.item === void 0 || !renewed.has(activation.item.of)) ? sessions.get(activation.id) : void 0;
-			sessions.delete(activation.id);
-			return session;
-		},
-		listed: (id, round, source) => {
-			const list = fanOuts.lists.get(listKey(id, round));
-			const ranAnew = typeof source === "object" && source !== null && fresh.has(source);
-			if (list !== void 0 && !ranAnew) return list;
-			renewed.add(id);
-			return null;
-		},
-		previousSession: ({ id, item, round = 0 }) => item === void 0 || renewed.has(item.of) ? void 0 : [...fanOuts.items.get(id) ?? []].findLast(([before]) => before < round)?.[1].sessionId,
-		lastOutput: (id) => history.get(id)?.at(-1)?.output,
-		kept: () => [...history.keys(), ...fanOuts.items.keys()],
-		...mail === void 0 ? {} : { mail },
-		...earlier === void 0 ? {} : { earlier }
-	};
-};
-/**
-* The run's `HumanChannel`, answering questions about loops out of rounds as
-* they were answered last time, in order; anything else goes to `human`.
-*/
-const replayLoopAnswers = (human, answers) => {
-	const left = [...answers];
-	return {
-		permit: (request) => human.permit(request),
-		...human.settled === void 0 ? {} : { settled: human.settled },
-		ask: (question) => {
-			const index = left.findIndex((a) => a.question === question.question);
-			const [given] = index === -1 ? [] : left.splice(index, 1);
-			return given === void 0 ? human.ask(question) : Promise.resolve(given.answer);
-		}
-	};
-};
-// ../core/src/store/drafts.ts
-const rowOf = (row) => {
-	const baseHash = text(row, "base_hash");
-	return {
-		project: text(row, "project"),
-		workflow: text(row, "workflow"),
-		text: text(row, "text"),
-		baseHash: baseHash === "" ? null : baseHash,
-		at: text(row, "at")
-	};
-};
-const draftQueries = (db) => {
-	const put = db.prepare("INSERT OR REPLACE INTO workflow_drafts (project, workflow, text, base_hash, at) VALUES (?, ?, ?, ?, ?)");
-	const one = db.prepare("SELECT project, workflow, text, base_hash, at FROM workflow_drafts WHERE project = ? AND workflow = ?");
-	const all = db.prepare("SELECT project, workflow, text, base_hash, at FROM workflow_drafts WHERE project = ? ORDER BY workflow");
-	const drop = db.prepare("DELETE FROM workflow_drafts WHERE project = ? AND workflow = ?");
-	return {
-		putDraft: (draft) => {
-			put.run(draft.project, draft.workflow, draft.text, draft.baseHash, draft.at);
-		},
-		draft: (project, workflow) => {
-			const row = one.get(project, workflow);
-			return row === void 0 ? void 0 : rowOf(row);
-		},
-		drafts: (project) => all.all(project).map((row) => rowOf(row)),
-		dropDraft: (project, workflow) => {
-			drop.run(project, workflow);
-		}
-	};
-};
-/** Gitignored files a session needs as much in a worktree as in the clone. */
-const LOCAL_AGENT_FILES = ["CLAUDE.local.md", ".claude/settings.local.json"];
-/** Where the project's instructions, skills and agents live. */
-const AGENT_PATHSPECS = [
-	":(glob)**/CLAUDE.md",
-	":(glob)**/AGENTS.md",
-	".claude",
-	".agents"
-];
-/** Symlinked agent folders (e.g. `.claude/skills -> ../.ai/skills`), as targets. */
-const symlinkTargets = (root) => {
-	const targets = [];
-	for (const dir of [".claude", ".agents"]) {
-		const base = path.join(root, dir);
-		if (!existsSync(base) || !lstatSync(base).isDirectory()) continue;
-		for (const name of [
-			"skills",
-			"agents",
-			"commands",
-			"rules"
-		]) {
-			const link = path.join(base, name);
-			if (!existsSync(link) || !lstatSync(link).isSymbolicLink()) continue;
-			const target = path.resolve(base, readlinkSync(link));
-			const relative = path.relative(root, target);
-			if (!relative.startsWith("..") && !path.isAbsolute(relative)) targets.push(relative);
-		}
-	}
-	return [...new Set(targets)];
-};
-const statusPaths = async (root, pathspecs) => {
-	const out = await gitOk(root, [
-		"status",
-		"--porcelain=v1",
-		"--untracked-files=all",
-		"--",
-		...pathspecs
-	]);
-	return lines(out).map((line) => line.slice(3));
-};
-/** The project's git root, head, and what a worktree would be missing. */
-const inspectProject = async (cwd) => {
-	const top = await git(cwd, ["rev-parse", "--show-toplevel"]);
-	if (top.code !== 0) return null;
-	const root = top.stdout.trim();
-	const head = await git(root, ["rev-parse", "HEAD"]);
-	if (head.code !== 0) return null;
-	const agent = await statusPaths(root, [...AGENT_PATHSPECS, ...symlinkTargets(root)]);
-	const all = await statusPaths(root, ["."]);
-	return {
-		root,
-		head: head.stdout.trim(),
-		dirtyAgentFiles: agent,
-		dirtyOther: all.length - agent.length
-	};
-};
-/**
-* The gitignored files to copy into a new worktree: every local agent file, and
-* what the repo's `.worktreeinclude` lists (Claude Code's convention). Only
-* files that are also gitignored qualify, so tracked files are never copied.
-*/
-const localFiles = async (root) => {
-	const include = path.join(root, ".worktreeinclude");
-	const candidates = lines(await gitOk(root, [
-		"ls-files",
-		"--others",
-		"--ignored",
-		...LOCAL_AGENT_FILES.map((f) => `--exclude=${f}`),
-		...existsSync(include) ? [`--exclude-from=${include}`] : []
-	]));
-	if (candidates.length === 0) return [];
-	const ignored = await git(root, [
-		"check-ignore",
-		"--",
-		...candidates
-	]);
-	return lines(ignored.stdout);
-};
-const copyInto = (from, to, files) => {
-	const copied = [];
-	for (const file of files) {
-		const target = path.join(to, file);
-		if (existsSync(target) || !existsSync(path.join(from, file))) continue;
-		mkdirSync(path.dirname(target), { recursive: true });
-		cpSync(path.join(from, file), target, { verbatimSymlinks: true });
-		copied.push(file);
-	}
-	return copied;
-};
-/**
-* Creates a worktree at `path` from `base`, with the local files: on a new
-* `branch`, or detached when there is none (`commit: never`). An existing
-* branch is checked out again only when this run created it (`known`): a
-* resumed run's branch outlives its removed worktree. Any other existing branch
-* stops it: Ork never takes over a branch it did not create.
-*/
-const createWorktree = async (options) => {
-	const { root, branch, base } = options;
-	const target = options.path;
-	mkdirSync(path.dirname(target), { recursive: true });
-	if (branch === void 0) {
-		await gitOk(root, [
-			"worktree",
-			"add",
-			"--detach",
-			target,
-			base
-		]);
-		return {
-			path: target,
-			copied: copyInto(root, target, await localFiles(root)),
-			reused: false
-		};
-	}
-	const exists = (await git(root, [
-		"rev-parse",
-		"--verify",
-		"--quiet",
-		`refs/heads/${branch}`
-	])).code === 0;
-	if (exists && options.known !== true) throw new Error(`branch ${branch} already exists, and this run did not create it; Ork never takes over a branch it did not create`);
-	await gitOk(root, exists ? [
-		"worktree",
-		"add",
-		target,
-		branch
-	] : [
-		"worktree",
-		"add",
-		"-b",
-		branch,
-		target,
-		base
-	]);
-	return {
-		path: target,
-		branch,
-		copied: copyInto(root, target, await localFiles(root)),
-		reused: exists
-	};
+	items: /* @__PURE__ */ new Map()
 };
-/** Copies files that exist in `from` and are missing in the worktree. */
-const carryFiles = (from, worktree, files) => copyInto(from, worktree, files.filter((f) => !path.isAbsolute(f) && !f.split(/[\\/]/u).includes("..")));
-/** What git keeps in a worktree's git dir while a rebase, merge or pick runs. */
-const UNDERWAY = [
-	"rebase-merge",
-	"rebase-apply",
-	"MERGE_HEAD",
-	"CHERRY_PICK_HEAD",
-	"REVERT_HEAD"
-];
-/** Whether a rebase, merge, cherry-pick or revert is underway in `worktree`. */
-const gitOperationUnderway = async (worktree) => {
-	const paths = await gitOk(worktree, ["rev-parse", ...UNDERWAY.flatMap((name) => ["--git-path", name])]);
-	return lines(paths).some((file) => existsSync(path.resolve(worktree, file)));
+/** Whether an activation's input carries a result this run made anew. */
+const carries = (fresh, input) => {
+	if (input === void 0) return false;
+	if (fresh.has(input)) return true;
+	const results = input["results"];
+	if (results === null || typeof results !== "object") return false;
+	return Object.values(results).some((value) => value !== null && typeof value === "object" && fresh.has(value));
 };
 /**
-* Commits what a session left uncommitted. The repo's hooks run; when they
-* refuse, the error says why and the worktree keeps the changes. A worktree
-* mid-rebase (or merge, cherry-pick, revert) is left exactly as it is: its
-* changes are the operation's to finish, as a conflict resolver's are.
+* Hands each node's recorded results back in order, until the node runs anew
+* once (it failed or never finished last time, or its input is new); from then
+* on it always runs. A node cut off mid-session continues that session, once.
 */
-const commitLeftovers = async (worktree, message) => {
-	if (await gitOperationUnderway(worktree)) return false;
-	const status = await gitOk(worktree, ["status", "--porcelain"]);
-	if (lines(status).length === 0) return false;
-	await gitOk(worktree, ["add", "-A"]);
-	await gitOk(worktree, [
-		"commit",
-		"-m",
-		message
-	]);
-	return true;
+const createReplay = (history, cutOff = /* @__PURE__ */ new Map(), mail, earlier, fanOuts = NO_FAN_OUTS) => {
+	const sessions = new Map(cutOff);
+	const used = /* @__PURE__ */ new Map();
+	const anew = /* @__PURE__ */ new Set();
+	const fresh = /* @__PURE__ */ new WeakSet();
+	/** Fanned nodes whose list was resolved anew: their items can't be replayed. */
+	const renewed = /* @__PURE__ */ new Set();
+	const takeItem = (activation, of) => {
+		const recorded = fanOuts.items.get(activation.id)?.get(activation.round ?? 0);
+		if (recorded !== void 0 && !renewed.has(of) && !carries(fresh, activation.input)) return recorded;
+		anew.add(activation.id);
+		return null;
+	};
+	return {
+		take: (activation) => {
+			const { id } = activation;
+			if (activation.brief !== void 0 || anew.has(id)) return null;
+			if (activation.item !== void 0) return takeItem(activation, activation.item.of);
+			const index = used.get(id) ?? 0;
+			const recorded = history.get(id)?.[index];
+			if (recorded === void 0 || carries(fresh, activation.input)) {
+				anew.add(id);
+				return null;
+			}
+			used.set(id, index + 1);
+			return recorded;
+		},
+		ran: (result) => {
+			fresh.add(result.output);
+		},
+		cutOff: (activation) => {
+			const session = activation.brief === void 0 && (activation.item === void 0 || !renewed.has(activation.item.of)) ? sessions.get(activation.id) : void 0;
+			sessions.delete(activation.id);
+			return session;
+		},
+		listed: (id, round, source) => {
+			const list = fanOuts.lists.get(listKey(id, round));
+			const ranAnew = typeof source === "object" && source !== null && fresh.has(source);
+			if (list !== void 0 && !ranAnew) return list;
+			renewed.add(id);
+			return null;
+		},
+		previousSession: ({ id, item, round = 0 }) => item === void 0 || renewed.has(item.of) ? void 0 : [...fanOuts.items.get(id) ?? []].findLast(([before]) => before < round)?.[1].sessionId,
+		lastOutput: (id) => history.get(id)?.at(-1)?.output,
+		kept: () => [...history.keys(), ...fanOuts.items.keys()],
+		...mail === void 0 ? {} : { mail },
+		...earlier === void 0 ? {} : { earlier }
+	};
 };
 /**
-* Moves a worktree's branch up to `branch` when it is behind and has nothing of
-* its own, e.g. a child's branch after its owner merged it and moved on.
-*/
-const fastForward = async (worktree, branch) => (await git(worktree, [
-	"merge",
-	"--ff-only",
-	"-q",
-	branch
-])).code === 0;
-/**
-* Merges `branch` into the checkout at `into` with `--no-ff`; aborts on
-* conflict.
+* The run's `HumanChannel`, answering questions about loops out of rounds as
+* they were answered last time, in order; anything else goes to `human`.
 */
-const mergeBranch = async (into, branch, message) => {
-	const merged = await git(into, [
-		"merge",
-		"--no-ff",
-		"--no-edit",
-		"-m",
-		message,
-		branch
-	]);
-	if (merged.code === 0) return { ok: true };
-	const conflicts = lines((await git(into, [
-		"diff",
-		"--name-only",
-		"--diff-filter=U"
-	])).stdout);
-	await git(into, ["merge", "--abort"]);
+const replayLoopAnswers = (human, answers) => {
+	const left = [...answers];
 	return {
-		ok: false,
-		conflicts,
-		error: (merged.stdout + merged.stderr).trim().split("\n").at(-1) ?? "the merge failed"
+		permit: (request) => human.permit(request),
+		...human.settled === void 0 ? {} : { settled: human.settled },
+		ask: (question) => {
+			const index = left.findIndex((a) => a.question === question.question);
+			const [given] = index === -1 ? [] : left.splice(index, 1);
+			return given === void 0 ? human.ask(question) : Promise.resolve(given.answer);
+		}
 	};
 };
-const removeWorktree = async (root, worktree, force = false) => {
-	await gitOk(root, [
-		"worktree",
-		"remove",
-		...force ? ["--force"] : [],
-		worktree
-	]);
+// ../core/src/store/drafts.ts
+const rowOf = (row) => {
+	const baseHash = text(row, "base_hash");
+	return {
+		project: text(row, "project"),
+		workflow: text(row, "workflow"),
+		text: text(row, "text"),
+		baseHash: baseHash === "" ? null : baseHash,
+		at: text(row, "at")
+	};
+};
+const draftQueries = (db) => {
+	const put = db.prepare("INSERT OR REPLACE INTO workflow_drafts (project, workflow, text, base_hash, at) VALUES (?, ?, ?, ?, ?)");
+	const one = db.prepare("SELECT project, workflow, text, base_hash, at FROM workflow_drafts WHERE project = ? AND workflow = ?");
+	const all = db.prepare("SELECT project, workflow, text, base_hash, at FROM workflow_drafts WHERE project = ? ORDER BY workflow");
+	const drop = db.prepare("DELETE FROM workflow_drafts WHERE project = ? AND workflow = ?");
+	return {
+		putDraft: (draft) => {
+			put.run(draft.project, draft.workflow, draft.text, draft.baseHash, draft.at);
+		},
+		draft: (project, workflow) => {
+			const row = one.get(project, workflow);
+			return row === void 0 ? void 0 : rowOf(row);
+		},
+		drafts: (project) => all.all(project).map((row) => rowOf(row)),
+		dropDraft: (project, workflow) => {
+			drop.run(project, workflow);
+		}
+	};
 };
 // ../core/src/worktree/list.ts
 /**
@@ -16275,9 +16645,7 @@ const planLimitQueries = (db) => {
 	const all = db.prepare("SELECT name, status, resets_at, at FROM plan_limits ORDER BY name");
 	const clear = db.prepare("DELETE FROM plan_limits");
 	return {
-		clearPlanLimits: () => {
-			clear.run();
-		},
+		clearPlanLimits: () => Number(clear.run().changes),
 		recordPlanLimit: ({ window, status, resetsAt }, at) => {
 			put.run(window, status, resetsAt ?? null, at);
 		},
@@ -17690,7 +18058,7 @@ const capsHere = (home, place) => {
 	try {
 		const rules = place === void 0 ? void 0 : loadProject(place.root, placeFiles(place).rules);
 		return {
-			problems: [...user.diagnostics, ...rules?.diagnostics ?? []].map((found) => found.message),
+			problems: [...user.diagnostics, ...rules?.diagnostics ?? []].map((found) => diagnosticText(found)),
 			caps: capsOf(user.settings?.quotas, rules?.project?.quotas, place?.root)
 		};
 	} catch (error) {
@@ -17843,95 +18211,6 @@ const usageReport = (rows, cpu = []) => {
 		hints: hintsOf(totals, groups.node)
 	};
 };
-// ../core/src/worktree/clean.ts
-/**
-* @file What `ork worktrees clean` and `ork worktrees remove` do with what
-*   list.ts reads: the plan (what goes, what's kept and why), by one rule for
-*   every caller, and carrying it out. The CLI and the Worktrees panel both
-*   plan here, so neither removes what the other would keep.
-*/
-/** What names an item for `remove`: its branch, or its worktree's path. */
-const keyOf = (item) => item.branch ?? item.path ?? `${item.runId}/${item.nodeId}`;
-/** The reasons no `force` overrides: removing would break something. */
-const MAIN_CHECKOUT = "checked out in the main checkout";
-const RUN_GOING = "its run is still going";
-const NOT_ORKS = "not created by Ork";
-const kept = (item, skip) => ({
-	item,
-	removeWorktree: false,
-	deleteBranch: false,
-	skip
-});
-/** What clean does with one item. */
-const cleanStep = (item, options) => {
-	if (!item.recorded) return kept(item, NOT_ORKS);
-	if (item.inMainCheckout) return kept(item, MAIN_CHECKOUT);
-	if (item.heldBy !== void 0) return kept(item, `checked out in ${item.heldBy}`);
-	if (options.live?.has(item.runId) === true) return kept(item, RUN_GOING);
-	if (item.dirty && !options.force) return kept(item, "uncommitted changes");
-	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return kept(item, "commits on no branch");
-	const removable = item.path !== null && !item.missing;
-	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: false,
-		skip: "branch not merged"
-	};
-	return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: options.branches && item.branch !== void 0
-	};
-};
-/** Whether a step drops a worktree whose folder is gone, by its own path. */
-const stepPrunes = (step) => step.item.missing && step.item.path !== null && step.skip === void 0;
-/** Whether a step does anything. */
-const stepActs = (step) => step.removeWorktree || step.deleteBranch || stepPrunes(step);
-/**
-* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
-* unmerged branch, or a detached worktree holding commits no branch has, is
-* kept unless `force`; one checked out in the main checkout or in a worktree
-* Ork didn't create, whose run is still going, or an `ork/` branch no run
-* recorded creating, is kept even then.
-*/
-const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => filter.key === void 0 || keyOf(item) === filter.key).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
-/**
-* Carries out one step; what it did goes into `done` as it goes. It touches
-* only its own item: a missing worktree is dropped by its own path (`git
-* worktree remove`), never by `git worktree prune`, which would drop every
-* missing worktree in the repository, the user's own included.
-*/
-const applyStep = async (root, step, force, done) => {
-	const { item } = step;
-	if (stepPrunes(step) && !step.removeWorktree && item.path !== null) {
-		await gitOk(root, [
-			"worktree",
-			"remove",
-			item.path
-		]);
-		done.push(`pruned ${item.path}`);
-	}
-	if (step.removeWorktree && item.path !== null) {
-		await removeWorktree(root, item.path, force);
-		done.push(`removed ${item.path}`);
-	}
-	if (step.deleteBranch && item.branch !== void 0) {
-		await gitOk(root, [
-			"branch",
-			force ? "-D" : "-d",
-			item.branch
-		]);
-		done.push(`deleted ${item.branch}`);
-	}
-};
-/**
-* Carries out a clean plan, step by step. What it did goes into `done` as it
-* goes, so a caller still has it when git fails halfway.
-*/
-const applyClean = async (root, steps, force, done = []) => {
-	for (const step of steps) await applyStep(root, step, force, done);
-	return done;
-};
 // ../core/src/worktree/names.ts
 /**
 * @file The names Ork gives a node's worktree and branch, from the project's
@@ -18731,4 +19010,4 @@ const createWorkspace = (options) => {
 		close
 	};
 };
-export { resolveInputs as $, createFeedback as $n, CheckReportSchema as $r, sessionDriver as $t, isNewer as A, stillTheSameProcess as An, shownPath as Ar, walkSummary as At, watchingPid as B, outcomeEnd as Bn, WorkflowEditSchema as Br, stoppedEnd as Bt, capsHere as C, liveStatus as Cn, hasInRepoFiles as Cr, explainWorkflowText as Ct, runningScript as D, slotWaitsOf as Dn, placeFor as Dr, reportSchemaFor as Dt, runningRunIds as E, runStatus as En, placeFiles as Er, parseReport as Et, triggerStanding as F, gitRulesOf as Fn, estimateTokens as Fr, runScope as Ft, applyPrune as G, FEEDBACK_SEVERITIES as Gn, beforeOf as Gr, programFound as Gt, isNodeEvent as H, END_KINDS as Hn, newWorkflowText as Hr, slotClock as Ht, declaredTriggers as I, loadProject as In, guardedBase as Ir, calledWorkflows as It, listOrkWorktrees as J, planPost as Jn, parseWorkflow as Jr, gitOk as Jt, planPrune as K, FEEDBACK_TARGETS as Kn, programsRunBy as Kr, startAt as Kt, readProjectTriggers as L, machineRulesOf as Ln, plainPathInside as Lr, lockWaitLine as Lt, lateTriggers as M, nestItems as Mn, inside as Mr, MESSAGE_LIMIT as Mt, triggersReport as N, countedTokens as Nn, projectRootOf as Nr, userMessageText as Nt, detectInstaller as O, templateOf$1 as On, projectsHome as Or, checkWorkflowText as Ot, createWatcher as P, PROJECT_FILE as Pn, LESSON_CAP_TOKENS as Pr, heldTimeout as Pt, parseInputPairs as Q, redact as Qn, WorkflowSchema as Qr, namingNoDriver as Qt, workflowTextHash as R, createSignals as Rn, writePlainFile as Rr, endedWith as Rt, usageReport as S, knownExperiments as Si, tellLiveRun as Sn, loadAgents as Sr, usd as St, releaseNotes as T, pausedOf as Tn, newProjectId as Tr, planNodeSession as Tt, openStore as U, endFor as Un, readDocument as Ur, slotWaitLine as Ut, activeTree as V, END_DETAIL_LIMIT as Vn, applyEdits as Vr, declaredProblem as Vt, storePath as W, FEEDBACK_KINDS as Wn, renameNodeTypes as Wr, lowerChild as Wt, createReplay as X, sendPost as Xn, markValue as Xr, envReadsOf as Xt, inspectProject as Y, runGh as Yn, serializeWorkflow as Yr, clearGitLocalEnv as Yt, replayLoopAnswers as Z, publishPost as Zn, EdgeInputSchema as Zr, modelDriver as Zt, keyOf as _, AGENT_DRIVERS as _i, linkNodes as _n, toolLinks as _r, followEvents as _t, planRemove as a, DriverSchema as ai, createFollowUps as an, renderTemplate as ar, scriptRefusal as at, stepPrunes as b, EXPERIMENTS as bi, requestPause as bn, deleteAgent as br, limitsReport as bt, repoRoot as c, timeoutMs as ci, recordPublished as cn, socketPath as cr, followRunTree as ct, planLine as d, integrationFor as di, deliverFollowUp as dn, maskReplacer as dr, createCalls as dt, expandEdge as ei, nodeSays as en, fingerprint as er, budgetWarnings as et, removeRefusal as f, PREFERRED_DRIVER as fi, followUpProblem as fn, maskSecrets as fr, adoptedCalls as ft, cleanStep as g, ORK_LAYOUT as gi, endLinksOf as gn, linkTools as gr, detachRun as gt, applyClean as h, AGENT_TOOL_LAYOUTS as hi, addressOf as hn, planMoveInto as hr, DETACHED_ENV as ht, lostWork as i, isToolNode as ii, serversIn as in, parseTemplate as ir, TOO_LONG as it, parseVersion as j, isItem as jn, workflowDirOf as jr, startRun as jt, compareVersions as k, processAlive as kn, runDirOf as kr, walkChecks as kt, labelOf as l, INTEGRATIONS as li, startFollowUpChecks as ln, socketRoom as lr, answerDecision as lt, resolveBase as m, readyDriver as mi, DEFAULT_FOLLOW_UPS_RULE as mn, applySteps as mr, resumable as mt, resumedOptions as n, NodeSchema as ni, MCP_FILE as nn, targetOf as nr, sessionRefusals as nt, projectHead as o, NodeIdSchema as oi, checkFollowUpsDue as on, readCondition as or, sendFromScript as ot, stateParts as p, driverChecks as pi, liveSessionOf as pn, planAgentMigration as pr, detachResume as pt, createdWorktrees as q, DISCUSSIONS as qn, renderJsonSchema as qr, git as qt, applyRemove as r, isClaudeNode as ri, mcpNotText as rn, evaluate as rr, driverQueues as rt, readWorktrees as s, retiredDriverHint as si, markDue as sn, serveRun as sr, createRelay as st, createWorkspace as t, settingsOf as ti, declaredOutputOf as tn, normalizeTitle as tr, driverRefusals as tt, mergeStateOf as u, TOOL_PREFIX as ui, takeFollowUps as un, MASK as ur, pendingDecisions as ut, planClean as v, DRIVER_IDS as vi, unlinkNodes as vn, toolsInUse as vr, NOT_STARTED as vt, planUpgrade as w, lockWaitsOf as wn, inRepoPlace as wr, explainSession as wt, USAGE_DIMENSIONS as x, experimentsOn as xi, requestStop as xn, catalogAgent as xr, planReason as xt, stepActs as y, firstLine as yi, requestContinue as yn, createAgent as yr, limitsNow as yt, takeWatchLock as z, endOf as zn, skillsIn as zr, failedWith as zt };
+export { sendFromScript as $, DISCUSSIONS as $n, programsRunBy as $r, gitOk as $t, declaredTriggers as A, lockWaitsOf as An, hasInRepoFiles as Ar, endedWith as At, planPrune as B, PROJECT_FILE as Bn, projectRootOf as Br, feedbackListTable as Bt, compareVersions as C, ORK_LAYOUT as Ci, linkNodes as Cn, toolLinks as Cr, startRun as Ct, triggersReport as D, EXPERIMENTS as Di, requestStop as Dn, AGENT_SOURCES as Dr, runScope as Dt, lateTriggers as E, firstLine as Ei, requestPause as En, deleteAgent as Er, heldTimeout as Et, activeTree as F, processAlive as Fn, projectsHome as Fr, slotWaitLine as Ft, parseInputPairs as G, endOf as Gn, writePlainFile as Gr, applyClean as Gt, listOrkWorktrees as H, loadProject as Hn, estimateTokens as Hr, runListTable as Ht, isNodeEvent as I, stillTheSameProcess as In, runDirOf as Ir, lowerChild as It, driverRefusals as J, END_KINDS as Jn, applyEdits as Jr, planClean as Jt, resolveInputs as K, outcomeEnd as Kn, skillsIn as Kr, cleanStep as Kt, openStore as L, isItem as Ln, shownPath as Lr, programFound as Lt, workflowTextHash as M, runStatus as Mn, newProjectId as Mr, stoppedEnd as Mt, takeWatchLock as N, slotWaitsOf as Nn, placeFiles as Nr, declaredProblem as Nt, createWatcher as O, experimentsOn as Oi, tellLiveRun as On, catalogAgent as Or, calledWorkflows as Ot, watchingPid as P, templateOf$1 as Pn, placeFor as Pr, slotClock as Pt, scriptRefusal as Q, FEEDBACK_TARGETS as Qn, beforeOf as Qr, git as Qt, storePath as R, nestItems as Rn, workflowDirOf as Rr, startAt as Rt, detectInstaller as S, AGENT_TOOL_LAYOUTS as Si, endLinksOf as Sn, linkTools as Sr, walkSummary as St, parseVersion as T, DRIVER_IDS as Ti, requestContinue as Tn, createAgent as Tr, userMessageText as Tt, createReplay as U, machineRulesOf as Un, guardedBase as Ur, usageListTable as Ut, createdWorktrees as V, gitRulesOf as Vn, LESSON_CAP_TOKENS as Vr, followUpListTable as Vt, replayLoopAnswers as W, createSignals as Wn, plainPathInside as Wr, worktreeListTable as Wt, driverQueues as X, FEEDBACK_KINDS as Xn, readDocument as Xr, stepPrunes as Xt, sessionRefusals as Y, endFor as Yn, newWorkflowText as Yr, stepActs as Yt, TOO_LONG as Z, FEEDBACK_SEVERITIES as Zn, renameNodeTypes as Zr, inspectProject as Zt, capsHere as _, TOOL_PREFIX as _i, deliverFollowUp as _n, maskReplacer as _r, planNodeSession as _t, planRemove as a, WorkflowSchema as ai, nodeSays as an, createFeedback as ar, adoptedCalls as at, runningRunIds as b, driverChecks as bi, DEFAULT_FOLLOW_UPS_RULE as bn, applySteps as br, checkWorkflowText as bt, repoRoot as c, settingsOf as ci, mcpNotText as cn, targetOf as cr, DETACHED_ENV as ct, planLine as d, isToolNode as di, createFollowUps as dn, renderTemplate as dr, NOT_STARTED as dt, renderJsonSchema as ei, clearGitLocalEnv as en, planPost as er, createRelay as et, removeRefusal as f, DriverSchema as fi, checkFollowUpsDue as fn, readCondition as fr, limitsNow as ft, usageReport as g, INTEGRATIONS as gi, takeFollowUps as gn, MASK as gr, explainSession as gt, USAGE_DIMENSIONS as h, timeoutMs as hi, startFollowUpChecks as hn, socketRoom as hr, explainWorkflowText as ht, lostWork as i, EdgeInputSchema as ii, sessionDriver as in, redact as ir, createCalls as it, readProjectTriggers as j, pausedOf as jn, inRepoPlace as jr, failedWith as jt, triggerStanding as k, knownExperiments as ki, liveStatus as kn, loadAgents as kr, lockWaitLine as kt, labelOf as l, NodeSchema as li, serversIn as ln, evaluate as lr, detachRun as lt, resolveBase as m, retiredDriverHint as mi, recordPublished as mn, socketPath as mr, planReason as mt, resumedOptions as n, serializeWorkflow as ni, modelDriver as nn, sendPost as nr, answerDecision as nt, projectHead as o, CheckReportSchema as oi, declaredOutputOf as on, fingerprint as or, detachResume as ot, stateParts as p, NodeIdSchema as pi, markDue as pn, serveRun as pr, limitsReport as pt, budgetWarnings as q, END_DETAIL_LIMIT as qn, WorkflowEditSchema as qr, keyOf as qt, applyRemove as r, markValue as ri, namingNoDriver as rn, publishPost as rr, pendingDecisions as rt, readWorktrees as s, expandEdge as si, MCP_FILE as sn, normalizeTitle as sr, resumable as st, createWorkspace as t, parseWorkflow as ti, envReadsOf as tn, runGh as tr, followRunTree as tt, mergeStateOf as u, isClaudeNode as ui, FOLLOW_UP_KINDS as un, parseTemplate as ur, followEvents as ut, planUpgrade as v, integrationFor as vi, followUpProblem as vn, maskSecrets as vr, parseReport as vt, isNewer as w, AGENT_DRIVERS as wi, unlinkNodes as wn, toolsInUse as wr, MESSAGE_LIMIT as wt, runningScript as x, readyDriver as xi, addressOf as xn, planMoveInto as xr, walkChecks as xt, releaseNotes as y, PREFERRED_DRIVER as yi, liveSessionOf as yn, planAgentMigration as yr, reportSchemaFor as yt, applyPrune as z, countedTokens as zn, inside as zr, decisionListTable as zt };