@krapht/ork 0.1.0 → 0.2.0

package/README.md

@@ -3,10 +3,12 @@
 The `ork` command: orchestrate Claude agents on your machine with hierarchical,
 serializable workflows.
 
-> **Pre-alpha.** `ork init`, `ork validate`, `ork doctor` and `ork run` (each
-> writing node in its own git worktree) work today; delegation and the context
-> compiler are being built. See the
-> [project README](https://github.com/mimshins/ork#readme).
+> **Pre-alpha.** The workflow format, `ork run` with delegation and worktrees,
+> the context compiler, agents, run logs, decisions from any terminal, messages
+> between nodes, chat, resume, claims and local feedback work today; a web UI
+> comes next. Expect changes between 0.x releases. See the
+> [project README](https://github.com/mimshins/ork#readme) and the
+> [guides](https://github.com/mimshins/ork/tree/main/docs#readme).
 
 ```sh
 npm install --global @krapht/ork
@@ -19,12 +21,14 @@ ork run hello --input task="add a README"
 ork worktrees           # the worktrees and branches runs left; `clean` tidies up
 ork run hello --node lead --input task="add a README" --in-place
                         # run one Claude node on its own
+ork upgrade             # a newer version? upgrade the way you installed Ork
 ```
 
 `--driver sdk` (the default) needs `ANTHROPIC_API_KEY` or a cloud provider;
 `--driver cli` uses your own logged-in `claude`.
 
 Ork never stores or asks for credentials: it uses the tools you already have,
-signed in with your own accounts.
+signed in with your own accounts. Once a day it asks the npm registry whether a
+newer version is out (`ORK_NO_UPDATE_CHECK=1` turns that off).
 
 Requires Node.js 24.20 or later. MIT licensed.

package/dist/bin.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { $ as parseWorkflow, A as planAgentMigration, B as PROJECT_MODES, C as fingerprint, D as parseTemplate, E as maskSecrets, F as toolsInUse, G as placeFor, H as inRepoPlace, I as createAgent, J as shownPath, K as projectsHome, L as deleteAgent, M as planMoveInto, N as linkTools, O as renderTemplate, P as toolLinks, R as catalogAgent, S as createFeedback, T as maskReplacer, U as newProjectId, V as hasInRepoFiles, W as placeFiles, X as inside, Y as workflowDirOf, Z as projectRootOf, _ as gitRulesOf, a as removeWorktree, at as INTEGRATIONS, b as FEEDBACK_SEVERITIES, c as lines, ct as AGENT_TOOL_LAYOUTS, dt as firstLine$1, et as serializeWorkflow, f as userMessageText, g as compileWorkflow, h as resolvePractices, i as inspectProject, it as isToolNode, j as applySteps, k as contextDiagnostics, l as startRun, lt as ORK_LAYOUT, m as practiceInstructions, n as resolveBase, nt as settingsOf, o as git, ot as TOOL_PREFIX, p as runScope, q as runDirOf, rt as isClaudeNode, s as gitOk, st as integrationFor, t as createWorkspace, tt as WorkflowSchema, u as planNodeSession, ut as CLAUDE_DRIVERS, v as loadProject, w as targetOf, x as FEEDBACK_TARGETS, y as FEEDBACK_KINDS, z as loadAgents } from "./src-CqNlvqV_.mjs";
+import { A as contextDiagnostics, B as loadAgents, C as createFeedback, D as maskSecrets, E as maskReplacer, F as toolLinks, G as placeFiles, H as hasInRepoFiles, I as toolsInUse, J as runDirOf, K as placeFor, L as createAgent, M as applySteps, N as planMoveInto, O as parseTemplate, P as linkTools, Q as projectRootOf, R as deleteAgent, S as FEEDBACK_TARGETS, T as targetOf, U as inRepoPlace, V as PROJECT_MODES, W as newProjectId, X as workflowDirOf, Y as shownPath, Z as inside, _ as compileWorkflow, a as removeWorktree, at as isToolNode, b as FEEDBACK_KINDS, c as lines, ct as integrationFor, d as planNodeSession, dt as CLAUDE_DRIVERS, et as parseWorkflow, ft as firstLine$1, g as resolvePractices, h as practiceInstructions, i as inspectProject, it as isClaudeNode, j as planAgentMigration, k as renderTemplate, l as detectInstaller, lt as AGENT_TOOL_LAYOUTS, m as runScope, n as resolveBase, nt as WorkflowSchema, o as git, ot as INTEGRATIONS, p as userMessageText, q as projectsHome, rt as settingsOf, s as gitOk, st as TOOL_PREFIX, t as createWorkspace, tt as serializeWorkflow, u as startRun, ut as ORK_LAYOUT, v as gitRulesOf, w as fingerprint, x as FEEDBACK_SEVERITIES, y as loadProject, z as catalogAgent } from "./src-CJ_zF0Zj.mjs";
 import { defineCommand, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { stringify } from "yaml";
-import { accessSync, appendFileSync, constants, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, appendFileSync, constants, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { createConnection, createServer } from "node:net";
@@ -13,8 +13,6 @@ import { DatabaseSync } from "node:sqlite";
 import { execFile, spawn } from "node:child_process";
 import { styleText } from "node:util";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-// src/__build_info__.ts
-const ORK_VERSION = "0.1.0";
 // ../core/src/control/queue.ts
 const PERMISSION_OPTIONS = [{
 	id: "allow",
@@ -881,7 +879,7 @@ const MIGRATIONS = [
    );`
 ];
 /** A text column, or `""` when it is null. */
-const text = (row, key) => {
+const text$1 = (row, key) => {
 	const value = row?.[key];
 	return typeof value === "string" ? value : "";
 };
@@ -914,23 +912,23 @@ const kindOf = (value) => value === "permission" ? "permission" : "question";
 const statusOf$1 = (value) => value === "answered" || value === "withdrawn" ? value : "open";
 const decisionOf = (row) => {
 	const record = {
-		id: text(row, "id"),
-		runId: text(row, "run_id"),
-		node: text(row, "node"),
-		kind: kindOf(text(row, "kind")),
-		question: text(row, "question"),
-		options: choicesOf(text(row, "options") || "[]"),
-		openedAt: text(row, "opened_at"),
-		status: statusOf$1(text(row, "status"))
+		id: text$1(row, "id"),
+		runId: text$1(row, "run_id"),
+		node: text$1(row, "node"),
+		kind: kindOf(text$1(row, "kind")),
+		question: text$1(row, "question"),
+		options: choicesOf(text$1(row, "options") || "[]"),
+		openedAt: text$1(row, "opened_at"),
+		status: statusOf$1(text$1(row, "status"))
 	};
 	const optional = {
-		recommended: text(row, "recommended"),
-		context: text(row, "context"),
-		answer: text(row, "answer"),
-		answeredAt: text(row, "answered_at")
+		recommended: text$1(row, "recommended"),
+		context: text$1(row, "context"),
+		answer: text$1(row, "answer"),
+		answeredAt: text$1(row, "answered_at")
 	};
 	for (const [key, value] of Object.entries(optional)) if (value !== "") Object.assign(record, { [key]: value });
-	const by = text(row, "answered_by");
+	const by = text$1(row, "answered_by");
 	if (by === "terminal" || by === "decide") record.answeredBy = by;
 	return record;
 };
@@ -982,12 +980,12 @@ const decisionQueries = (db) => {
 			const at = (/* @__PURE__ */ new Date()).toISOString();
 			return pending.all(runId).flatMap((row) => {
 				handled.run(at, Number(row["id"]));
-				const kind = text(row, "kind");
+				const kind = text$1(row, "kind");
 				if (kind === "stop") return [{ kind }];
 				if (kind === "message") return [{
 					kind,
-					node: text(row, "node"),
-					body: text(row, "body")
+					node: text$1(row, "node"),
+					body: text$1(row, "body")
 				}];
 				return [];
 			});
@@ -1012,7 +1010,7 @@ const SOURCES = [
 const oneOf$1 = (values, value, fallback) => values.find((v) => v === value) ?? fallback;
 /** A JSON array column of strings, without nulls. */
 const strings = (row, key) => {
-	const parsed = JSON.parse(text(row, key) || "[]");
+	const parsed = JSON.parse(text$1(row, key) || "[]");
 	return Array.isArray(parsed) ? parsed.filter((v) => typeof v === "string" && v !== "") : [];
 };
 const ORIGIN_COLUMNS = [
@@ -1026,46 +1024,46 @@ const ORIGIN_COLUMNS = [
 const recordOf$2 = (row) => {
 	const origin = {};
 	for (const [key, column] of ORIGIN_COLUMNS) {
-		const value = text(row, column);
+		const value = text$1(row, column);
 		if (value !== "") origin[key] = value;
 	}
 	const feedback = {
-		source: oneOf$1(SOURCES, text(row, "source"), "system"),
-		kind: oneOf$1(FEEDBACK_KINDS, text(row, "kind"), "idea"),
-		target: oneOf$1(FEEDBACK_TARGETS, text(row, "target"), "workflow"),
-		severity: oneOf$1(FEEDBACK_SEVERITIES, text(row, "severity"), "medium"),
-		title: text(row, "title"),
-		body: text(row, "body"),
+		source: oneOf$1(SOURCES, text$1(row, "source"), "system"),
+		kind: oneOf$1(FEEDBACK_KINDS, text$1(row, "kind"), "idea"),
+		target: oneOf$1(FEEDBACK_TARGETS, text$1(row, "target"), "workflow"),
+		severity: oneOf$1(FEEDBACK_SEVERITIES, text$1(row, "severity"), "medium"),
+		title: text$1(row, "title"),
+		body: text$1(row, "body"),
 		evidence: strings(row, "evidence"),
-		fingerprint: text(row, "fingerprint"),
+		fingerprint: text$1(row, "fingerprint"),
 		origin
 	};
-	const code = text(row, "code");
+	const code = text$1(row, "code");
 	if (code !== "") feedback.code = code;
 	const record = {
 		id: Number(row?.["id"]),
-		runId: text(row, "run_id"),
+		runId: text$1(row, "run_id"),
 		seq: Number(row?.["seq"]),
-		at: text(row, "at"),
+		at: text$1(row, "at"),
 		feedback
 	};
-	const node = text(row, "node");
+	const node = text$1(row, "node");
 	if (node !== "") record.node = node;
 	return record;
 };
 const itemOf = (row) => {
 	const severities = strings(row, "severities");
 	return {
-		id: text(row, "fingerprint"),
-		status: oneOf$1(STATUSES$1, text(row, "status"), "new"),
-		title: text(row, "title"),
-		target: oneOf$1(FEEDBACK_TARGETS, text(row, "target"), "workflow"),
-		kind: oneOf$1(FEEDBACK_KINDS, text(row, "kind"), "idea"),
+		id: text$1(row, "fingerprint"),
+		status: oneOf$1(STATUSES$1, text$1(row, "status"), "new"),
+		title: text$1(row, "title"),
+		target: oneOf$1(FEEDBACK_TARGETS, text$1(row, "target"), "workflow"),
+		kind: oneOf$1(FEEDBACK_KINDS, text$1(row, "kind"), "idea"),
 		severity: FEEDBACK_SEVERITIES.toReversed().find((s) => severities.includes(s)) ?? "medium",
 		sources: strings(row, "sources").flatMap((s) => SOURCES.filter((known) => known === s)),
 		count: Number(row?.["count"]),
-		firstSeen: text(row, "first_seen"),
-		lastSeen: text(row, "last_seen"),
+		firstSeen: text$1(row, "first_seen"),
+		lastSeen: text$1(row, "last_seen"),
 		runs: strings(row, "runs"),
 		workflows: strings(row, "workflows"),
 		models: strings(row, "models")
@@ -1113,11 +1111,11 @@ const feedbackQueries = (db) => {
 *   (`ork migrate`) with its runs' workflow files.
 */
 const recordOf$1 = (row) => ({
-	id: text(row, "id"),
-	root: text(row, "root"),
-	mode: PROJECT_MODES.find((m) => m === text(row, "mode")) ?? "in-repo",
-	dir: text(row, "dir"),
-	registeredAt: text(row, "registered_at")
+	id: text$1(row, "id"),
+	root: text$1(row, "root"),
+	mode: PROJECT_MODES.find((m) => m === text$1(row, "mode")) ?? "in-repo",
+	dir: text$1(row, "dir"),
+	registeredAt: text$1(row, "registered_at")
 });
 const projectQueries = (db) => {
 	const all = db.prepare("SELECT * FROM projects ORDER BY id");
@@ -1185,16 +1183,16 @@ const STATUSES = [
 const statusOf = (value) => STATUSES.find((s) => s === value) ?? "failed";
 const recordOf = (row) => {
 	const record = {
-		id: text(row, "id"),
-		workflow: text(row, "workflow"),
-		file: text(row, "file"),
-		project: text(row, "project"),
-		status: statusOf(text(row, "status")),
+		id: text$1(row, "id"),
+		workflow: text$1(row, "workflow"),
+		file: text$1(row, "file"),
+		project: text$1(row, "project"),
+		status: statusOf(text$1(row, "status")),
 		pid: Number(row?.["pid"]),
-		startedAt: text(row, "started_at"),
+		startedAt: text$1(row, "started_at"),
 		costUsd: Number(row?.["cost_usd"])
 	};
-	const finished = text(row, "finished_at");
+	const finished = text$1(row, "finished_at");
 	if (finished !== "") record.finishedAt = finished;
 	return record;
 };
@@ -1270,8 +1268,8 @@ const openStore = (file = storePath()) => {
 		events: (runId, after = 0) => eventsAfter.all(runId, after).map((r) => ({
 			runId,
 			seq: Number(r["seq"]),
-			at: text(r, "at"),
-			event: eventOf(text(r, "data"))
+			at: text$1(r, "at"),
+			event: eventOf(text$1(r, "data"))
 		})),
 		close: () => {
 			db.close();
@@ -1348,6 +1346,144 @@ const alive = (pid) => {
 };
 /** A run's status, with `crashed` for a `running` run whose process is gone. */
 const liveStatus = (run) => run.status === "running" && !alive(run.pid) ? "crashed" : run.status;
+// ../core/src/update/version.ts
+const VERSION = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u;
+/** `1.2.3`, `v1.2.3-beta.1` and the like; `null` for anything else. */
+const parseVersion = (text) => {
+	const match = VERSION.exec(text.trim());
+	if (match === null) return null;
+	const [, major = "0", minor = "0", patch = "0", pre] = match;
+	return {
+		core: [
+			Number(major),
+			Number(minor),
+			Number(patch)
+		],
+		pre: pre === void 0 ? [] : pre.split(".")
+	};
+};
+const NUMERIC = /^\d+$/u;
+/** One pre-release identifier against another: numbers sort below words. */
+const compareIdentifier = (a, b) => {
+	const an = NUMERIC.test(a);
+	const bn = NUMERIC.test(b);
+	if (an && bn) return Number(a) - Number(b);
+	if (an !== bn) return an ? -1 : 1;
+	return a < b ? -1 : Number(a > b);
+};
+const comparePre = (a, b) => {
+	if (a.length === 0 || b.length === 0) return b.length - a.length;
+	for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+		const order = compareIdentifier(a[i] ?? "", b[i] ?? "");
+		if (order !== 0) return order;
+	}
+	return a.length - b.length;
+};
+/** Semver precedence: negative when `a` is older, 0 when equal. */
+const compareVersions = (a, b) => {
+	for (let i = 0; i < 3; i += 1) {
+		const order = (a.core[i] ?? 0) - (b.core[i] ?? 0);
+		if (order !== 0) return order;
+	}
+	return comparePre(a.pre, b.pre);
+};
+/** Whether `candidate` is newer than `current`; false when either is invalid. */
+const isNewer = (candidate, current) => {
+	const a = parseVersion(candidate);
+	const b = parseVersion(current);
+	return a !== null && b !== null && compareVersions(a, b) > 0;
+};
+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;
+/** The package's `latest` version on the registry, 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) ? text(tags, "latest") : void 0) ?? 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 `latest` is kept.
+*/
+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/worktree/list.ts
 /**
 * @file What `ork worktrees` shows and cleans: every worktree and branch Ork's
@@ -2817,6 +2953,15 @@ const missingPrograms = (workflow, installed = (program) => onPath(program)) =>
 	}
 	return [...missing.values()];
 };
+// 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 = "0.2.0";
 // src/run/origin.ts
 /**
 * @file Where a run's feedback comes from, beyond what its events say: Ork's
@@ -3190,7 +3335,7 @@ const flagValues = (rawArgs, flag) => {
 };
 const isDriver = (value) => CLAUDE_DRIVERS.some((d) => d.id === value);
 /** Loads the drivers only when a run starts, so other commands stay fast. */
-const loadRuntime = async (driver) => (await import("./src-CDkj_-3F.mjs")).createRuntime(driver, process.env);
+const loadRuntime = async (driver) => (await import("./src-DAsOYtoR.mjs")).createRuntime(driver, process.env);
 /** Ctrl-C asks the run to stop. */
 const onInterrupt = (stop) => {
 	process.once("SIGINT", () => {
@@ -3942,6 +4087,428 @@ const resume = defineCommand({
 		}
 	}
 });
+// src/update/notify.ts
+/**
+* @file The new-version notice (ADR-038). At most once a day a command starts a
+*   detached copy of `ork` that asks the npm registry for the latest version
+*   and records it in `~/.ork/update-check.json`, so no command waits on the
+*   network; a later command, when a newer version is known, ends with one line
+*   on stderr (once a day). Off in CI, without a terminal, with `--json`, and
+*   with `ORK_NO_UPDATE_CHECK=1` or `NO_UPDATE_NOTIFIER=1`.
+*/
+/** Set in the background copy of `ork` that only runs the check. */
+const UPDATE_CHILD_ENV = "ORK_UPDATE_CHECK_CHILD";
+/** A registry to ask instead of npm's, e.g. a company mirror. */
+const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
+const on = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+/** Why the automatic check is off for this command, or `null` when it is on. */
+const updateCheckOff = (env, argv, terminal) => {
+	if (on(env["ORK_NO_UPDATE_CHECK"]) || on(env["NO_UPDATE_NOTIFIER"])) return "turned off";
+	if (on(env["CI"])) return "in CI";
+	if (on(env["ORK_DETACHED"]) || !terminal) return "no terminal";
+	if (argv.includes("--json")) return "JSON output";
+	if (argv[0] === "upgrade") return "ork upgrade checks for itself";
+	return null;
+};
+const registryOf = (env) => {
+	const registry = env[UPDATE_REGISTRY_ENV];
+	return registry === void 0 || registry === "" ? void 0 : registry;
+};
+/** The notice's text. */
+const updateNotice = (latest, current) => `Ork ${latest} is out (you have ${current}). Upgrade with: ork upgrade`;
+/**
+* Starts the background check when one is due. Records the attempt first, so
+* commands started in the next moments do not start one too.
+*/
+const startUpdateCheck = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
+	try {
+		const cache = readUpdateCache(file);
+		if (!checkDue(cache, now)) return;
+		writeUpdateCache(file, {
+			...cache,
+			checkedAt: now.toISOString()
+		});
+		const child = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? ""], {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				[UPDATE_CHILD_ENV]: "1"
+			}
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+};
+/** The background copy's whole job: ask the registry, record the answer. */
+const runUpdateChild = async () => {
+	const registry = registryOf(process.env);
+	await refreshUpdateCache(updateCachePath(), ORK_NAME, /* @__PURE__ */ new Date(), registry === void 0 ? {} : { registry });
+};
+/** Prints the notice when a newer version is known and not told today. */
+const showUpdateNotice = (file = updateCachePath(), now = /* @__PURE__ */ new Date()) => {
+	try {
+		const cache = readUpdateCache(file);
+		const latest = pendingNotice(cache, ORK_VERSION, now);
+		if (cache === null || latest === null) return;
+		const text = updateNotice(latest, ORK_VERSION);
+		process.stderr.write(`\n${styleText("yellow", text, { stream: process.stderr })}\n`);
+		writeUpdateCache(file, {
+			...cache,
+			notified: {
+				version: latest,
+				at: now.toISOString()
+			}
+		});
+	} catch {}
+};
+// src/update/upgrade.ts
+/**
+* @file What `ork upgrade` does (ADR-038): compares the registry's latest
+*   version with this one, works out how Ork was installed, and gives the
+*   command to run (a global npm, pnpm, yarn, bun or Volta install) or advice
+*   (a clone, `npx`); runs the command when the user agrees. Also the version
+*   line of `ork doctor`, read from the cache without asking the network.
+*/
+const REPOSITORY = "https://github.com/mimshins/ork";
+/** The GitHub release page of a version, with its changes. */
+const releaseNotes = (name, version) => `${REPOSITORY}/releases/tag/${encodeURIComponent(`${name}@${version}`)}`;
+/** The running script's real path, which tells how Ork was installed. */
+const runningScript = () => {
+	const script = process.argv[1] ?? "";
+	try {
+		return realpathSync(script);
+	} catch {
+		return script;
+	}
+};
+const planUpgrade = (options) => {
+	const { latest, name } = options;
+	if (latest === null) return { kind: "unreachable" };
+	if (!isNewer(latest, options.current)) return { kind: "latest" };
+	const spec = `${name}@${latest}`;
+	const installer = detectInstaller(options.script, options.installers);
+	if (installer?.command !== void 0) return {
+		kind: "command",
+		latest,
+		installer,
+		argv: installer.command(spec)
+	};
+	return {
+		kind: "advice",
+		latest,
+		text: installer?.advice?.(spec, options.script.replaceAll("\\", "/")) ?? `Ork could not tell how it was installed. With npm: npm install --global ${spec}`
+	};
+};
+/** Runs the installer's command on this terminal; resolves its exit code. */
+const runInstall = (argv) => new Promise((resolve) => {
+	const [program = "", ...args] = argv;
+	const child = spawn(program, args, { stdio: "inherit" });
+	child.on("error", (error) => {
+		process.stderr.write(`Could not run ${program}: ${error.message}\n`);
+		resolve(127);
+	});
+	child.on("close", (code) => {
+		resolve(code ?? 1);
+	});
+});
+/** `ork doctor`'s line for Ork itself, from the last check. */
+const versionCheck = (current, cache, checksOff) => {
+	const newer = newerVersion(cache, current);
+	if (newer !== null) return {
+		name: "ork",
+		status: "warn",
+		detail: `${current}; ${newer} is out`,
+		hint: "Run ork upgrade."
+	};
+	return {
+		name: "ork",
+		status: "ok",
+		detail: `${current} (${cache?.latest === void 0 ? checksOff ? "update check off" : "not checked for updates yet" : `the latest as of ${cache.checkedAt.slice(0, 10)}`})`
+	};
+};
+// src/doctor/checks.ts
+/**
+* @file The checks behind `ork doctor`: Ork's own version against the last
+*   update check, and each tool's presence and login status, through an
+*   injectable `exec` so tests need no real tools. Never prints a token or an
+*   account.
+*/
+const TIMEOUT_MS = 15e3;
+const exec = (program, args) => new Promise((resolve) => {
+	execFile(program, args, {
+		timeout: TIMEOUT_MS,
+		encoding: "utf8"
+	}, (error, stdout) => {
+		resolve({
+			ok: error === null,
+			stdout
+		});
+	});
+});
+/** Ork's own version, against the last update check (no network). */
+const orkCheck = () => versionCheck(ORK_VERSION, readUpdateCache(updateCachePath()), updateCheckOff(process.env, [], true) !== null);
+const MIN_NODE = [24, 20];
+const checkNode = (version) => {
+	const [major = 0, minor = 0] = version.split(".").map(Number);
+	const [minMajor, minMinor] = MIN_NODE;
+	return major > minMajor || major === minMajor && minor >= minMinor ? {
+		name: "node",
+		status: "ok",
+		detail: `v${version}`
+	} : {
+		name: "node",
+		status: "fail",
+		detail: `v${version}`,
+		hint: `Ork needs Node ${MIN_NODE.join(".")} or later.`
+	};
+};
+const checkGit = async (run) => {
+	const version = await run("git", ["--version"]);
+	if (!version.ok) return [{
+		name: "git",
+		status: "fail",
+		detail: "not found",
+		hint: "Install git; Ork gives each writing node its own worktree."
+	}];
+	const inside = await run("git", ["rev-parse", "--is-inside-work-tree"]);
+	return [{
+		name: "git",
+		status: "ok",
+		detail: firstLine$1(version.stdout)
+	}, inside.ok ? {
+		name: "git repo",
+		status: "ok",
+		detail: "inside a work tree"
+	} : {
+		name: "git repo",
+		status: "warn",
+		detail: "not a git repository",
+		hint: "Run Ork inside a git repository so nodes can use worktrees."
+	}];
+};
+/**
+* Runs every check: Node and git, then every registered Claude driver and
+* integration (ADR-022). Node, git, and at least one driver are required;
+* integrations are optional.
+*/
+const runChecks = async (run, env, nodeVersion) => {
+	const [git, drivers, tools] = await Promise.all([
+		checkGit(run),
+		Promise.all(CLAUDE_DRIVERS.map((d) => d.doctor(run, env))),
+		Promise.all(INTEGRATIONS.flatMap((i) => i.doctor === void 0 ? [] : [i.doctor(run, env)]))
+	]);
+	const results = [
+		checkNode(nodeVersion),
+		...git,
+		...drivers,
+		...tools
+	];
+	return {
+		results,
+		ok: drivers.some((d) => d.status === "ok") && !results.some((r) => r.status === "fail")
+	};
+};
+// src/project/link.ts
+/**
+* @file What `ork link` and `ork doctor` say about a project's tool folders:
+*   one line per folder (linked, created, kept as a real folder, pointing
+*   elsewhere, broken), and one doctor check per tool the project uses, only
+*   once the project has `.ork/`.
+*/
+const DESCRIBE = {
+	linked: (link) => `${link.path} → ${link.origin}`,
+	missing: (link) => `${link.path} → ${link.origin}`,
+	broken: (link) => `${link.path} → ${link.target ?? "?"}, which does not exist`,
+	elsewhere: (link) => `${link.path} → ${link.target ?? "?"}, not ${link.origin}`,
+	folder: (link) => `${link.path} is a real folder, left as it is`
+};
+const describe = (link) => DESCRIBE[link.state](link);
+const LABEL = {
+	linked: style("dim", "ok     "),
+	missing: style("yellow", "missing"),
+	broken: style("red", "broken "),
+	elsewhere: style("yellow", "kept   "),
+	folder: style("yellow", "kept   ")
+};
+/** One line per folder; `created` marks the links this call made. */
+const formatLinks = (links, created = []) => links.map((link) => {
+	return `${created.includes(link.path) ? style("green", "linked ") : LABEL[link.state]} ${describe(link)}`;
+});
+const checkOf = (tool, links) => {
+	const name = `${AGENT_TOOL_LAYOUTS.find((l) => l.id === tool)?.name ?? tool} links`;
+	const detail = links.map((link) => describe(link)).join("; ");
+	if (links.every((l) => l.state === "linked")) return {
+		name,
+		status: "ok",
+		detail: links.map((l) => l.path).join(", ")
+	};
+	if (links.some((l) => l.state === "broken" || l.state === "missing")) return {
+		name,
+		status: "warn",
+		detail,
+		hint: `Run ork link ${tool} to link what is missing; a broken link needs fixing by hand.`
+	};
+	return {
+		name,
+		status: "skip",
+		detail
+	};
+};
+/**
+* One check per tool the project uses, once it has `.ork/`: are its folders
+* linked to `.ork/agents` and `.ork/skills`?
+*/
+const linkChecks = (projectRoot) => {
+	const ork = path.dirname(ORK_LAYOUT.agents);
+	if (!existsSync(path.join(projectRoot, ork))) return [];
+	const links = toolLinks(projectRoot, toolsInUse(projectRoot));
+	return Object.entries(Object.groupBy(links, (link) => link.tool)).map(([tool, group = []]) => checkOf(tool, group));
+};
+// src/commands/install.ts
+/**
+* @file This installation of Ork: its name and version for the root command;
+*   `ork doctor`, which prints Ork's version against the last update check and
+*   the environment checks (Node, git, the user's own claude, gh and aws
+*   logins, the project's links) and fails when no Claude driver can run; and
+*   `ork upgrade`, which asks the npm registry for the latest version and, when
+*   it is newer, upgrades Ork the way it was installed after the user agrees
+*   (`--yes` skips the question; `--check` only reports). A clone or `npx` gets
+*   advice instead. Ork never upgrades itself unasked, and stores no
+*   credentials (ADR-038).
+*/
+/** The root command's name, version and description. */
+const ORK_META = {
+	name: "ork",
+	version: ORK_VERSION,
+	description: "Orchestrate Claude agents on your machine"
+};
+const MARK = {
+	ok: style("green", "✓"),
+	warn: style("yellow", "!"),
+	fail: style("red", "✗"),
+	skip: style("dim", "-")
+};
+const formatCheck = (result) => {
+	const line = `${MARK[result.status]} ${result.name.padEnd(20)} ${result.detail}`;
+	return result.hint === void 0 ? [line] : [line, `  ${style("dim", result.hint)}`];
+};
+const doctor = defineCommand({
+	meta: {
+		name: "doctor",
+		description: "Check Node, git, and your own claude, gh, and aws logins (Ork stores no credentials)"
+	},
+	run: async () => {
+		const { results, ok } = await runChecks(exec, process.env, process.versions.node);
+		const place = projectAt(process.cwd());
+		for (const result of [
+			orkCheck(),
+			...results,
+			...place.mode === "attached" ? [] : linkChecks(place.root)
+		]) for (const line of formatCheck(result)) write(line);
+		if (!ok) {
+			write(`\n${style("red", "Not ready:")} Ork needs Node, git, and at least one Claude driver.`);
+			process.exitCode = 1;
+		}
+	}
+});
+/** The ids of runs still running anywhere on this machine. */
+const runningRuns = () => {
+	const store = openStore();
+	try {
+		return store.runs({ limit: 500 }).filter((run) => liveStatus(run) === "running").map((run) => run.id.slice(0, 8));
+	} finally {
+		store.close();
+	}
+};
+/** Records what the registry said, so the notice and doctor agree with it. */
+const remember = (latest, notified) => {
+	try {
+		const file = updateCachePath();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		writeUpdateCache(file, {
+			...readUpdateCache(file),
+			checkedAt: now,
+			latest,
+			...notified ? { notified: {
+				version: latest,
+				at: now
+			} } : {}
+		});
+	} catch {}
+};
+/** Whether to go ahead: `--yes`, or the user says so on a terminal. */
+const agreed = (yes, command) => {
+	if (yes) return Promise.resolve(true);
+	if (!process.stdin.isTTY) {
+		write(`Run it yourself: ${command}\nor run ork upgrade --yes.`);
+		return Promise.resolve(false);
+	}
+	return confirm(`Run ${style("bold", command)}? [y/N] `);
+};
+const upgrade = defineCommand({
+	meta: {
+		name: "upgrade",
+		description: "Upgrade Ork to the latest version, the way it was installed (asks first)"
+	},
+	args: {
+		check: {
+			type: "boolean",
+			description: "Only say whether a newer version is out",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Run the upgrade without asking",
+			default: false
+		}
+	},
+	run: async ({ args }) => {
+		const registry = registryOf(process.env);
+		const latest = await fetchLatest(ORK_NAME, {
+			...registry === void 0 ? {} : { registry },
+			timeoutMs: 15e3
+		});
+		const plan = planUpgrade({
+			name: ORK_NAME,
+			current: ORK_VERSION,
+			latest,
+			script: runningScript()
+		});
+		if (plan.kind === "unreachable") {
+			writeErr("Could not reach the npm registry to look for a new version.");
+			process.exitCode = 1;
+			return;
+		}
+		if (latest !== null) remember(latest, plan.kind !== "latest");
+		if (plan.kind === "latest") {
+			write(`${style("green", "✓")} Ork ${ORK_VERSION} is the latest version.`);
+			return;
+		}
+		write(`Ork ${style("bold", plan.latest)} is out (you have ${ORK_VERSION}).\nWhat changed: ${releaseNotes(ORK_NAME, plan.latest)}`);
+		if (args.check) return;
+		if (plan.kind === "advice") {
+			write(plan.text);
+			process.exitCode = 1;
+			return;
+		}
+		const running = runningRuns();
+		if (running.length > 0) write(`${style("yellow", "!")} Running now: ${running.join(", ")}. Their next sessions would start from the new install; upgrading after they finish is safer.`);
+		const command = plan.argv.join(" ");
+		write(`Installed with ${plan.installer.label}.`);
+		if (!await agreed(args.yes, command)) {
+			process.exitCode = 1;
+			return;
+		}
+		const code = await runInstall(plan.argv);
+		if (code !== 0) {
+			writeErr(`${command} failed (exit ${code}); the upgrade did not finish.`);
+			process.exitCode = code;
+			return;
+		}
+		write(`${style("green", "✓")} Upgraded Ork to ${plan.latest}.`);
+	}
+});
 // src/project/draft.ts
 /**
 * @file `ork migrate --from-agents` (ADR-036): drafts a workflow from a
@@ -4370,62 +4937,6 @@ const initRecorded = (store, cwd, options = {}) => {
 	const recorded = recordInRepo(store, cwd);
 	return recorded.ok ? initProject(cwd, options) : { error: recorded.error };
 };
-// src/project/link.ts
-/**
-* @file What `ork link` and `ork doctor` say about a project's tool folders:
-*   one line per folder (linked, created, kept as a real folder, pointing
-*   elsewhere, broken), and one doctor check per tool the project uses, only
-*   once the project has `.ork/`.
-*/
-const DESCRIBE = {
-	linked: (link) => `${link.path} → ${link.origin}`,
-	missing: (link) => `${link.path} → ${link.origin}`,
-	broken: (link) => `${link.path} → ${link.target ?? "?"}, which does not exist`,
-	elsewhere: (link) => `${link.path} → ${link.target ?? "?"}, not ${link.origin}`,
-	folder: (link) => `${link.path} is a real folder, left as it is`
-};
-const describe = (link) => DESCRIBE[link.state](link);
-const LABEL = {
-	linked: style("dim", "ok     "),
-	missing: style("yellow", "missing"),
-	broken: style("red", "broken "),
-	elsewhere: style("yellow", "kept   "),
-	folder: style("yellow", "kept   ")
-};
-/** One line per folder; `created` marks the links this call made. */
-const formatLinks = (links, created = []) => links.map((link) => {
-	return `${created.includes(link.path) ? style("green", "linked ") : LABEL[link.state]} ${describe(link)}`;
-});
-const checkOf = (tool, links) => {
-	const name = `${AGENT_TOOL_LAYOUTS.find((l) => l.id === tool)?.name ?? tool} links`;
-	const detail = links.map((link) => describe(link)).join("; ");
-	if (links.every((l) => l.state === "linked")) return {
-		name,
-		status: "ok",
-		detail: links.map((l) => l.path).join(", ")
-	};
-	if (links.some((l) => l.state === "broken" || l.state === "missing")) return {
-		name,
-		status: "warn",
-		detail,
-		hint: `Run ork link ${tool} to link what is missing; a broken link needs fixing by hand.`
-	};
-	return {
-		name,
-		status: "skip",
-		detail
-	};
-};
-/**
-* One check per tool the project uses, once it has `.ork/`: are its folders
-* linked to `.ork/agents` and `.ork/skills`?
-*/
-const linkChecks = (projectRoot) => {
-	const ork = path.dirname(ORK_LAYOUT.agents);
-	if (!existsSync(path.join(projectRoot, ork))) return [];
-	const links = toolLinks(projectRoot, toolsInUse(projectRoot));
-	return Object.entries(Object.groupBy(links, (link) => link.tool)).map(([tool, group = []]) => checkOf(tool, group));
-};
 // src/project/migrate.ts
 /**
 * @file `ork migrate` (ADR-036): moves an attached project's folder into its
@@ -5357,94 +5868,13 @@ const addAgent = (options) => {
 	if (options.model !== void 0) agent.model = options.model;
 	return createAgent(options.name, agent, options);
 };
-// src/doctor/checks.ts
-/**
-* @file The checks behind `ork doctor`: each tool's presence and login status,
-*   through an injectable `exec` so tests need no real tools. Never prints a
-*   token or an account.
-*/
-const TIMEOUT_MS = 15e3;
-const exec = (program, args) => new Promise((resolve) => {
-	execFile(program, args, {
-		timeout: TIMEOUT_MS,
-		encoding: "utf8"
-	}, (error, stdout) => {
-		resolve({
-			ok: error === null,
-			stdout
-		});
-	});
-});
-const MIN_NODE = [24, 20];
-const checkNode = (version) => {
-	const [major = 0, minor = 0] = version.split(".").map(Number);
-	const [minMajor, minMinor] = MIN_NODE;
-	return major > minMajor || major === minMajor && minor >= minMinor ? {
-		name: "node",
-		status: "ok",
-		detail: `v${version}`
-	} : {
-		name: "node",
-		status: "fail",
-		detail: `v${version}`,
-		hint: `Ork needs Node ${MIN_NODE.join(".")} or later.`
-	};
-};
-const checkGit = async (run) => {
-	const version = await run("git", ["--version"]);
-	if (!version.ok) return [{
-		name: "git",
-		status: "fail",
-		detail: "not found",
-		hint: "Install git; Ork gives each writing node its own worktree."
-	}];
-	const inside = await run("git", ["rev-parse", "--is-inside-work-tree"]);
-	return [{
-		name: "git",
-		status: "ok",
-		detail: firstLine$1(version.stdout)
-	}, inside.ok ? {
-		name: "git repo",
-		status: "ok",
-		detail: "inside a work tree"
-	} : {
-		name: "git repo",
-		status: "warn",
-		detail: "not a git repository",
-		hint: "Run Ork inside a git repository so nodes can use worktrees."
-	}];
-};
-/**
-* Runs every check: Node and git, then every registered Claude driver and
-* integration (ADR-022). Node, git, and at least one driver are required;
-* integrations are optional.
-*/
-const runChecks = async (run, env, nodeVersion) => {
-	const [git, drivers, tools] = await Promise.all([
-		checkGit(run),
-		Promise.all(CLAUDE_DRIVERS.map((d) => d.doctor(run, env))),
-		Promise.all(INTEGRATIONS.flatMap((i) => i.doctor === void 0 ? [] : [i.doctor(run, env)]))
-	]);
-	const results = [
-		checkNode(nodeVersion),
-		...git,
-		...drivers,
-		...tools
-	];
-	return {
-		results,
-		ok: drivers.some((d) => d.status === "ok") && !results.some((r) => r.status === "fail")
-	};
-};
 // src/commands/setup.ts
 /**
 * @file Setting up: `ork init` scaffolds `.ork/` in a project, records it, and
 *   links the tool folders it uses; `ork link` points tools' agents and skills
 *   folders at `.ork/` (never in an attached project); `ork agents` lists,
-*   shows, adds and removes the agents nodes can take; `ork doctor` prints the
-*   environment checks (Node, git, the user's own claude, gh and aws logins,
-*   and the project's links) and fails when no Claude driver can run. Ork
-*   stores no credentials.
+*   shows, adds and removes the agents nodes can take. `ork doctor` and `ork
+*   upgrade` live in `install.ts`.
 */
 const init = defineCommand({
 	meta: {
@@ -5512,31 +5942,6 @@ const link = defineCommand({
 		for (const line of formatLinks(result.links, result.created)) write(line);
 	}
 });
-const MARK = {
-	ok: style("green", "✓"),
-	warn: style("yellow", "!"),
-	fail: style("red", "✗"),
-	skip: style("dim", "-")
-};
-const formatCheck = (result) => {
-	const line = `${MARK[result.status]} ${result.name.padEnd(20)} ${result.detail}`;
-	return result.hint === void 0 ? [line] : [line, `  ${style("dim", result.hint)}`];
-};
-const doctor = defineCommand({
-	meta: {
-		name: "doctor",
-		description: "Check Node, git, and your own claude, gh, and aws logins (Ork stores no credentials)"
-	},
-	run: async () => {
-		const { results, ok } = await runChecks(exec, process.env, process.versions.node);
-		const place = projectAt(process.cwd());
-		for (const result of [...results, ...place.mode === "attached" ? [] : linkChecks(place.root)]) for (const line of formatCheck(result)) write(line);
-		if (!ok) {
-			write(`\n${style("red", "Not ready:")} Ork needs Node, git, and at least one Claude driver.`);
-			process.exitCode = 1;
-		}
-	}
-});
 const json = {
 	type: "boolean",
 	description: "Print JSON",
@@ -5673,11 +6078,7 @@ const agents = defineCommand({
 // src/main.ts
 /** @file The root `ork` command and its subcommands. */
 const main = defineCommand({
-	meta: {
-		name: "ork",
-		version: ORK_VERSION,
-		description: "Orchestrate Claude agents on your machine"
-	},
+	meta: ORK_META,
 	subCommands: {
 		init,
 		register,
@@ -5698,13 +6099,26 @@ const main = defineCommand({
 		context,
 		worktrees,
 		wt: worktrees,
-		doctor
+		doctor,
+		upgrade
 	}
 });
 // src/bin.ts
 /**
 * @file The `ork` executable: runs the CLI's root command. The published
-*   package's `bin` points at its bundle.
+*   package's `bin` points at its bundle. When the new-version check is on, it
+*   starts the daily background check and ends with the notice (ADR-038); the
+*   background copy it starts only runs the check.
 */
-await runMain(main);
+if (process.env["ORK_UPDATE_CHECK_CHILD"] === "1") await runUpdateChild();
+else {
+	const argv = process.argv.slice(2);
+	if (updateCheckOff(process.env, argv, process.stderr.isTTY) === null) {
+		startUpdateCheck();
+		process.once("exit", () => {
+			showUpdateNotice();
+		});
+	}
+	await runMain(main);
+}
 export {};

package/dist/{src-CqNlvqV_.mjs → src-CJ_zF0Zj.mjs}

@@ -4581,6 +4581,82 @@ const startRun = (options) => {
 		tell: ports.bus.tell
 	};
 };
+// ../core/src/update/installers.ts
+const SOURCE = "/packages/cli/";
+const has = (...parts) => (script) => parts.some((part) => script.includes(part));
+const INSTALLERS = [
+	{
+		id: "source",
+		label: "a clone of the repository",
+		owns: (script) => script.includes(SOURCE) && !script.includes("/node_modules/"),
+		advice: (_spec, script) => `In ${script.slice(0, script.indexOf(SOURCE))}: git pull, then pnpm install and pnpm build.`
+	},
+	{
+		id: "npx",
+		label: "npx",
+		owns: has("/_npx/"),
+		advice: (spec) => `npx keeps its own copy: run npx ${spec} …, or install it with npm install --global ${spec}.`
+	},
+	{
+		id: "pnpm",
+		label: "pnpm (global)",
+		owns: has("/pnpm/global/", "/.pnpm-global/"),
+		command: (spec) => [
+			"pnpm",
+			"add",
+			"--global",
+			spec
+		]
+	},
+	{
+		id: "yarn",
+		label: "yarn (global)",
+		owns: has("/yarn/global/"),
+		command: (spec) => [
+			"yarn",
+			"global",
+			"add",
+			spec
+		]
+	},
+	{
+		id: "bun",
+		label: "bun (global)",
+		owns: has("/.bun/install/global/"),
+		command: (spec) => [
+			"bun",
+			"add",
+			"--global",
+			spec
+		]
+	},
+	{
+		id: "volta",
+		label: "Volta",
+		owns: has("/.volta/tools/"),
+		command: (spec) => [
+			"volta",
+			"install",
+			spec
+		]
+	},
+	{
+		id: "npm",
+		label: "npm (global)",
+		owns: has("/node_modules/"),
+		command: (spec) => [
+			"npm",
+			"install",
+			"--global",
+			spec
+		]
+	}
+];
+/** The installer of the running script, or `undefined` when none fits. */
+const detectInstaller = (script, installers = INSTALLERS) => {
+	const normal = script.replaceAll("\\", "/");
+	return installers.find((i) => i.owns(normal));
+};
 // ../core/src/worktree/git.ts
 /**
 * @file A minimal `git` runner for the worktree manager: arguments without a
@@ -5354,4 +5430,4 @@ const createWorkspace = (options) => {
 		close
 	};
 };
-export { parseWorkflow as $, planAgentMigration as A, PROJECT_MODES as B, fingerprint as C, parseTemplate as D, maskSecrets as E, toolsInUse as F, placeFor as G, inRepoPlace as H, createAgent as I, shownPath as J, projectsHome as K, deleteAgent as L, planMoveInto as M, linkTools as N, renderTemplate as O, toolLinks as P, SKILL_FILE as Q, catalogAgent as R, createFeedback as S, maskReplacer as T, newProjectId as U, hasInRepoFiles as V, placeFiles as W, inside as X, workflowDirOf as Y, projectRootOf as Z, gitRulesOf as _, removeWorktree as a, INTEGRATIONS as at, FEEDBACK_SEVERITIES as b, lines as c, AGENT_TOOL_LAYOUTS as ct, parseReport as d, firstLine as dt, serializeWorkflow as et, userMessageText as f, compileWorkflow as g, resolvePractices as h, inspectProject as i, isToolNode as it, applySteps as j, contextDiagnostics as k, startRun as l, ORK_LAYOUT as lt, practiceInstructions as m, resolveBase as n, settingsOf as nt, git as o, TOOL_PREFIX as ot, runScope as p, runDirOf as q, BRANCH_PREFIX as r, isClaudeNode as rt, gitOk as s, integrationFor as st, createWorkspace as t, WorkflowSchema as tt, planNodeSession as u, CLAUDE_DRIVERS as ut, loadProject as v, targetOf as w, FEEDBACK_TARGETS as x, FEEDBACK_KINDS as y, loadAgents as z };
+export { SKILL_FILE as $, contextDiagnostics as A, loadAgents as B, createFeedback as C, maskSecrets as D, maskReplacer as E, toolLinks as F, placeFiles as G, hasInRepoFiles as H, toolsInUse as I, runDirOf as J, placeFor as K, createAgent as L, applySteps as M, planMoveInto as N, parseTemplate as O, linkTools as P, projectRootOf as Q, deleteAgent as R, FEEDBACK_TARGETS as S, targetOf as T, inRepoPlace as U, PROJECT_MODES as V, newProjectId as W, workflowDirOf as X, shownPath as Y, inside as Z, compileWorkflow as _, removeWorktree as a, isToolNode as at, FEEDBACK_KINDS as b, lines as c, integrationFor as ct, planNodeSession as d, CLAUDE_DRIVERS as dt, parseWorkflow as et, parseReport as f, firstLine as ft, resolvePractices as g, practiceInstructions as h, inspectProject as i, isClaudeNode as it, planAgentMigration as j, renderTemplate as k, detectInstaller as l, AGENT_TOOL_LAYOUTS as lt, runScope as m, resolveBase as n, WorkflowSchema as nt, git as o, INTEGRATIONS as ot, userMessageText as p, projectsHome as q, BRANCH_PREFIX as r, settingsOf as rt, gitOk as s, TOOL_PREFIX as st, createWorkspace as t, serializeWorkflow as tt, startRun as u, ORK_LAYOUT as ut, gitRulesOf as v, fingerprint as w, FEEDBACK_SEVERITIES as x, loadProject as y, catalogAgent as z };

package/dist/{src-CDkj_-3F.mjs → src-DAsOYtoR.mjs}

@@ -1,4 +1,4 @@
-import { b as FEEDBACK_SEVERITIES, d as parseReport, x as FEEDBACK_TARGETS, y as FEEDBACK_KINDS } from "./src-CqNlvqV_.mjs";
+import { S as FEEDBACK_TARGETS, b as FEEDBACK_KINDS, f as parseReport, x as FEEDBACK_SEVERITIES } from "./src-CJ_zF0Zj.mjs";
 import { z } from "zod";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createInterface } from "node:readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krapht/ork",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
     "claude",