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

package/dist/{src-8Mul0695.mjs → src-DQKz2eOH.mjs}

@@ -1,79 +1,15 @@
-import { An as END_KINDS, Ar as readDocument, C as capsHere, D as runningScript, Dn as endOf, Dr as WorkflowEditSchema, E as runningRunIds, Er as skillsIn, Fn as DISCUSSIONS, Fr as parseWorkflow, Gt as pausedOf, H as isNodeEvent, In as planPost, It as checkWorkflowText, Kt as runStatus, Ln as runGh, Lt as walkChecks, N as triggersReport, O as detectInstaller, Or as applyEdits, Ot as limitsReport, Pr as renderJsonSchema, Qt as nestItems, Rn as sendPost, Rr as EdgeInputSchema, Rt as walkSummary, S as usageReport, St as resumable, T as releaseNotes, Tt as followEvents, U as openStore, Ur as NodeSchema, Ut as liveStatus, V as activeTree, Vr as expandEdge, W as storePath, Yt as processAlive, _ as keyOf, _n as nodeSays, _t as requestPause, a as planRemove, b as stepPrunes, d as planLine, f as removeRefusal, g as cleanStep, gr as runDirOf, gt as requestContinue, h as applyClean, ht as unlinkNodes, i as lostWork, jt as explainWorkflowText, kr as newWorkflowText, l as labelOf, lr as loadAgents, lt as answerDecision, mr as placeFor, mt as linkNodes, o as projectHead, p as stateParts, pr as placeFiles, qn as readCondition, r as applyRemove, s as readWorktrees, u as mergeStateOf, ut as pendingDecisions, v as planClean, vr as workflowDirOf, vt as requestStop, w as planUpgrade, wt as detachRun, xr as LESSON_CAP_TOKENS, xt as detachResume, y as stepActs, yr as inside, yt as tellLiveRun } from "./src-tsuZRu0H.mjs";
-import { C as feedbackActions, S as placeOf$1, _ as previewPost, a as registryShown, b as acceptItem, c as checkDue, f as readUpdateCache, g as nodeSession, h as writeUpdateCache, i as registryOf, l as fetchLatest, m as updateCachePath, o as updateSwitchOff, p as refreshUpdateCache, s as runInstall, u as newerVersion, w as openFixRun, x as lessonPlaceOf, y as recordNote } from "./__build_info__-B82-dGJY.mjs";
-import { t as builtinProblem } from "./builtin-files-Bdq23IIi.mjs";
-import { n as newRunId, t as findRun } from "./find-BVX-bL4u.mjs";
+import { At as walkSummary, Br as WorkflowEditSchema, C as capsHere, Cn as liveStatus, Ct as explainWorkflowText, D as runningScript, Dr as placeFor, E as runningRunIds, En as runStatus, Er as placeFiles, H as isNodeEvent, Hn as END_KINDS, Hr as newWorkflowText, In as loadProject, Jn as planPost, Jr as parseWorkflow, Mn as nestItems, Mr as inside, N as triggersReport, O as detectInstaller, Ot as checkWorkflowText, Pr as LESSON_CAP_TOKENS, S as usageReport, Sn as tellLiveRun, Sr as loadAgents, T as releaseNotes, Tn as pausedOf, U as openStore, Ur as readDocument, V as activeTree, Vr as applyEdits, W as storePath, Xn as sendPost, Yn as runGh, Zr as EdgeInputSchema, _ as keyOf, _n as linkNodes, _t as followEvents, a as planRemove, b as stepPrunes, bn as requestPause, bt as limitsReport, d as planLine, ei as expandEdge, en as nodeSays, f as removeRefusal, g as cleanStep, gt as detachRun, h as applyClean, i as lostWork, jr as workflowDirOf, kn as processAlive, kr as runDirOf, kt as walkChecks, l as labelOf, ln as startFollowUpChecks, lt as answerDecision, mn as DEFAULT_FOLLOW_UPS_RULE, mt as resumable, ni as NodeSchema, o as projectHead, on as checkFollowUpsDue, or as readCondition, p as stateParts, pn as liveSessionOf, pt as detachResume, qn as DISCUSSIONS, qr as renderJsonSchema, r as applyRemove, s as readWorktrees, u as mergeStateOf, ut as pendingDecisions, v as planClean, vn as unlinkNodes, w as planUpgrade, xn as requestStop, y as stepActs, yn as requestContinue, zn as endOf, zr as skillsIn } from "./src-Dr_fTSu-.mjs";
+import { a as acceptItem, c as feedbackActions, i as recordNote, l as openFixRun, n as previewPost, o as lessonPlaceOf, s as placeOf$1, t as runInstall } from "./install-DWtXTq4y.mjs";
+import { _ as dueCause, a as registryShown, c as fetchLatest, d as readUpdateCache, f as refreshUpdateCache, g as changeFollowUp, h as nodeSession, i as registryOf, l as newerVersion, m as writeUpdateCache, o as updateSwitchOff, p as updateCachePath, s as checkDue, v as findFollowUp, y as followUpActions } from "./__build_info__-Bsb1kjgF.mjs";
+import { t as postFollowUpMessage } from "./post-BzA6Qobq.mjs";
+import { t as builtinProblem } from "./builtin-files-2bHf76x-.mjs";
+import { n as newRunId, t as findRun } from "./find-BYLlszqj.mjs";
 import path from "node:path";
 import { z } from "zod";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
 import { createServer } from "node:http";
-// ../server/src/contract-builder.ts
-/** A new workflow's name, as its file and its `name:` take it. */
-const NewWorkflowSchema = z.strictObject({ name: z.string().min(1) });
-/** The server checks each edit; this file imports only types of the schema. */
-const WorkflowEditsSchema = z.strictObject({ edits: z.array(z.custom()).min(1) });
-/** Earlier text, and the file it was based on, to ask before replacing it. */
-const DraftTextSchema = z.strictObject({
-	text: z.string(),
-	baseHash: z.string().nullable()
-});
-const SaveWorkflowSchema = z.strictObject({ 
-/** Write over a file that changed since this draft began. */
-force: z.boolean().optional() });
-const BUILDER_API = {
-	builderSchema: {
-		method: "GET",
-		path: "/api/workflow-schema"
-	},
-	builderCatalog: {
-		method: "GET",
-		path: "/api/projects/:id/catalog"
-	},
-	builderDrafts: {
-		method: "GET",
-		path: "/api/projects/:id/builder"
-	},
-	builderView: {
-		method: "GET",
-		path: "/api/projects/:id/builder/:name"
-	},
-	builderCreate: {
-		method: "POST",
-		path: "/api/projects/:id/builder",
-		body: NewWorkflowSchema
-	},
-	builderEdit: {
-		method: "POST",
-		path: "/api/projects/:id/builder/:name/edits",
-		body: WorkflowEditsSchema
-	},
-	builderRestore: {
-		method: "POST",
-		path: "/api/projects/:id/builder/:name/text",
-		body: DraftTextSchema
-	},
-	builderDiscard: {
-		method: "POST",
-		path: "/api/projects/:id/builder/:name/discard"
-	},
-	builderSave: {
-		method: "POST",
-		path: "/api/projects/:id/builder/:name/save",
-		body: SaveWorkflowSchema
-	}
-};
-// ../server/src/contract-context.ts
-const CONTEXT_API = {
-	runContext: {
-		method: "GET",
-		path: "/api/runs/:id/nodes/:node/context"
-	},
-	builderContext: {
-		method: "GET",
-		path: "/api/projects/:id/builder/:name/nodes/:node/context"
-	}
-};
 // ../server/src/contract-feedback.ts
 const NoteSchema = z.strictObject({
 	/** Its first line is the title. */
@@ -153,6 +89,133 @@ const FEEDBACK_API = {
 		path: "/api/feedback/:id/split"
 	}
 };
+// ../server/src/contract-follow-ups.ts
+/** `open` is due and waiting, the default; `all` adds done and dropped. */
+const FollowUpsQuerySchema = z.strictObject({
+	status: z.enum([
+		"open",
+		"all",
+		"due",
+		"waiting",
+		"done",
+		"dropped"
+	]).optional(),
+	/** Only those for this: `agent`, `me`, `project:<name>` or `person:<name>`. */
+	for: z.string().min(1).optional()
+});
+const FollowUpChangeSchema = z.strictObject({ action: z.enum([
+	"done",
+	"drop",
+	"reopen",
+	"due"
+]) });
+/**
+* Posts a drafted GitHub comment through the person's own `gh`. `confirm` says
+* yes, and `digest` is the detail's `draftDigest`, which stands for the
+* recipient and text they saw: the route refuses when the draft is no longer
+* that, so nothing else is sent.
+*/
+const FollowUpPostSchema = z.strictObject({
+	confirm: z.literal(true),
+	digest: z.string().min(1)
+});
+const FOLLOW_UPS_API = {
+	followUps: {
+		method: "GET",
+		path: "/api/projects/:id/follow-ups",
+		query: FollowUpsQuerySchema
+	},
+	followUp: {
+		method: "GET",
+		path: "/api/projects/:id/follow-ups/:followUp"
+	},
+	followUpChange: {
+		method: "POST",
+		path: "/api/projects/:id/follow-ups/:followUp",
+		body: FollowUpChangeSchema
+	},
+	followUpPost: {
+		method: "POST",
+		path: "/api/projects/:id/follow-ups/:followUp/post",
+		body: FollowUpPostSchema
+	}
+};
+// ../server/src/contract-after.ts
+/**
+* @file What the API offers after runs: the feedback loop's routes
+*   (contract-feedback.ts) and the follow-ups' (contract-follow-ups.ts), joined
+*   so the contract reads one part for both.
+*/
+const AFTER_API = {
+	...FEEDBACK_API,
+	...FOLLOW_UPS_API
+};
+// ../server/src/contract-builder.ts
+/** A new workflow's name, as its file and its `name:` take it. */
+const NewWorkflowSchema = z.strictObject({ name: z.string().min(1) });
+/** The server checks each edit; this file imports only types of the schema. */
+const WorkflowEditsSchema = z.strictObject({ edits: z.array(z.custom()).min(1) });
+/** Earlier text, and the file it was based on, to ask before replacing it. */
+const DraftTextSchema = z.strictObject({
+	text: z.string(),
+	baseHash: z.string().nullable()
+});
+const SaveWorkflowSchema = z.strictObject({ 
+/** Write over a file that changed since this draft began. */
+force: z.boolean().optional() });
+const BUILDER_API = {
+	builderSchema: {
+		method: "GET",
+		path: "/api/workflow-schema"
+	},
+	builderCatalog: {
+		method: "GET",
+		path: "/api/projects/:id/catalog"
+	},
+	builderDrafts: {
+		method: "GET",
+		path: "/api/projects/:id/builder"
+	},
+	builderView: {
+		method: "GET",
+		path: "/api/projects/:id/builder/:name"
+	},
+	builderCreate: {
+		method: "POST",
+		path: "/api/projects/:id/builder",
+		body: NewWorkflowSchema
+	},
+	builderEdit: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/edits",
+		body: WorkflowEditsSchema
+	},
+	builderRestore: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/text",
+		body: DraftTextSchema
+	},
+	builderDiscard: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/discard"
+	},
+	builderSave: {
+		method: "POST",
+		path: "/api/projects/:id/builder/:name/save",
+		body: SaveWorkflowSchema
+	}
+};
+// ../server/src/contract-context.ts
+const CONTEXT_API = {
+	runContext: {
+		method: "GET",
+		path: "/api/runs/:id/nodes/:node/context"
+	},
+	builderContext: {
+		method: "GET",
+		path: "/api/projects/:id/builder/:name/nodes/:node/context"
+	}
+};
 // ../server/src/contract-links.ts
 /**
 * @file The routes that link two nodes of live runs (RFC-003): list, link and
@@ -320,7 +383,7 @@ const API = {
 	},
 	...BUILDER_API,
 	...CONTEXT_API,
-	...FEEDBACK_API,
+	...AFTER_API,
 	...WORKTREES_API,
 	...UPDATE_API,
 	projects: {
@@ -2021,7 +2084,7 @@ const applyRoute = async (context, item, driver) => {
 *   workflows would go and how big that file is, the project a fix would be
 *   proposed in, and the run proposing one now, if any.
 */
-const detailOf = (store, item) => {
+const detailOf$1 = (store, item) => {
 	const registered = store.projects();
 	const fixRun = openFixRun(store, item);
 	const actions = feedbackActions(item, fixRun);
@@ -2124,7 +2187,7 @@ const feedbackRoutes = (context) => {
 		feedbackItem: ({ params }) => {
 			const found = itemOf(store, params.id);
 			if (!found.ok) return found.refusal;
-			return ok(detailOf(store, found.item));
+			return ok(detailOf$1(store, found.item));
 		},
 		feedbackStatus: ({ params, body }) => {
 			const found = itemOf(store, params.id);
@@ -2173,6 +2236,172 @@ const feedbackRoutes = (context) => {
 		}
 	};
 };
+// ../server/src/follow-up-routes.ts
+/**
+* @file The follow-ups' routes (specs/follow-ups.md), through the same core
+*   functions as `ork follow-ups`: a project's list (after the due check, which
+*   reads pull requests through the person's own `gh` and only reports a `gh`
+*   that fails), one follow-up with what to copy and what can be done to it,
+*   done, drop, reopen and due, and posting a drafted GitHub comment only with
+*   the person's confirmation of the draft they saw (its digest). Ork never
+*   runs a task's commands.
+*/
+const OPEN = ["due", "waiting"];
+/** Stands for what a person saw of a draft: its recipient and text. */
+const digestOf$1 = (f) => f.draft === void 0 ? void 0 : createHash("sha256").update(JSON.stringify([f.draft.to, f.draft.text])).digest("hex");
+/** The place a project's rule keeps follow-ups in. */
+const ruleOf = (project) => (loadProject(project.root, placeFiles(project).rules).project?.followUps ?? DEFAULT_FOLLOW_UPS_RULE).store;
+/** Why a follow-up isn't where the project's rule says, when it isn't. */
+const fallbackOf = (placed, rule) => {
+	if (placed === rule) return void 0;
+	return rule === "github" ? "GitHub couldn't be used when it was added (gh not signed in, or the issue failed), so Ork's store keeps it." : `It couldn't be written to ${rule} when it was added, so Ork's store keeps it.`;
+};
+const deliveryOf = (store, f) => {
+	if (!f.for.startsWith("project:")) return void 0;
+	const name = f.for.slice(8).trim();
+	const target = store.projects().find((p) => p.id === name);
+	if (target === void 0) return {
+		project: name,
+		registered: false
+	};
+	const live = liveSessionOf(store, target.root);
+	return {
+		project: name,
+		registered: true,
+		root: target.root,
+		keptIn: ruleOf(target),
+		...live === void 0 ? {} : { live }
+	};
+};
+/** `f`, what can be done to it, where it is kept, and what to copy from it. */
+const detailOf = (context, project, f) => {
+	const rule = ruleOf(project);
+	const fallback = fallbackOf(f.place, rule);
+	const cause = dueCause(f);
+	const delivery = deliveryOf(context.store, f);
+	const digest = digestOf$1(f);
+	return {
+		followUp: f,
+		actions: followUpActions(f),
+		...cause === void 0 ? {} : { cause },
+		keptIn: {
+			place: f.place,
+			rule,
+			...f.url === void 0 ? {} : { url: f.url },
+			...fallback === void 0 ? {} : { fallback }
+		},
+		...delivery === void 0 ? {} : { delivery },
+		...digest === void 0 ? {} : { draftDigest: digest },
+		copy: {
+			text: f.draft?.text ?? "",
+			commands: (f.steps ?? []).flatMap((step) => step.command === void 0 ? [] : [step.command])
+		}
+	};
+};
+const toItem = (f) => ({
+	id: f.id,
+	project: f.project,
+	title: f.title,
+	for: f.for,
+	kind: f.kind,
+	...f.note === void 0 ? {} : { note: f.note }
+});
+/** The due follow-ups of `roots`, most recently changed first. */
+const dueOf = (store, roots) => {
+	const due = roots.flatMap((root) => store.followUps(root)).filter((f) => f.status === "due").toSorted((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	return {
+		count: due.length,
+		items: due.slice(0, 20).map((f) => toItem(f))
+	};
+};
+const found = (context, params) => {
+	const project = projectOf(context, params.id);
+	if (project === void 0) return {
+		ok: false,
+		refusal: fail(404, `No registered project \`${params.id}\`.`)
+	};
+	if (params.followUp === void 0) return {
+		ok: true,
+		project
+	};
+	const one = findFollowUp(context.store, project.root, params.followUp);
+	if (!one.ok) {
+		const status = one.error.startsWith("No follow-up") ? 404 : 400;
+		return {
+			ok: false,
+			refusal: fail(status, one.error)
+		};
+	}
+	return {
+		ok: true,
+		project,
+		followUp: one.followUp
+	};
+};
+const followUpRoutes = (context) => {
+	const { store } = context;
+	const gh = context.gh ?? runGh;
+	return {
+		followUps: async ({ params, query }) => {
+			const one = found(context, params);
+			if (!one.ok) return one.refusal;
+			const { root } = one.project;
+			const errors = await checkFollowUpsDue({
+				rows: store,
+				project: root,
+				gh
+			}).then((checked) => checked.errors).catch((error) => [error instanceof Error ? error.message : String(error)]);
+			const all = store.followUps(root);
+			const status = query.status ?? "open";
+			const shown = all.filter((f) => {
+				if (query.for !== void 0 && f.for !== query.for) return false;
+				if (status === "all") return true;
+				if (status === "open") return OPEN.some((s) => s === f.status);
+				return f.status === status;
+			});
+			return ok({
+				project: root,
+				followUps: shown,
+				due: all.filter((f) => f.status === "due").length,
+				checker: {
+					available: errors.length === 0,
+					errors
+				}
+			});
+		},
+		followUp: ({ params }) => {
+			const one = found(context, params);
+			if (!one.ok) return one.refusal;
+			return one.followUp === void 0 ? fail(404, "No such follow-up.") : ok(detailOf(context, one.project, one.followUp));
+		},
+		followUpChange: ({ params, body }) => {
+			const one = found(context, params);
+			if (!one.ok) return one.refusal;
+			if (one.followUp === void 0) return fail(404, "No such follow-up.");
+			const changed = changeFollowUp(store, one.followUp, body.action);
+			return changed.ok ? ok(detailOf(context, one.project, changed.followUp)) : fail(409, changed.error);
+		},
+		followUpPost: async ({ params, body }) => {
+			const one = found(context, params);
+			if (!one.ok) return one.refusal;
+			const { followUp } = one;
+			if (followUp === void 0) return fail(404, "No such follow-up.");
+			const check = followUpActions(followUp).post;
+			if (!check.ok) return fail(409, check.error);
+			if (digestOf$1(followUp) !== body.digest) return fail(409, "The draft is no longer the one you confirmed; open the follow-up again.");
+			const posted = await postFollowUpMessage(followUp, {
+				rows: store,
+				gh,
+				confirmed: body.confirm,
+				home: context.home ?? homedir()
+			});
+			return posted.ok ? ok({
+				...posted.url === void 0 ? {} : { url: posted.url },
+				followUp: detailOf(context, one.project, posted.followUp)
+			}) : fail(409, posted.error);
+		}
+	};
+};
 const ANSI = /\u001B\[[0-?]*[ -/]*[@-~]|\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)|\u001B[@-Z\\-_]/gu;
 /** A line as a terminal would end up showing it. */
 const plainLine = (raw) => (raw.replaceAll(ANSI, "").split("\r").findLast((part) => part !== "") ?? "").replaceAll(/\s+$/gu, "");
@@ -2727,6 +2956,7 @@ const apiRoutes = (context, port) => ({
 	...builderRoutes(context),
 	...contextRoutes(context),
 	...feedbackRoutes(context),
+	...followUpRoutes(context),
 	...worktreesRoutes(context),
 	...updateRoutes(context, port)
 });
@@ -2885,7 +3115,11 @@ const overviewStream = (context, res, url, shutdown) => {
 	const last = {
 		runs: "",
 		decisions: "",
-		version: ""
+		version: "",
+		followUps: JSON.stringify({
+			count: 0,
+			items: []
+		})
 	};
 	const tick = () => {
 		const filter = root === void 0 ? {} : { project: root };
@@ -2900,7 +3134,8 @@ const overviewStream = (context, res, url, shutdown) => {
 		for (const [name, value] of [
 			["runs", runs],
 			["decisions", decisions],
-			["version", context.updates.info()]
+			["version", context.updates.info()],
+			["followUps", dueOf(context.store, root === void 0 ? context.store.projects().map((p) => p.root) : [root])]
 		]) {
 			const text = JSON.stringify(value);
 			if (text === last[name]) continue;
@@ -3058,6 +3293,8 @@ const runningServer = (file) => {
 */
 /** The port `ork ui` serves on unless told otherwise. */
 const DEFAULT_PORT = 4417;
+/** The overview stream sends the due follow-ups itself; nothing more here. */
+const noticed = () => {};
 const listen = (server, port) => new Promise((resolve, reject) => {
 	server.once("error", (error) => {
 		reject(error.code === "EADDRINUSE" ? /* @__PURE__ */ new Error(`Port ${String(port)} is in use; start Ork's UI on another with \`--port <n>\`.`) : error);
@@ -3119,6 +3356,15 @@ const startServer = async (options) => {
 		token,
 		startedAt
 	});
+	const stopChecks = startFollowUpChecks({
+		rows: store,
+		gh: options.gh ?? runGh,
+		projects: () => store.projects().map((project) => project.root),
+		onDue: noticed,
+		onError: (error) => {
+			log(`ork ui: follow-ups: ${error}`);
+		}
+	});
 	let closed;
 	return {
 		port,
@@ -3131,6 +3377,7 @@ const startServer = async (options) => {
 		close: () => {
 			closed ??= new Promise((resolve) => {
 				shutdown.abort();
+				stopChecks();
 				updates.close();
 				server.close(() => {
 					store.close();

package/dist/{src-C7z_6fhn.mjs → src-DcrhgipG.mjs}

@@ -1,12 +1,13 @@
-import { $t as countedTokens, Cn as MCP_FILE, Dn as endOf, Ft as reportSchemaFor, Gn as parseTemplate, Gr as isToolNode, Ht as heldTimeout, Kn as renderTemplate, Lr as markValue, Mr as beforeOf, Nr as programsRunBy, Nt as planNodeSession, On as outcomeEnd, Qr as integrationFor, Tn as serversIn, Wn as evaluate, Wr as isClaudeNode, Xr as INTEGRATIONS, Yr as timeoutMs, Zr as TOOL_PREFIX, an as stoppedEnd, en as runScope, gn as sessionDriver, ii as AGENT_DRIVERS, in as failedWith, jn as endFor, kn as END_DETAIL_LIMIT, kt as planReason, ln as lowerChild, mn as envReadsOf, nt as sessionRefusals, on as declaredProblem, rn as endedWith, sn as slotClock, tn as calledWorkflows, un as startAt, vn as declaredOutputOf, wn as mcpNotText } from "./src-tsuZRu0H.mjs";
-import { t as runOnce } from "./run-D8divGCs.mjs";
+import { $t as sessionDriver, Bn as outcomeEnd, Bt as stoppedEnd, Dt as reportSchemaFor, Ft as runScope, Gr as beforeOf, Ht as slotClock, It as calledWorkflows, Kr as programsRunBy, Kt as startAt, Nn as countedTokens, Pt as heldTimeout, Rt as endedWith, Tt as planNodeSession, Un as endFor, Vn as END_DETAIL_LIMIT, Vt as declaredProblem, Wt as lowerChild, Xr as markValue, Xt as envReadsOf, _i as AGENT_DRIVERS, ar as renderTemplate, ci as timeoutMs, di as integrationFor, ii as isToolNode, in as serversIn, ir as parseTemplate, li as INTEGRATIONS, nn as MCP_FILE, nt as sessionRefusals, ri as isClaudeNode, rn as mcpNotText, rr as evaluate, tn as declaredOutputOf, ui as TOOL_PREFIX, xt as planReason, zn as endOf, zt as failedWith } from "./src-Dr_fTSu-.mjs";
+import { t as runOnce } from "./run-CiPsW9Kf.mjs";
+import { n as holdGuard, r as orphanGuard, t as KILL_AFTER_MS } from "./orphan-guard-BFKg8VSd.mjs";
 import path from "node:path";
 import { accessSync, constants, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { Readable } from "node:stream";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { Readable } from "node:stream";
 // ../nodes/src/call.ts
 /**
 * @file The `workflow.call` node type (RFC-004): renders what the node asks for
@@ -1816,6 +1817,7 @@ const claudeExecutor = (options) => async (context) => {
 	if (context.mailbox !== void 0) ports.mailbox = context.mailbox;
 	if (context.claims !== void 0) ports.claims = context.claims;
 	if (context.feedback !== void 0) ports.feedback = context.feedback;
+	if (context.followUps !== void 0) ports.followUps = context.followUps;
 	const whole = context.round > 1 ? wholeInput(context.input) : void 0;
 	if (whole !== void 0) ports.input = whole;
 	const watch = limitWatch(context);
@@ -2143,20 +2145,23 @@ const mcpCallExecutor = (options = {}) => async (context) => {
 *   whatever it started: SIGTERM, then SIGKILL for what ignores that. A stop or
 *   a timeout therefore leaves nothing running, and an escaped process that
 *   keeps the output pipes open cannot hold the node. Off Windows it runs under
-*   `sh`, whose `times` says the CPU the program and its children used, and at
-*   the project's priority: `low` starts it below Ork's own (nice, and on macOS
+*   `sh`, whose `times` says the CPU the program and its children used, beside
+*   the orphan guard, which ends the group when `ork` dies, and at the
+*   project's priority: `low` starts it below Ork's own (nice, and on macOS
 *   utility QoS).
 */
-/** How long a program may take to end after SIGTERM. */
-const KILL_AFTER_MS = 2e3;
 /** How long to wait for the pipes to close after SIGKILL. */
 const CLOSE_AFTER_MS = 500;
+/** The fd of the orphan guard's pipe from `ork`. */
+const WATCH_FD = 4;
 /**
-* Runs `$0 "$@"`, then writes the shell's `times` to fd 3: its children's user
-* and system time, the program's whole tree that it waited for. A program that
+* Runs `$0 "$@"` beside the orphan guard, which ends the group if `ork` dies,
+* and stops the guard once the program ends, so its leftovers live on as
+* before. Then writes the shell's `times` to fd 3: its children's user and
+* system time, the program's whole tree that it waited for. A program that
 * isn't there says so on fd 3, as spawn's ENOENT would.
 */
-const TIMED = String.raw`command -v "$0" >/dev/null 2>&1 || { echo ork-missing >&3; exit 127; }; "$0" "$@" 3>&-; s=$?; times >&3; exit $s`;
+const TIMED = String.raw`command -v "$0" >/dev/null 2>&1 || { echo ork-missing >&3; exit 127; }; ${orphanGuard(WATCH_FD)}w=$!; "$0" "$@" 3>&- ${String(WATCH_FD)}<&-; s=$?; kill -s KILL $w 2>/dev/null; times >&3; exit $s`;
 const MISSING = "ork-missing";
 /** The children's line of `times` (`0m1.250s 0m0.300s`), in milliseconds. */
 const cpuOfTimes = (text) => {
@@ -2197,10 +2202,12 @@ const spawnTool = (program, args, { cwd, signal, env, priority }) => {
 				"ignore",
 				"pipe",
 				"pipe",
+				"pipe",
 				"pipe"
 			]
 		});
 		lowerChild(priority, child.pid);
+		holdGuard(child.stdio[WATCH_FD]);
 		const fd3 = child.stdio[3];
 		if (fd3 instanceof Readable) fd3.setEncoding("utf8").on("data", (chunk) => {
 			times.push(chunk);