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

package/README.md

@@ -1,9 +1,9 @@
 # @krapht/ork
 
-The `ork` command: orchestrate Claude agents on your machine with hierarchical,
-serializable workflows.
+The `ork` command: orchestrate coding agents (Claude Code, OpenCode, Command
+Code) on your machine with hierarchical, serializable workflows.
 
-> **Alpha.** Workflows of Claude agents and tools, run from the terminal or the
+> **Alpha.** Workflows of coding agents and tools, run from the terminal or the
 > browser (`ork ui`). Expect changes until 1.0.0. See the
 > [project README](https://github.com/mimshins/ork#readme), the
 > [guides](https://github.com/mimshins/ork/tree/main/docs#readme) and
@@ -28,7 +28,13 @@ ork upgrade             # a newer version? upgrade the way you installed Ork
 
 A workflow that names no agent driver runs on the one that's ready. Today that
 is `claude-code`: your own `claude`, logged in or with `ANTHROPIC_API_KEY` or a
-cloud provider set. `--driver claude-code` names it.
+cloud provider set. Your own `opencode` (`open-code`) and Command Code's `cmd`
+(`command-code`) work too: `--driver <id>`, or a driver per node
+([Drivers](https://github.com/mimshins/ork/blob/main/docs/guides/drivers.md)).
+
+Ork is built with Ork: its own workflows plan, build, review and document its
+features, and each run is measured against a manual session in
+[Benchmarks: Ork building Ork](https://github.com/mimshins/ork/blob/main/benchmarks/README.md).
 
 Ork never stores or asks for credentials: it uses the tools you already have,
 signed in with your own accounts. Once a day it asks the npm registry whether a

package/dist/__build_info__-DcRdK0Du.mjs

@@ -0,0 +1,359 @@
+import { C as compareVersions, T as parseVersion, w as isNewer } from "./src-DN-RPsil.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,
+		kind: "status",
+		why: `it is ${f.status}`,
+		error
+	};
+};
+/** Whether `to` names one GitHub issue or pull request by its URL. */
+const isGithubIssueUrl = (to) => /^https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+$/u.test(to);
+/**
+* Why `f`'s draft can't be posted to GitHub whatever its status, or
+* `undefined`.
+*/
+const githubDraftRefusal = (f) => {
+	if (f.kind !== "message" || f.draft?.channel !== "github") return {
+		why: "not drafted for the github channel",
+		error: "only a message drafted for the github channel is posted; send the others yourself"
+	};
+	return isGithubIssueUrl(f.draft.to) ? void 0 : {
+		why: "its `to` isn't a GitHub issue or pull request URL",
+		error: `${f.id}'s \`to\` (${f.draft.to}) isn't a GitHub issue or pull request URL, so it is not posted; copy the text and send it yourself.`
+	};
+};
+const postCheck = (f) => {
+	const open = f.status === "waiting" || f.status === "due";
+	const refused = githubDraftRefusal(f);
+	if (refused !== void 0) return {
+		ok: false,
+		kind: "draft",
+		...refused
+	};
+	return open ? { ok: true } : {
+		ok: false,
+		kind: "status",
+		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.16";
+export { dueCause as _, registryShown as a, githubDraftRefusal as b, 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, isGithubIssueUrl as x, followUpActions as y };

package/dist/apply-Mb0fNpCX.mjs

@@ -0,0 +1,17 @@
+// ../core/src/list-filters/apply.ts
+/**
+* @file Keeps the rows a list's filter matches (RFC-017). The list's own order
+*   and `--limit` stay the caller's: filter, then order, then limit.
+*/
+const fieldMatches = (field, row, wanted) => {
+	if (wanted === void 0 || wanted === "all" || field.get === void 0) return true;
+	const got = field.get(row);
+	if (got === void 0) return false;
+	const values = typeof got === "string" ? [got] : got;
+	if (field.type === "since") return values.some((value) => Date.parse(value) >= Date.parse(wanted));
+	if (field.type === "until") return values.some((value) => Date.parse(value) < Date.parse(wanted));
+	return values.includes(wanted);
+};
+/** The rows of `rows` every field of `filter` matches, in their order. */
+const applyFilters = (table, rows, filter) => rows.filter((row) => table.fields.every((field) => fieldMatches(field, row, filter[field.name])));
+export { applyFilters as t };

package/dist/{attach-CdtGX9se.mjs → attach-7lB5_jpr.mjs}

@@ -1,8 +1,9 @@
-import "./src-tsuZRu0H.mjs";
-import { l as createTerminalHuman, n as attachRun, t as withStore } from "./store-CleF7KeS.mjs";
-import { t as findRun } from "./find-BVX-bL4u.mjs";
+import "./src-DN-RPsil.mjs";
+import { l as createTerminalHuman, t as attachRun } from "./attach-B-FeE1dJ.mjs";
+import { t as findRun } from "./find-mLYsR0uC.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { n as attachRefusal } from "./in-a-run-cL5N9gpH.mjs";
+import { n as attachRefusal } from "./in-a-run-a447hxq8.mjs";
+import { t as withStore } from "./store-Dyr1mP8K.mjs";
 import { defineCommand } from "citty";
 // src/commands/attach.ts
 /**

package/dist/{store-CleF7KeS.mjs → attach-B-FeE1dJ.mjs}

@@ -1,4 +1,5 @@
-import { $n as maskSecrets, An as END_KINDS, Dn as endOf, H as isNodeEvent, On as outcomeEnd, Tt as followEvents, U as openStore, cn as slotWaitLine, ct as followRunTree, lt as answerDecision, nn as lockWaitLine, ut as pendingDecisions } from "./src-tsuZRu0H.mjs";
+import { Ft as slotWaitLine, Gn as endOf, I as isNodeEvent, Jn as END_KINDS, Kn as outcomeEnd, kt as lockWaitLine, nt as answerDecision, rt as pendingDecisions, tt as followRunTree, ut as followEvents, vr as maskSecrets } from "./src-DN-RPsil.mjs";
+import { t as applyFilters } from "./apply-Mb0fNpCX.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";
@@ -769,8 +770,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)";
@@ -779,11 +781,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);
@@ -792,6 +800,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;
 };
 /**
@@ -1027,7 +1039,8 @@ const formatRunEvent = (event, width, tools, terminal = false, verbose = false,
 	if (event.type === "node.started") {
 		const round = event.round > 1 ? ` (round ${String(event.round)})` : "";
 		const owner = event.owner === void 0 ? "" : `, for ${event.owner}`;
-		return [`${tag(event.id)} ${style("dim", `${event.nodeType}${round}${owner}`)}`];
+		const named = event.description === void 0 ? "" : ` · ${event.description}`;
+		return [`${tag(event.id)} ${style("dim", `${event.nodeType}${round}${owner}${named}`)}`];
 	}
 	if (event.type === "node.event") {
 		const inner = event.event;
@@ -1110,7 +1123,7 @@ const formatRunEvent = (event, width, tools, terminal = false, verbose = false,
 /** Turns stored events into lines, keeping the state a transcript needs. */
 const createLogPrinter = (options) => {
 	const tools = /* @__PURE__ */ new Map();
-	const view = createView();
+	const view = options.view ?? createView();
 	let width = 8;
 	return (stored) => {
 		const { event } = stored;
@@ -1130,6 +1143,19 @@ const unknownNode = (stored, node, live) => {
 	const declared = stored.some(({ event }) => event.type === "run.started" && event.nodes.some((n) => n.id === node));
 	return named || declared || live ? null : `Run has no node ${node}.`;
 };
+/** `ork logs`'s filter flags (RFC-017): an event's time; no ids. */
+const logListTable = { fields: [{
+	name: "since",
+	description: "Only events since an age (24h, 30d, 12w), a day (2026-11-01), or all",
+	type: "since",
+	all: true,
+	get: (stored) => stored.at
+}, {
+	name: "until",
+	description: "Only events on or before this day (2026-11-01)",
+	type: "until",
+	get: (stored) => stored.at
+}] };
 /**
 * Prints a run's events; with `follow`, then each new one as it is stored:
 * pushed over the run's socket, or polled from the store when there is none.
@@ -1138,8 +1164,13 @@ const unknownNode = (stored, node, live) => {
 */
 const followRun = async (store, run, out, options) => {
 	const print = createLogPrinter(options);
+	const matches = (stored) => applyFilters(logListTable, [stored], options.filter ?? {}).length > 0 && (options.node === void 0 || isNodeEvent(stored.event, options.node));
+	const replayed = options.limit === void 0 ? [] : store.events(run.id, options.after ?? 0).filter((stored) => matches(stored)).slice(0, -options.limit);
+	const dropped = new Set(replayed.map((stored) => stored.seq));
 	if (await followEvents(store, run.id, (stored) => {
-		for (const line of print(stored)) out(line);
+		const lines = print(stored);
+		if (!matches(stored) || dropped.has(stored.seq)) return;
+		for (const line of lines) out(line);
 	}, {
 		follow: options.follow,
 		...options.after === void 0 ? {} : { after: options.after },
@@ -1197,13 +1228,15 @@ const askStored = async (store, human, decision, { place, by, signal, home }) =>
 *   asked through one `TerminalHuman`, withdrawn when it closes elsewhere.
 */
 const where = (path) => path.join(" › ");
+/** The gutter before a called run's lines: its call path, then ` › `. */
+const gutterOf = (path) => path.length === 0 ? "" : `${where(path)} › `;
 /**
 * Prints the events of `root` and of the runs it called until the root ends or
 * `signal` aborts, and asks each open decision with `options.human`.
 */
 const attachRun = async (store, root, out, options = {}) => {
 	const { human, basePath = [] } = options;
-	const { term } = createView();
+	const { term } = options.view ?? createView();
 	const say = styler(term);
 	const printers = /* @__PURE__ */ new Map();
 	const prompts = /* @__PURE__ */ new Map();
@@ -1215,9 +1248,25 @@ const attachRun = async (store, root, out, options = {}) => {
 		succeeded: false
 	};
 	const show = (path, lines) => {
-		const prefix = path.length === 0 ? "" : paint(term, "muted", `${where(path)} › `);
+		const gutter = gutterOf(path);
+		const prefix = gutter === "" ? "" : paint(term, "muted", gutter);
 		for (const line of lines) out(line === "" ? line : `${prefix}${line}`);
 	};
+	/**
+	* A run's printer, laid out in the columns its gutter leaves, so a line fits
+	* the terminal with the gutter before it and a wrapped line goes on under its
+	* own text, not at the terminal's first column.
+	*/
+	const printerFor = (path) => createLogPrinter({
+		json: false,
+		view: {
+			term: {
+				...term,
+				width: Math.max(20, term.width - widthOf(gutterOf(path)))
+			},
+			roots: /* @__PURE__ */ new Map()
+		}
+	});
 	const ask = (run, path, id) => {
 		const decision = store.decision(id);
 		if (human === void 0 || decision === void 0) return;
@@ -1277,7 +1326,7 @@ const attachRun = async (store, root, out, options = {}) => {
 		}
 		let print = printers.get(run);
 		if (print === void 0) {
-			print = createLogPrinter({ json: false });
+			print = printerFor(path);
 			printers.set(run, print);
 		}
 		show(path, print(stored));
@@ -1296,18 +1345,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 { unknownNode as a, callsShown as c, createDecisionQueue as d, logListTable as i, createTerminalHuman as l, askStored as n, formatEvent as o, followRun as r, formatRunEvent as s, attachRun as t, readText as u };