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

package/dist/__build_info__-Bsb1kjgF.mjs

@@ -0,0 +1,340 @@
+import { A as isNewer, j as parseVersion, k as compareVersions } from "./src-Dr_fTSu-.mjs";
+import path from "node:path";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+// ../core/src/follow-ups/change.ts
+/** The project's follow-up whose id is, or starts with, `prefix`. */
+const findFollowUp = (rows, project, prefix) => {
+	const exact = rows.followUp(project, prefix);
+	if (exact !== void 0) return {
+		ok: true,
+		followUp: exact
+	};
+	const matches = prefix === "" ? [] : rows.followUps(project).filter((f) => f.id.startsWith(prefix));
+	const [only, other] = matches;
+	if (only === void 0) return {
+		ok: false,
+		error: `No follow-up \`${prefix}\` in this project.`
+	};
+	if (other !== void 0) return {
+		ok: false,
+		error: `\`${prefix}\` matches ${matches.map((f) => f.id).join(", ")}; give more of the id.`
+	};
+	return {
+		ok: true,
+		followUp: only
+	};
+};
+/** Which statuses each action starts from, and where it goes. */
+const ACTIONS = {
+	done: {
+		from: ["waiting", "due"],
+		to: () => "done",
+		note: "done"
+	},
+	drop: {
+		from: ["waiting", "due"],
+		to: () => "dropped",
+		note: "dropped"
+	},
+	reopen: {
+		from: ["done", "dropped"],
+		to: (f) => f.due === "now" ? "due" : "waiting",
+		note: "reopened"
+	},
+	due: {
+		from: ["waiting"],
+		to: () => "due",
+		note: "marked due"
+	}
+};
+/** Why `action` can't be done to `f` now, or `undefined`. */
+const refusal = (f, action) => {
+	const rule = ACTIONS[action];
+	return rule.from.includes(f.status) ? void 0 : `${f.id} is ${f.status}, so it can't be ${rule.note}.`;
+};
+const check = (f, action) => {
+	const error = refusal(f, action);
+	return error === void 0 ? { ok: true } : {
+		ok: false,
+		why: `it is ${f.status}`,
+		error
+	};
+};
+const postCheck = (f) => {
+	const open = f.status === "waiting" || f.status === "due";
+	if (f.kind !== "message" || f.draft?.channel !== "github") return {
+		ok: false,
+		why: "not drafted for the github channel",
+		error: "only a message drafted for the github channel is posted; send the others yourself"
+	};
+	return open ? { ok: true } : {
+		ok: false,
+		why: `it is ${f.status}`,
+		error: `${f.id} is ${f.status}, so it is not posted.`
+	};
+};
+const followUpActions = (f) => ({
+	done: check(f, "done"),
+	drop: check(f, "drop"),
+	reopen: check(f, "reopen"),
+	due: check(f, "due"),
+	post: postCheck(f)
+});
+/** Applies `action` to `followUp`, and keeps it. */
+const changeFollowUp = (rows, followUp, action, now = () => (/* @__PURE__ */ new Date()).toISOString()) => {
+	const rule = ACTIONS[action];
+	const refused = refusal(followUp, action);
+	if (refused !== void 0) return {
+		ok: false,
+		error: refused
+	};
+	const { note: _old, ...rest } = followUp;
+	const changed = {
+		...rest,
+		status: rule.to(followUp),
+		note: rule.note,
+		updatedAt: now()
+	};
+	rows.putFollowUp(changed);
+	return {
+		ok: true,
+		followUp: changed
+	};
+};
+/**
+* Why a due follow-up is due, read from the note `due.ts` left: its ref merged,
+* its date came, its ref closed unmerged, or a person marked it. `undefined`
+* for one that is not due, or was due from the start.
+*/
+const dueCause = (f) => {
+	if (f.status !== "due" || f.note === void 0) return void 0;
+	if (f.note.includes("closed without merging")) return "closed-unmerged";
+	if (f.note.endsWith(" merged")) return "merged";
+	if (f.note.startsWith("due on ")) return "overdue";
+	return f.note === "marked due" ? "marked" : void 0;
+};
+// ../core/src/remote/session.ts
+const chattable = (type) => type === "agent.leader" || type === "agent.worker";
+/** Reads `node`'s session from a run's events, and every node's last output. */
+const nodeSession = (events, node) => {
+	const session = {
+		known: false,
+		chattable: false,
+		running: false
+	};
+	const outputs = {};
+	for (const { event } of events) {
+		if (event.type === "run.started") {
+			const declared = event.nodes.find((n) => n.id === node);
+			if (declared !== void 0) {
+				session.known = true;
+				session.chattable = chattable(declared.type);
+			}
+		}
+		if (event.type === "node.finished") outputs[event.id] = event.output;
+		if (!("id" in event) || event.id !== node) continue;
+		if (event.type === "node.started") {
+			session.known = true;
+			session.chattable = chattable(event.nodeType);
+			session.running = true;
+		}
+		if (event.type === "node.finished") session.running = false;
+		if (event.type === "worktree" && event.action === "created") session.checkout = {
+			path: event.path,
+			...event.branch === void 0 ? {} : { branch: event.branch },
+			own: true,
+			owner: node
+		};
+		if (event.type !== "node.event") continue;
+		const inner = event.event;
+		if (inner.fork === true) continue;
+		if (inner.type === "session.started") {
+			session.sessionId = inner.sessionId;
+			if (inner.cwd !== void 0) session.cwd = inner.cwd;
+			if (inner.driver !== void 0) session.driver = inner.driver;
+			if (inner.model !== "") session.model = inner.model;
+		}
+		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
+	}
+	return {
+		session,
+		outputs
+	};
+};
+/** The dist-tags every install follows, toward and after 1.0.0. */
+const CHANNEL_TAGS = [
+	"latest",
+	"alpha",
+	"beta",
+	"rc"
+];
+/** The dist-tag of snapshots from `main`, followed only by a canary. */
+const CANARY_TAG = "canary";
+const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (record, key) => {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+};
+const notifiedOf = (value) => {
+	if (!isRecord(value)) return void 0;
+	const version = text(value, "version");
+	const at = text(value, "at");
+	return version === void 0 || at === void 0 ? void 0 : {
+		version,
+		at
+	};
+};
+/** The cache, or `null` when there is none or it cannot be read. */
+const readUpdateCache = (file) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+	if (!isRecord(parsed)) return null;
+	const checkedAt = text(parsed, "checkedAt");
+	if (checkedAt === void 0) return null;
+	const latest = text(parsed, "latest");
+	const notified = notifiedOf(parsed["notified"]);
+	return {
+		checkedAt,
+		...latest === void 0 ? {} : { latest },
+		...notified === void 0 ? {} : { notified }
+	};
+};
+/** Writes the cache whole (a temporary file, then a rename). */
+const writeUpdateCache = (file, cache) => {
+	mkdirSync(path.dirname(file), { recursive: true });
+	const temporary = `${file}.${process.pid}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
+	renameSync(temporary, file);
+};
+const age = (iso, now) => {
+	const time = Date.parse(iso);
+	return Number.isNaN(time) ? Infinity : now.getTime() - time;
+};
+/** Whether it is time to ask the registry again. */
+const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
+/** Whether `version` is a canary snapshot: its pre-release starts `canary`. */
+const isCanary = (version) => parseVersion(version)?.pre[0]?.startsWith(CANARY_TAG) === true;
+/**
+* The newest version, by semver precedence, among the dist-tags `current`
+* follows: the channel tags, and `canary` too when `current` is a canary. A tag
+* whose value doesn't parse is skipped; `null` when none does.
+*/
+const newestTagged = (tags, current) => {
+	return (current !== void 0 && isCanary(current) ? [...CHANNEL_TAGS, "canary"] : CHANNEL_TAGS).flatMap((tag) => {
+		const value = tags[tag];
+		const version = typeof value === "string" ? parseVersion(value) : null;
+		return typeof value === "string" && version !== null ? [{
+			value,
+			version
+		}] : [];
+	}).reduce((best, candidate) => best === null || compareVersions(candidate.version, best.version) > 0 ? candidate : best, null)?.value ?? null;
+};
+/**
+* The newest version on the registry that the running version follows ({@link
+* newestTagged}), or `null` on any failure.
+*/
+const fetchLatest = async (name, options = {}) => {
+	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
+	const get = options.fetch ?? globalThis.fetch;
+	try {
+		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
+			headers: { accept: "application/json" },
+			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
+		});
+		if (!response.ok) return null;
+		const tags = await response.json();
+		return isRecord(tags) ? newestTagged(tags, options.current) : null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Asks the registry and records the answer. A failed check is recorded too, so
+* an offline machine is not asked again until the interval passes; the last
+* known version is kept. `options.current` is the running version.
+*/
+const refreshUpdateCache = async (file, name, now, options = {}) => {
+	const before = readUpdateCache(file);
+	const latest = await fetchLatest(name, options) ?? before?.latest;
+	const cache = {
+		...before,
+		checkedAt: now.toISOString(),
+		...latest === void 0 ? {} : { latest }
+	};
+	writeUpdateCache(file, cache);
+	return cache;
+};
+/** The newer version the cache knows of, if any. */
+const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
+/**
+* The version to tell the user about now: newer than theirs, and not already
+* told today. `null` when there is nothing to say.
+*/
+const pendingNotice = (cache, current, now) => {
+	const newer = newerVersion(cache, current);
+	if (newer === null) return null;
+	const told = cache?.notified;
+	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
+};
+// ../core/src/update/switches.ts
+/**
+* @file The environment's say over the update check (ADR-038): the variables
+*   that turn it off (`ORK_NO_UPDATE_CHECK`, the common `NO_UPDATE_NOTIFIER`,
+*   and `CI`), and the registry to ask instead of npm's. The CLI adds its own
+*   rules about where a notice may go; the server behind `ork ui` uses only
+*   these.
+*/
+/** Turns the automatic check and its notice off. */
+const NO_UPDATE_ENV = "ORK_NO_UPDATE_CHECK";
+/** A registry to ask instead of npm's, e.g. a company mirror. */
+const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
+/** The variables that turn the check off, in the order they are looked at. */
+const UPDATE_SWITCHES = [
+	NO_UPDATE_ENV,
+	"NO_UPDATE_NOTIFIER",
+	"CI"
+];
+/** Set to anything but empty, `0` or `false`. */
+const isSwitchedOn = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+/** The variable that turns the check off in `env`, or `null` when none does. */
+const updateSwitchOff = (env) => UPDATE_SWITCHES.find((name) => isSwitchedOn(env[name])) ?? null;
+/** The registry `ORK_UPDATE_REGISTRY` names, if it names one. */
+const registryOf = (env) => {
+	const registry = env[UPDATE_REGISTRY_ENV];
+	return registry === void 0 || registry === "" ? void 0 : registry;
+};
+/** The host of a registry that isn't an http(s) URL, past any `user:pass@`. */
+const hostOf = (registry) => registry.replace(/^[a-z][\w+.-]*:\/\//iu, "").replace(/^[^/?#]*@/u, "").split(/[/?#]/u)[0] ?? "";
+/**
+* The registry as it may be shown (on a page, in a message): an http(s) URL
+* without its user name and password, which a mirror's URL may carry; anything
+* else only as its host.
+*/
+const registryShown = (registry) => {
+	try {
+		const url = new URL(registry);
+		if (url.protocol === "http:" || url.protocol === "https:") {
+			if (url.username === "" && url.password === "") return registry;
+			url.username = "";
+			url.password = "";
+			return url.href;
+		}
+	} catch {}
+	return hostOf(registry);
+};
+// src/__build_info__.ts
+/**
+* @file The published package's name and version, bound to
+*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
+*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
+*   fails when it is stale.
+*/
+const ORK_NAME = "@krapht/ork";
+const ORK_VERSION = "1.0.0-alpha.15";
+export { dueCause as _, registryShown as a, fetchLatest as c, readUpdateCache as d, refreshUpdateCache as f, changeFollowUp as g, nodeSession as h, registryOf as i, newerVersion as l, writeUpdateCache as m, ORK_VERSION as n, updateSwitchOff as o, updateCachePath as p, isSwitchedOn as r, checkDue as s, ORK_NAME as t, pendingNotice as u, findFollowUp as v, followUpActions as y };

package/dist/{store-CM3cERGl.mjs → attach-BHO3X3cf.mjs}

@@ -1,8 +1,7 @@
-import { $ as followEvents, C as isNodeEvent, Ft as slotWaitLine, On as maskSecrets, _t as liveStatus, in as END_KINDS, nn as outcomeEnd, tn as endOf, w as openStore } from "./src-BeR6f70A.mjs";
-import { n as pendingDecisions, t as answerDecision } from "./decide-DuIHACvH.mjs";
-import { E as readKeys, S as cut, T as wrap, _ as withdrawn, a as style, c as confirmOrStop, d as apply, f as bold, g as readLine, h as interrupt, i as plain, m as createRegion, n as cost, p as paint, v as canKey, w as widthOf, x as termOf, y as plainEnv } from "./output-CnRzrbUM.mjs";
-import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-CyeB_rhR.mjs";
-import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CIy8tAyX.mjs";
+import { Bn as outcomeEnd, H as isNodeEvent, Hn as END_KINDS, Lt as lockWaitLine, Ut as slotWaitLine, _t as followEvents, ct as followRunTree, fr as maskSecrets, lt as answerDecision, ut as pendingDecisions, zn as endOf } from "./src-Dr_fTSu-.mjs";
+import { C as termOf, D as wrap, E as widthOf, O as readKeys, _ as interrupt, a as plain, b as canKey, g as createRegion, h as paint, m as bold, n as cost, p as apply, r as costOf, s as style, u as confirmOrStop, v as readLine, w as cut, x as plainEnv, y as withdrawn } from "./output-B1kwo0YU.mjs";
+import { n as chip, r as nodeChip, t as CHIP_LABELS } from "./chips-BqcT58qr.mjs";
+import { a as createView, i as formatBusEvent, n as nodeVerdict, o as styler, r as firstLine, t as hasConflict } from "./verdict-CMvPCpWC.mjs";
 import { createInterface } from "node:readline/promises";
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
@@ -219,66 +218,6 @@ const createDecisionQueue = (options) => {
 		}
 	};
 };
-// ../core/src/remote/follow-tree.ts
-/**
-* Calls `onEvent` for each event of `root` and of the runs it called, once
-* each. A called run's stored events come right after the `call.started` that
-* started it; live events as they arrive. Ends when the root ends or `signal`
-* aborts.
-*/
-const followRunTree = async (store, root, onEvent, options = {}) => {
-	/** Every run followed, with its call path, in the order found. */
-	const paths = /* @__PURE__ */ new Map([[root, []]]);
-	/** Each run's last event seen, for the catch-up once the root ends. */
-	const seqs = /* @__PURE__ */ new Map();
-	const followers = [];
-	/** Ends the called runs' following once the root's has ended. */
-	const halt = new AbortController();
-	const signal = options.signal === void 0 ? halt.signal : AbortSignal.any([options.signal, halt.signal]);
-	const handle = (run, path) => (stored) => {
-		seqs.set(run, stored.seq);
-		onEvent({
-			run,
-			path,
-			stored
-		});
-		const { event } = stored;
-		if (event.type === "call.started" && !paths.has(event.run)) follow(event.run, [...path, event.node]);
-	};
-	const follow = (run, path) => {
-		paths.set(run, path);
-		followers.push(followEvents(store, run, handle(run, path), {
-			...options,
-			follow: true,
-			after: seqs.get(run) ?? 0,
-			signal
-		}));
-	};
-	/** Waits for every follower, including those started while waiting. */
-	const settle = async () => {
-		while (followers.length > 0) await Promise.all(followers.splice(0));
-	};
-	const end = await followEvents(store, root, handle(root, []), {
-		...options,
-		follow: true
-	});
-	halt.abort();
-	await settle();
-	if (end !== "aborted") {
-		for (const [run, path] of [...paths].slice(1)) followers.push(followEvents(store, run, handle(run, path), {
-			follow: false,
-			after: seqs.get(run) ?? 0
-		}));
-		await settle();
-	}
-	return {
-		end,
-		stillRunning: [...paths.keys()].slice(1).filter((id) => {
-			const [run] = store.lookup(id);
-			return run !== void 0 && liveStatus(run) === "running";
-		})
-	};
-};
 // src/human-card.ts
 /** Lines of context a card shows before `d` (or `--verbose`) shows the rest. */
 const CONTEXT_LINES = 6;
@@ -830,8 +769,9 @@ const createTerminalHuman = (io) => {
 /**
 * @file How a node's end reads on the terminal (specs/runtime/session-ends.md):
 *   its kind's label and Ork's own message, a note for a kind that may pass,
-*   the setup hint for an account or provider end, and the scrubbed raw detail
-*   only when asked for. Never the provider's own words first.
+*   the setup hint for an account or provider end, the last line of a failed
+*   tool's own stderr, and the scrubbed raw detail only when asked for. Never
+*   the provider's own words first.
 */
 /** What a transient kind says in place of its hint on the log line. */
 const MAY_PASS = "(may pass; ork resume retries)";
@@ -840,11 +780,17 @@ const endHeadline = (end) => {
 	const { label, transient } = END_KINDS[end.kind];
 	return `${label}: ${end.message}${transient ? ` ${MAY_PASS}` : ""}`;
 };
+/** The longest a script's last stderr line is shown on the log line. */
+const LAST_LINE_LIMIT = 200;
+/** The last non-empty line of a scrubbed detail, cut; "" when there is none. */
+const lastLine = (detail) => (detail ?? "").split("\n").map((line) => line.trim()).findLast((line) => line !== "")?.slice(0, LAST_LINE_LIMIT) ?? "";
 /**
 * The lines under a headline: the hint for an account or provider end (what to
 * set up) or whenever `full` (`--verbose`, one node's log), and the detail only
 * when `full`. A transient kind's hint is its retry wording, which the headline
-* already says, so it is not printed twice.
+* already says, so it is not printed twice. A failed tool (`command_failed`)
+* also shows the last line of its detail without `full`: a script's stderr is
+* the workflow's own message, not the provider's.
 */
 const endLines = (end, full, term = createView().term) => {
 	const style = styler(term);
@@ -853,6 +799,10 @@ const endLines = (end, full, term = createView().term) => {
 	const lines = [];
 	if (hint !== "" && !transient && (full || setup)) lines.push(`  ${style("dim", hint)}`);
 	if (full && end.detail !== void 0) lines.push(style("dim", "  details:"), ...end.detail.split("\n").map((line) => style("dim", `    ${line}`)));
+	else if (end.kind === "command_failed") {
+		const last = lastLine(end.detail);
+		if (last !== "") lines.push(`  ${style("dim", last)}`);
+	}
 	return lines;
 };
 /**
@@ -869,6 +819,21 @@ const formatFinished = (event, tag, verbose, term = createView().term, rest = ta
 	if (!(!event.ok && end.kind !== "reported_failure" && (event.end !== void 0 || end.kind !== "unknown"))) return [`${tag} ${mark} ${nodeVerdict(event.output, event.ok, event.error)}${spent}`];
 	return [`${tag} ${mark} ${endHeadline(end)}${spent}`, ...endLines(end, verbose, term).map((line) => `${rest} ${line}`)];
 };
+// src/run/format-machine.ts
+/**
+* @file How a node's waits for the machine read in `ork logs`: a slot for a
+*   heavy command (ADR-080) and a lock (RFC-016), each naming who holds it.
+*/
+/** Whether `event` is a slot's or a lock's. */
+const isMachineEvent = (event) => event.type.startsWith("slot.") || event.type.startsWith("lock.");
+/** A slot or lock event's line, after its node's tag. */
+const machineLine = (event, style) => {
+	if (event.type === "slot.waiting") return style("yellow", `‖ ${slotWaitLine(event.holders)}`);
+	if (event.type === "slot.taken") return style("dim", "▸ got a check slot");
+	if (event.type === "lock.waiting") return style("yellow", `‖ ${lockWaitLine(event.lock, event.holders)}`);
+	if (event.type === "lock.taken") return style("dim", `▸ holds ${event.lock}`);
+	return style("dim", `▸ let ${event.lock} go`);
+};
 // src/run/format-outcome.ts
 /**
 * @file How a finished session reads on the terminal: its report or its end,
@@ -972,7 +937,7 @@ const formatRunResult = (result, term = createView().term) => {
 	const ran = result.nodes.filter((n) => n.runs > 0).length;
 	const skipped = result.skipped ?? result.nodes.length - ran;
 	const handled = result.failuresHandled ?? 0;
-	const lines = ["", `${mark} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
+	const lines = ["", `${mark} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${costOf(result.costUsd, result.partial, result.tokens)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
 	for (const kept of result.worktrees) lines.push(`  ${kept.id}: ${kept.branch ?? "detached"} ${style("dim", `at ${kept.path} (${kept.reason})`)}`);
 	for (const reason of result.reasons) lines.push(`  ${style("red", reason)}`);
 	for (const { node, messages } of result.unread ?? []) lines.push(`  ${style(["yellow", "bold"], "warning")} ${node} never ran, so ${messages === 1 ? "1 message" : `${String(messages)} messages`} to it went unread`);
@@ -1025,11 +990,6 @@ const toolLines = (name, input, view, room, verbose, node) => {
 	return [`${styledHead}${style("dim", cut(first.trim(), Math.max(1, room - headWidth - more.length)))}${style("dim", more)}`];
 };
 // src/run/format.ts
-/**
-* @file How runs read on the terminal: session events and run events with node
-*   chips or prefixes; the node result is `format-outcome.ts`'s, a tool call
-*   `format-tool.ts`'s and the run summary `format-result.ts`'s.
-*/
 /** A line's 2-column indent, after any style codes that open it. */
 const INDENT = /^((?:\u001B\[[0-9;]*m)*) {2}/u;
 /** Who answered a decision, as the log says it. */
@@ -1126,8 +1086,7 @@ const formatRunEvent = (event, width, tools, terminal = false, verbose = false,
 		return [`${tag(event.id)} ${style("yellow", `‖ paused: ${at}`)}`];
 	}
 	if (event.type === "node.released") return [`${tag(event.id)} ${style("dim", "▸ continues")}`];
-	if (event.type === "slot.waiting") return [`${tag(event.id)} ${style("yellow", `‖ ${slotWaitLine(event.holders)}`)}`];
-	if (event.type === "slot.taken") return [`${tag(event.id)} ${style("dim", "▸ got a check slot")}`];
+	if (isMachineEvent(event)) return [`${tag(event.id)} ${machineLine(event, style)}`];
 	if (event.type === "verify.skipped") return [`${tag(event.id)} ${style("dim", `✓ ${skippedLine(event)}`)}`];
 	if (event.type === "each.listed") {
 		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
@@ -1348,18 +1307,4 @@ const attachRun = async (store, root, out, options = {}) => {
 		exitCode: end === "aborted" || seen.succeeded ? 0 : 1
 	};
 };
-// src/store.ts
-/**
-* @file Opening the user's store (`~/.ork/state.db`) for the length of one
-*   command, and closing it after, whatever happens.
-*/
-/** Runs `body` with the user's store open, and closes it after. */
-const withStore = async (body) => {
-	const store = openStore();
-	try {
-		await body(store);
-	} finally {
-		store.close();
-	}
-};
-export { unknownNode as a, callsShown as c, createDecisionQueue as d, followRun as i, createTerminalHuman as l, attachRun as n, formatEvent as o, askStored as r, formatRunEvent as s, withStore as t, readText as u };
+export { formatEvent as a, createTerminalHuman as c, unknownNode as i, readText as l, askStored as n, formatRunEvent as o, followRun as r, callsShown as s, attachRun as t, createDecisionQueue as u };

package/dist/{attach-E6NNyA3T.mjs → attach-CPespxlQ.mjs}

@@ -1,8 +1,9 @@
-import "./src-BeR6f70A.mjs";
-import { l as createTerminalHuman, n as attachRun, t as withStore } from "./store-CM3cERGl.mjs";
-import { t as findRun } from "./find-CjsNYAAf.mjs";
-import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
-import { n as attachRefusal } from "./in-a-run-BYjTXaST.mjs";
+import "./src-Dr_fTSu-.mjs";
+import { c as createTerminalHuman, t as attachRun } from "./attach-BHO3X3cf.mjs";
+import { t as findRun } from "./find-BYLlszqj.mjs";
+import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { n as attachRefusal } from "./in-a-run-Bp0k0J09.mjs";
+import { t as withStore } from "./store-oKJ-cCf3.mjs";
 import { defineCommand } from "citty";
 // src/commands/attach.ts
 /**