@krapht/ork 0.4.0 → 1.0.0-alpha.0

package/dist/{format-J-a21Yvn.mjs → format-CmTlTOjT.mjs}

@@ -1,15 +1,17 @@
-import { lt as liveStatus } from "./src-CGqMati3.mjs";
-import { i as style, n as cost } from "./output-CXSJO00X.mjs";
+import { ht as liveStatus } from "./src-DHvWU4tX.mjs";
+import { i as style, n as cost } from "./output-B1V6ZJSx.mjs";
 import { createInterface } from "node:readline/promises";
 // src/human.ts
 /**
 * @file The terminal `HumanChannel`: answers `ask_user` questions, gates and
 *   permission prompts on the terminal, one at a time, and denies or defers
-*   when no one is there. In a run it is the decision queue's local answerer,
-*   racing `ork decide`.
+*   when no one is there. After a choice it offers one optional line for a
+*   note, which Enter skips. In a run it is the decision queue's local
+*   answerer, racing `ork decide`.
 */
 const PREVIEW = 160;
 const NO_ONE_TO_PERMIT = "No one is at the terminal to approve this tool, so it is not allowed in this run.";
+const NOTE_PROMPT = "  Note for the run (optional, Enter to skip): ";
 const NO_ONE_TO_ASK = "no one (nobody is at the terminal; use your best judgment and say so in your report)";
 /** One line that shows what a tool is about to do. */
 const previewInput = (toolName, input) => {
@@ -55,6 +57,12 @@ const createTerminalHuman = (io) => {
 		});
 		return signal === void 0 ? rl.question(text) : rl.question(text, { signal });
 	};
+	/** The optional line after a choice, when the asker takes a note. */
+	const takeNote = async (onNote, signal) => {
+		if (onNote === void 0) return;
+		const note = (await prompt(NOTE_PROMPT, signal)).trim();
+		if (note !== "") onNote(note);
+	};
 	const choose = async (hint, options, recommended, signal) => {
 		const picked = pickOption(await prompt(`  Choose${hint}: `, signal), options, recommended);
 		if (picked !== void 0) return picked;
@@ -67,7 +75,7 @@ const createTerminalHuman = (io) => {
 		return result;
 	};
 	return {
-		permit: ({ nodeId, toolName, input, signal }) => oneAtATime(async () => {
+		permit: ({ nodeId, toolName, input, signal, onNote }) => oneAtATime(async () => {
 			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
 			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} wants to run ${previewInput(toolName, input)}`);
 			if (!io.interactive) {
@@ -78,24 +86,28 @@ const createTerminalHuman = (io) => {
 				};
 			}
 			const answer = (await prompt("  Allow? [y/N] ", signal)).trim().toLowerCase();
-			return answer === "y" || answer === "yes" ? { allow: true } : {
+			if (answer === "y" || answer === "yes") return { allow: true };
+			await takeNote(onNote, signal);
+			return {
 				allow: false,
 				message: "The user did not allow this tool."
 			};
 		}),
-		ask: ({ nodeId, question, options, recommended, context, signal }) => oneAtATime(() => {
-			if (signal?.aborted === true) return Promise.reject(/* @__PURE__ */ new Error("the question was withdrawn"));
+		ask: ({ nodeId, question, options, recommended, context, signal, onNote }) => oneAtATime(async () => {
+			if (signal?.aborted === true) throw new Error("the question was withdrawn");
 			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} asks: ${question}`);
 			if (context !== void 0) say(style("dim", `  ${context}`));
 			for (const [index, option] of options.entries()) say(optionLine(option, index, recommended));
 			if (!io.interactive) {
 				const answer = recommended ?? NO_ONE_TO_ASK;
 				say(style("dim", `  no terminal; answered ${answer}`));
-				return Promise.resolve(answer);
+				return answer;
 			}
 			const fallback = options.findIndex((o) => o.id === recommended);
 			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
-			return choose(hint, options, recommended, signal);
+			const picked = await choose(hint, options, recommended, signal);
+			await takeNote(onNote, signal);
+			return picked;
 		}),
 		close: () => {
 			rl?.close();
@@ -131,12 +143,38 @@ const formatBusEvent = (event) => {
 	if (event.type === "owner.answered") return [style("dim", `→ ${event.answer} (owner)`)];
 	return [style("dim", "→ its session ended first; asking you")];
 };
+// src/run/format-result.ts
+const RUN_MARK = {
+	succeeded: style("green", "✓"),
+	failed: style("red", "✗"),
+	budget_exhausted: style("yellow", "!"),
+	quota_exhausted: style("yellow", "!"),
+	timed_out: style("yellow", "!"),
+	interrupted: style("yellow", "!")
+};
+/** `1 failure handled`, `2 failures handled`. */
+const failuresHandled = (count) => `${String(count)} ${count === 1 ? "failure" : "failures"} handled`;
+/**
+* The run summary: status, cost, what ran, what was skipped and which failures
+* an edge handled, branches to look at, why, and mail to nodes that never ran.
+*/
+const formatRunResult = (result) => {
+	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 = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${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`);
+	return lines;
+};
 // src/run/format.ts
 /** Who answered a decision, as the log says it. */
 const ANSWERED_BY = {
 	terminal: "terminal",
 	decide: "ork decide",
-	ui: "ork ui"
+	ui: "ork ui",
+	owner: "its owner"
 };
 const STATUS_MARK = {
 	pass: style("green", "✓"),
@@ -170,7 +208,10 @@ const formatOutcome = (nodeId, outcome) => {
 };
 /** The transcript lines for one event; tool names come from `tools`. */
 const formatEvent = (nodeId, event, tools) => {
-	if (event.type === "session.started") return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId})`)];
+	if (event.type === "session.started") {
+		const fork = event.fork === true ? ", a fork to answer a question" : "";
+		return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId}${fork})`)];
+	}
 	if (event.type === "assistant.text") return indent(event.text);
 	if (event.type === "tool.called") {
 		tools.set(event.id, event.name);
@@ -201,8 +242,12 @@ const formatRunEvent = (event, width, tools) => {
 	if (event.type === "node.event") {
 		const inner = event.event;
 		if (inner.type === "session.finished") return [];
-		if (inner.type === "session.started") return [`${tag(event.id)} ${style("dim", `${inner.model}, session ${inner.sessionId}`)}`];
-		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${line.replace(/^ {2}/u, "")}`);
+		const fork = inner.fork === true ? style("dim", "fork · ") : "";
+		if (inner.type === "session.started") {
+			const why = inner.fork === true ? ", to answer a question" : "";
+			return [`${tag(event.id)} ${fork}${style("dim", `${inner.model}, session ${inner.sessionId}${why}`)}`];
+		}
+		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${fork}${line.replace(/^ {2}/u, "")}`);
 	}
 	if (event.type === "node.finished") {
 		const mark = event.ok ? style("green", "✓") : style("red", "✗");
@@ -223,11 +268,13 @@ const formatRunEvent = (event, width, tools) => {
 	if (event.type === "decision.opened") {
 		const what = event.kind === "permission" ? "asks to" : "asks:";
 		const question = event.kind === "permission" ? event.question.replace(/^Allow /u, "run ").replace(/\?$/u, "") : event.question;
-		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(decision ${event.decision}; ork decide)`)}`];
+		const where = event.owner === void 0 ? `decision ${event.decision}; ork decide` : `decision ${event.decision}, via ${event.owner}`;
+		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(${where})`)}`];
 	}
 	if (event.type === "decision.answered") {
-		const by = ANSWERED_BY[event.by];
-		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})`)}`];
+		const by = event.by === "owner" && event.owner !== void 0 ? event.owner : ANSWERED_BY[event.by];
+		const said = event.note === void 0 ? "" : ` · said: ${event.note.replaceAll(/\s+/gu, " ")}`;
+		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})${said}`)}`];
 	}
 	if (event.type === "decision.withdrawn") return [`${tag(event.node)} ${style("dim", "→ question withdrawn")}`];
 	if (event.type === "run.command") {
@@ -256,23 +303,6 @@ const formatRunEvent = (event, width, tools) => {
 	}
 	return formatBusEvent(event).map((line) => `${tag(event.node)} ${line}`);
 };
-const RUN_MARK = {
-	succeeded: style("green", "✓"),
-	failed: style("red", "✗"),
-	budget_exhausted: style("yellow", "!"),
-	quota_exhausted: style("yellow", "!"),
-	timed_out: style("yellow", "!"),
-	interrupted: style("yellow", "!")
-};
-/** The run summary: status, cost, what ran, branches to look at, and why. */
-const formatRunResult = (result) => {
-	const ran = result.nodes.filter((n) => n.runs > 0).length;
-	const skipped = result.nodes.length - ran;
-	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped`)}`];
-	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)}`);
-	return lines;
-};
 // src/runs/format.ts
 /**
 * @file How stored runs read on the terminal: the `ork ps` table and the `ork
@@ -306,7 +336,10 @@ const duration = (ms) => {
 	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
 	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
 };
-/** The `ork ps` table; `withProject` adds each run's project. */
+/**
+* The `ork ps` table; `withProject` adds each run's project. A called run's
+* cost is dimmed and says its caller's, whose cost already counts it.
+*/
 const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus) => {
 	if (runs.length === 0) return ["No runs."];
 	const rows = runs.map((run) => {
@@ -317,7 +350,8 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus)
 			workflow: run.workflow,
 			status,
 			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
-			cost: cost(run.costUsd),
+			cost: run.parent === void 0 ? cost(run.costUsd) : `${cost(run.costUsd)} in ${run.parent}`,
+			called: run.parent !== void 0,
 			project: run.project
 		};
 	});
@@ -342,7 +376,7 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus)
 		r.workflow.padEnd(w.workflow),
 		style(STATUS_STYLE[r.status] ?? "reset", r.status.padEnd(w.status)),
 		style("dim", r.when.padEnd(w.when)),
-		r.cost.padStart(w.cost),
+		r.called ? style("dim", r.cost.padStart(w.cost)) : r.cost.padStart(w.cost),
 		...withProject ? [style("dim", r.project)] : []
 	].join("  "))];
 };

package/dist/help-groups-BwYoAWsh.mjs

@@ -0,0 +1,354 @@
+// src/completion/scripts.ts
+/**
+* @file The tab-completion scripts `ork completion <shell>` prints, one per
+*   shell. Each is thin: it runs `ork __complete -- <words…>` with the word
+*   under the cursor last, and offers the lines it prints, `value<TAB>
+*   description`. A line `:group <title>` starts a group (zsh labels the menu
+*   with it); `:files` asks for file names too. A new shell is one more entry.
+*/
+/** The hidden command the scripts run. */
+const COMPLETE_COMMAND = "__complete";
+/** Each shell's script, by the name `ork completion` takes. */
+const SHELL_SCRIPTS = {
+	zsh: `#compdef ork
+# Tab completion for ork, in zsh. Save it as _ork in a folder on your fpath
+# (ork completion zsh > ~/.zsh/completions/_ork), or source it.
+
+_ork() {
+  local -a lines cands
+  local line group=commands files=0 n=0 ret=1
+  lines=("\${(@f)$("\${words[1]}" ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  for line in "\${lines[@]}"; do
+    case $line in
+      (:files) files=1 ;;
+      (:group\\ *)
+        if (( \${#cands} )); then
+          _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
+        fi
+        cands=()
+        group=\${line#:group }
+        ;;
+      (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
+    esac
+  done
+  if (( \${#cands} )); then
+    _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
+  fi
+  if (( files )); then
+    _files && ret=0
+  fi
+  return ret
+}
+
+if [[ "\${funcstack[1]}" == _ork ]]; then
+  _ork "$@"
+else
+  compdef _ork ork
+fi
+`,
+	bash: `# Tab completion for ork, in bash. Add to your ~/.bashrc:
+#   eval "$(ork completion bash)"
+# (macOS's bash 3.2 can't source <(…); saving it to a file and sourcing that
+# works too.) Every expansion is quoted and lines are read with read -r, so a
+# candidate is never split or glob-expanded.
+
+_ork() {
+  local line="\${COMP_LINE:0:COMP_POINT}" cur files=0 strip="" out
+  local -a words
+  read -r -a words <<< "$line"
+  if [[ "$line" == *[[:space:]] ]]; then words+=(""); fi
+  cur="\${words[\${#words[@]}-1]}"
+  COMPREPLY=()
+  # bash splits a word at ":" (ork:feature); offer only what follows it.
+  if [[ "$cur" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
+    strip="\${cur%"\${cur##*:}"}"
+  fi
+  out="$("\${words[0]}" ${COMPLETE_COMMAND} -- "\${words[@]:1}" 2>/dev/null)"
+  while IFS= read -r line; do
+    case "$line" in
+      :files) files=1 ;;
+      :* | "") ;;
+      *)
+        line="\${line%%$'\\t'*}"
+        COMPREPLY+=("\${line#"$strip"}")
+        ;;
+    esac
+  done <<< "$out"
+  if (( files )); then
+    out="$(compgen -f -- "$cur")"
+    while IFS= read -r line; do
+      if [[ -n "$line" ]]; then COMPREPLY+=("\${line#"$strip"}"); fi
+    done <<< "$out"
+  fi
+}
+
+complete -F _ork ork
+`,
+	fish: `# Tab completion for ork, in fish. Save it as
+# ~/.config/fish/completions/ork.fish (ork completion fish > …), or source it.
+
+function __ork_complete
+    # -x is fish 4's name for -o, which it deprecates; fish 3 has only -o.
+    set -l tokens (commandline -xpc 2>/dev/null; or commandline -opc)
+    set -l current (commandline -ct)
+    set -l out ($tokens[1] ${COMPLETE_COMMAND} -- $tokens[2..-1] "$current" 2>/dev/null)
+    string match -v -r '^:' -- $out
+    if contains -- :files $out
+        __fish_complete_path "$current"
+    end
+end
+
+complete -c ork -f -a '(__ork_complete)'
+`
+};
+/** The shells there is a script for. */
+const SHELLS = Object.keys(SHELL_SCRIPTS);
+// src/command-tree.ts
+/** How a flag that only Ork passes to itself starts its description. */
+const INTERNAL = "Internal:";
+/** Whether citty was given a function that gives the value. */
+const isThunk = (value) => typeof value === "function";
+/** A value citty lets be given as is, as a promise, or as a function. */
+const resolved = (value) => Promise.resolve(isThunk(value) ? value() : value);
+/** `args` without the flags only Ork passes to itself. */
+const publicArgs = (args) => Object.fromEntries(Object.entries(args).filter(([, def]) => !(def.description ?? "").startsWith(INTERNAL)));
+/** A command's flags and positionals, which citty lets be given lazily. */
+const argsOf = (cmd) => cmd.args === void 0 ? Promise.resolve({}) : resolved(cmd.args);
+const listOf = (value) => value === void 0 ? [] : [value].flat();
+const flagOf = (name, def) => ({
+	name,
+	description: def.description ?? "",
+	takesValue: def.type === "string" || def.type === "enum",
+	aliases: "alias" in def ? listOf(def.alias) : [],
+	options: def.type === "enum" ? def.options ?? [] : [],
+	negatable: def.type === "boolean" && def.default === true
+});
+/** A command's public flags and positionals, in the order it defines them. */
+const argInfoOf = async (cmd) => {
+	const entries = Object.entries(publicArgs(await argsOf(cmd)));
+	return {
+		flags: entries.filter(([, def]) => def.type !== "positional").map(([name, def]) => flagOf(name, def)),
+		positionals: entries.filter(([, def]) => def.type === "positional").map(([name, def]) => ({
+			name,
+			description: def.description ?? ""
+		}))
+	};
+};
+/**
+* A command's subcommands, in order, loaded ones resolved. A name whose
+* definition is one listed before it (`wt`, `worktrees`'s) is an alias of that
+* one, not an entry of its own.
+*/
+const subcommandsOf = async (cmd) => {
+	const subs = cmd.subCommands === void 0 ? {} : await resolved(cmd.subCommands);
+	const loaded = await Promise.all(Object.entries(subs).map(async ([name, sub]) => {
+		const def = await resolved(sub);
+		return {
+			name,
+			def,
+			meta: def.meta === void 0 ? {} : await resolved(def.meta)
+		};
+	}));
+	const entries = [];
+	for (const { name, def, meta } of loaded) {
+		const same = entries.find((entry) => entry.def === def);
+		if (same === void 0) entries.push({
+			name,
+			aliases: listOf(meta.alias),
+			description: meta.description ?? "",
+			hidden: meta.hidden === true,
+			def
+		});
+		else same.aliases.push(name);
+	}
+	return entries;
+};
+/** The subcommand `name` (or one of its aliases) of `entries`. */
+const findEntry = (entries, name) => entries.find((entry) => entry.name === name || entry.aliases.includes(name));
+// src/help-groups.ts
+const HELP_GROUPS = [
+	{
+		title: "Get started",
+		commands: [
+			{
+				name: "init",
+				short: "Set up Ork in this repository, in .ork/"
+			},
+			{
+				name: "doctor",
+				short: "Check Node, git and your own logins"
+			},
+			{
+				name: "ui",
+				short: "Open Ork's local UI in the browser"
+			}
+		]
+	},
+	{
+		title: "Workflows",
+		commands: [
+			{
+				name: "validate",
+				short: "Check workflow files"
+			},
+			{
+				name: "run",
+				short: "Run a workflow, or one node of it"
+			},
+			{
+				name: "agents",
+				short: "List, show, add and remove agents"
+			},
+			{
+				name: "context",
+				short: "Show what a node's session loads"
+			},
+			{
+				name: "watch",
+				short: "Start runs from each project's triggers"
+			}
+		]
+	},
+	{
+		title: "Runs",
+		commands: [
+			{
+				name: "ps",
+				short: "List this project's runs"
+			},
+			{
+				name: "logs",
+				short: "Print a run's transcript"
+			},
+			{
+				name: "tree",
+				short: "Show a run's tree, tokens and cost"
+			},
+			{
+				name: "usage",
+				short: "Show what runs spent over time"
+			},
+			{
+				name: "resume",
+				short: "Continue a run that didn't succeed"
+			}
+		]
+	},
+	{
+		title: "Steer a running run",
+		commands: [
+			{
+				name: "decide",
+				short: "Answer a run's open decisions"
+			},
+			{
+				name: "chat",
+				short: "Talk to a node of a run"
+			},
+			{
+				name: "pause",
+				short: "Pause a run, or one node"
+			},
+			{
+				name: "continue",
+				short: "Let a paused run or node go on"
+			},
+			{
+				name: "stop",
+				short: "Stop a run, or one node"
+			},
+			{
+				name: "relay",
+				short: "Let nodes of two runs message each other"
+			}
+		]
+	},
+	{
+		title: "After runs",
+		commands: [
+			{
+				name: "feedback",
+				short: "What got in the way in your runs"
+			},
+			{
+				name: "worktrees",
+				short: "Track and clean up Ork's worktrees"
+			},
+			{
+				name: "prune",
+				short: "Forget old runs' transcripts"
+			}
+		]
+	},
+	{
+		title: "Projects",
+		commands: [
+			{
+				name: "projects",
+				short: "List, forget or move registered projects"
+			},
+			{
+				name: "register",
+				short: "Attach a project from outside it"
+			},
+			{
+				name: "migrate",
+				short: "Move an attached project into its .ork/"
+			},
+			{
+				name: "link",
+				short: "Point tools' agent folders at .ork/"
+			}
+		]
+	},
+	{
+		title: "Ork itself",
+		commands: [
+			{
+				name: "upgrade",
+				short: "Upgrade Ork, the way it was installed"
+			},
+			{
+				name: "mcp",
+				short: "Serve Ork's tools to Claude Code (MCP)"
+			},
+			{
+				name: "send",
+				short: "Write to a session from a tool node's program"
+			},
+			{
+				name: "completion",
+				short: "Print a tab-completion script"
+			}
+		]
+	}
+];
+/** What a command not in any group is listed under. */
+const OTHER_GROUP = "Other";
+/** The group a root command is in, and its short line, if it has them. */
+const groupOf = (name) => {
+	for (const group of HELP_GROUPS) {
+		const found = group.commands.find((command) => command.name === name);
+		if (found !== void 0) return {
+			title: group.title,
+			short: found.short
+		};
+	}
+};
+/**
+* The shown commands in `HELP_GROUPS`'s order, then any in no group under
+* "Other", in the order the root command lists them.
+*/
+const groupedEntries = (entries) => {
+	const shown = entries.filter((entry) => !entry.hidden);
+	const grouped = HELP_GROUPS.map((group) => ({
+		title: group.title,
+		entries: group.commands.flatMap((command) => shown.find((entry) => entry.name === command.name) ?? [])
+	}));
+	const other = shown.filter((entry) => groupOf(entry.name) === void 0);
+	return [...grouped, {
+		title: OTHER_GROUP,
+		entries: other
+	}].filter((group) => group.entries.length > 0);
+};
+export { findEntry as a, subcommandsOf as c, SHELL_SCRIPTS as d, argsOf as i, COMPLETE_COMMAND as l, groupedEntries as n, publicArgs as o, argInfoOf as r, resolved as s, groupOf as t, SHELLS as u };

package/dist/{in-a-run-D1Qc5Mit.mjs → in-a-run-BPXX09Bs.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-UWkk1sl9.mjs";
+import { p as runMarkerIn } from "./src-C38BPzit.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{limits-BDZCmGEu.mjs → limits-JCve2QpI.mjs}

@@ -1,4 +1,4 @@
-import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-CGqMati3.mjs";
+import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-DHvWU4tX.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/{list-ZvY2OcLq.mjs → list-C7UEgmtd.mjs}

@@ -1,4 +1,4 @@
-import { D as git, O as gitOk, k as lines } from "./src-CGqMati3.mjs";
+import { A as gitOk, j as lines, k as git } from "./src-DHvWU4tX.mjs";
 import { existsSync } from "node:fs";
 // ../core/src/worktree/list.ts
 /**

package/dist/{mcp-CHVKKg3B.mjs → mcp-CKPyNaKD.mjs}

@@ -1,10 +1,10 @@
-import { m as isNewer } from "./src-CGqMati3.mjs";
-import { n as ORK_VERSION } from "./__build_info__-CtSVVuZE.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CpDKIulI.mjs";
-import { n as explainNode } from "./context-C_bksb0C.mjs";
-import { p as runMarkerIn } from "./src-UWkk1sl9.mjs";
-import { defineCommand } from "citty";
+import { h as isNewer } from "./src-DHvWU4tX.mjs";
+import { n as ORK_VERSION } from "./__build_info__-DdTVd2p5.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-BJTegEzY.mjs";
+import { n as explainNode } from "./context-DO3sBy9v.mjs";
+import { p as runMarkerIn } from "./src-C38BPzit.mjs";
 import { z } from "zod";
+import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 // src/commands/mcp.ts
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "0.4.0") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.0") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION