@krapht/ork 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/src-B9v0lDc6.mjs

@@ -1,1204 +0,0 @@
-import { Bt as FEEDBACK_TARGETS, Rt as FEEDBACK_KINDS, pt as parseReport, zt as FEEDBACK_SEVERITIES } from "./src-hrj2h0IZ.mjs";
-import { z } from "zod";
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { createInterface } from "node:readline";
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
-// ../runtime-claude/src/cache-env.ts
-/** Claude Code's switch for the one-hour prompt cache. */
-const PROMPT_CACHE_1H = "ENABLE_PROMPT_CACHING_1H";
-/** The variables a session adds to its driver's environment. */
-const cacheEnv = (spec) => spec.promptCache === "1h" ? { [PROMPT_CACHE_1H]: "1" } : {};
-// ../runtime-claude/src/clean.ts
-/** Claude Code's switch that turns its auto-memory off. */
-const NO_AUTO_MEMORY = "CLAUDE_CODE_DISABLE_AUTO_MEMORY";
-/**
-* The CLI flag that moves the per-machine sections (working directory, memory
-* path, git status) out of the system prompt; the SDK's
-* `excludeDynamicSections`.
-*/
-const EXCLUDE_DYNAMIC_SECTIONS = "--exclude-dynamic-system-prompt-sections";
-/** Whether the session loads no MCP server but Ork's. */
-const strictMcpOf = (spec) => spec.tools.strictMcp === true || spec.machineClaude !== true;
-/** The variables that keep the machine's auto-memory out of a session. */
-const memoryEnv = (spec) => spec.machineClaude === true ? {} : { [NO_AUTO_MEMORY]: "1" };
-/** Everything a session adds to its driver's environment. */
-const driverEnv = (spec) => ({
-	...cacheEnv(spec),
-	...memoryEnv(spec)
-});
-// ../runtime-claude/src/normalize.ts
-/**
-* @file Both drivers emit the same message JSON (the Agent SDK's messages are
-*   the CLI's `stream-json` lines), so one normalizer serves both.
-*/
-const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const get = (value, key) => isObject(value) ? value[key] : void 0;
-const num = (value) => typeof value === "number" ? value : 0;
-const str = (value) => typeof value === "string" ? value : "";
-const blocks = (message) => {
-	const content = get(get(message, "message"), "content");
-	return Array.isArray(content) ? content.filter((item) => isObject(item)) : [];
-};
-const usageOf = (result) => {
-	const usage = get(result, "usage");
-	return {
-		costUsd: num(result["total_cost_usd"]),
-		inputTokens: num(get(usage, "input_tokens")),
-		outputTokens: num(get(usage, "output_tokens")),
-		cacheReadTokens: num(get(usage, "cache_read_input_tokens")),
-		cacheWriteTokens: num(get(usage, "cache_creation_input_tokens")),
-		turns: num(result["num_turns"]),
-		durationMs: num(result["duration_ms"])
-	};
-};
-/** The outcome a `result` message describes. */
-const outcomeOf = (result) => {
-	const errors = result["errors"];
-	return {
-		subtype: str(result["subtype"]) || "unknown",
-		sessionId: str(result["session_id"]),
-		report: parseReport(result["structured_output"]),
-		text: str(result["result"]),
-		usage: usageOf(result),
-		errors: Array.isArray(errors) ? errors.filter((e) => typeof e === "string") : []
-	};
-};
-/** The year 2286: a reset beyond this is not in seconds. */
-const MAX_RESET_SECONDS = 1e10;
-/**
-* What a subscription's limit said (RFC-007). Only the fields Claude Code
-* documents are read, so `utilization`, often absent, plays no part.
-*/
-const planLimitOf = (info) => {
-	const status = get(info, "status");
-	if (status !== "allowed" && status !== "allowed_warning" && status !== "rejected") return [];
-	const window = get(info, "rateLimitType");
-	const resets = get(info, "resetsAt");
-	const overage = get(info, "overageStatus");
-	return [{
-		type: "plan.limit",
-		status: status === "rejected" && !(status === "rejected" && overage !== "allowed" && overage !== "allowed_warning") ? "allowed_warning" : status,
-		window: typeof window === "string" ? window : "plan",
-		...typeof resets === "number" && resets > 0 && resets < MAX_RESET_SECONDS ? { resetsAt: (/* @__PURE__ */ new Date(resets * 1e3)).toISOString() } : {}
-	}];
-};
-/** Maps one driver message to zero or more normalized events. */
-const normalize = (message) => {
-	if (!isObject(message)) return [];
-	switch (message["type"]) {
-		case "system": {
-			if (message["subtype"] !== "init") return [];
-			const started = {
-				type: "session.started",
-				sessionId: str(message["session_id"]),
-				model: str(message["model"])
-			};
-			if (str(message["cwd"]) !== "") started.cwd = str(message["cwd"]);
-			return [started];
-		}
-		case "assistant": return blocks(message).flatMap((block) => {
-			if (block["type"] === "text" && str(block["text"]).trim() !== "") return [{
-				type: "assistant.text",
-				text: str(block["text"])
-			}];
-			if (block["type"] === "tool_use") {
-				const input = block["input"];
-				return [{
-					type: "tool.called",
-					id: str(block["id"]),
-					name: str(block["name"]),
-					input: isObject(input) ? input : {}
-				}];
-			}
-			return [];
-		});
-		case "user": return blocks(message).filter((block) => block["type"] === "tool_result").map((block) => ({
-			type: "tool.result",
-			id: str(block["tool_use_id"]),
-			isError: block["is_error"] === true
-		}));
-		case "rate_limit_event": return planLimitOf(message["rate_limit_info"]);
-		case "result": return [{
-			type: "session.finished",
-			outcome: outcomeOf(message)
-		}];
-		default: return [];
-	}
-};
-/** Marks a session's start with the driver that runs it. */
-const withDriver = (event, driver) => event.type === "session.started" ? {
-	...event,
-	driver
-} : event;
-/** A finished event for a session the driver could not run. */
-const driverFailure = (message) => ({
-	type: "session.finished",
-	outcome: {
-		subtype: "error_driver",
-		sessionId: "",
-		report: null,
-		text: "",
-		usage: {
-			costUsd: 0,
-			inputTokens: 0,
-			outputTokens: 0,
-			cacheReadTokens: 0,
-			cacheWriteTokens: 0,
-			turns: 0,
-			durationMs: 0
-		},
-		errors: [message]
-	}
-});
-/** How long a hook holds a call before it defers it instead. */
-const HOLD_WINDOW_MS = 54e4;
-/**
-* Waits at a tool call while `hold` is held: "go" once it is released within
-* the window (or at once when it is not held), "defer" after the window.
-*/
-const holdAtTool = async (hold, signal, windowMs = HOLD_WINDOW_MS) => {
-	if (!hold.held()) return "go";
-	const window = new AbortController();
-	const timer = setTimeout(() => {
-		window.abort();
-	}, windowMs);
-	try {
-		await hold.wait("tool", AbortSignal.any([signal, window.signal]));
-	} finally {
-		clearTimeout(timer);
-	}
-	return hold.held() && !signal.aborted ? "defer" : "go";
-};
-/** The hook's answer: nothing to say for "go", the deferral otherwise. */
-const hookOutput = (answer) => answer === "go" ? {} : { hookSpecificOutput: {
-	hookEventName: "PreToolUse",
-	permissionDecision: "defer",
-	permissionDecisionReason: "Ork paused this node; it goes on from this call when it continues."
-} };
-/** Whether a stream-json message is the result of a deferred tool call. */
-const isDeferredResult = (message) => typeof message === "object" && message !== null && "type" in message && message.type === "result" && "stop_reason" in message && message.stop_reason === "tool_deferred";
-/**
-* Two legs of one session, as one: the tokens of both, and the later leg's
-* cost, which is already the session's total (ADR-046).
-*/
-const addUsage = (a, b) => ({
-	costUsd: Math.max(a.costUsd, b.costUsd),
-	inputTokens: a.inputTokens + b.inputTokens,
-	outputTokens: a.outputTokens + b.outputTokens,
-	cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
-	cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
-	turns: a.turns + b.turns,
-	durationMs: a.durationMs + b.durationMs
-});
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/**
-* The node's `--settings` with Ork's `PreToolUse` HTTP hook added: before every
-* tool call, pre-approved ones included, the session asks whether its node may
-* go on.
-*/
-const withHoldHook = (settings, holdUrl, token) => {
-	const hooks = isRecord(settings?.["hooks"]) ? settings["hooks"] : {};
-	const listed = hooks["PreToolUse"];
-	const before = Array.isArray(listed) ? [...listed] : [];
-	const hook = {
-		type: "http",
-		url: holdUrl,
-		headers: { Authorization: `Bearer ${token}` },
-		timeout: 600
-	};
-	return {
-		...settings,
-		hooks: {
-			...hooks,
-			PreToolUse: [...before, {
-				matcher: "*",
-				hooks: [hook]
-			}]
-		}
-	};
-};
-/**
-* What one stream-json message of a leg yields, and how the leg ends if it
-* does: a result is the session's end, unless the hold hook deferred a call in
-* this leg; a resumed leg's start is not news, and its end carries what the
-* legs before it spent.
-*/
-const legStep = (message, input) => {
-	const deferred = input.deferred && isDeferredResult(message);
-	const events = [];
-	let ended;
-	for (const event of normalize(message)) {
-		if (event.type === "session.started" && input.carried !== void 0) continue;
-		if (event.type !== "session.finished") events.push(withDriver(event, input.driver));
-		else if (deferred) ended = {
-			kind: "deferred",
-			sessionId: event.outcome.sessionId,
-			usage: event.outcome.usage,
-			last: withDriver(event, input.driver)
-		};
-		else {
-			const usage = input.carried === void 0 ? event.outcome.usage : addUsage(input.carried, event.outcome.usage);
-			events.push(withDriver({
-				...event,
-				outcome: {
-					...event.outcome,
-					usage
-				}
-			}, input.driver));
-			ended = { kind: "finished" };
-		}
-	}
-	return ended === void 0 ? { events } : {
-		events,
-		ended
-	};
-};
-// ../runtime-claude/src/cli-leg.ts
-/**
-* @file One `claude -p` process of a CLI-driven session: it writes the queued
-*   stream-json lines, yields the normalized events, and says how it ended. A
-*   session is one leg, or several when a paused node's tool call was deferred
-*   and the session resumed (ADR-041); a resumed leg carries what the legs
-*   before it spent, and its start is not news.
-*/
-const STDERR_LINES = 20;
-const parseLine = (line) => {
-	try {
-		return JSON.parse(line);
-	} catch {
-		return;
-	}
-};
-/** Runs one `claude` process, yielding its events; returns how it ended. */
-const runLeg = async function* (input) {
-	const child = spawn(input.bin, input.args, {
-		cwd: input.cwd,
-		env: { ...input.env },
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		]
-	});
-	const exited = new Promise((resolve) => {
-		child.on("close", (code) => {
-			resolve(code);
-		});
-	});
-	const spawnError = new Promise((resolve) => {
-		child.on("error", resolve);
-	});
-	const stderr = [];
-	child.stderr.setEncoding("utf8");
-	child.stderr.on("data", (chunk) => {
-		stderr.push(...chunk.split("\n").filter((l) => l.trim() !== ""));
-		stderr.splice(0, Math.max(0, stderr.length - STDERR_LINES));
-	});
-	const write = (line) => {
-		if (child.stdin.writable) child.stdin.write(line);
-	};
-	input.attach({
-		write,
-		stop: () => {
-			child.kill("SIGINT");
-		}
-	});
-	for (const line of input.pending.splice(0)) write(line);
-	let outcome;
-	try {
-		for await (const line of createInterface({ input: child.stdout })) {
-			const { events, ended } = legStep(parseLine(line), {
-				carried: input.carried,
-				deferred: input.deferred(),
-				driver: "cli"
-			});
-			yield* events;
-			if (ended !== void 0) {
-				child.stdin.end();
-				outcome = ended;
-			}
-		}
-		const code = await Promise.race([exited, spawnError.then((error) => error)]);
-		return outcome ?? {
-			kind: "failed",
-			reason: code instanceof Error ? `could not start ${input.bin}: ${code.message}` : stderr.at(-1) ?? `claude exited with code ${String(code)}`
-		};
-	} finally {
-		input.attach();
-		if (child.exitCode === null) child.kill();
-	}
-};
-/** The name Claude Code gives an Ork tool: `mcp__ork__<name>`. */
-const toolId = (name) => `mcp__ork__${name}`;
-const text = (value) => ({ content: [{
-	type: "text",
-	text: value
-}] });
-const defineTool = (definition) => {
-	const schema = z.object(definition.shape);
-	return {
-		name: definition.name,
-		bind: (context) => definition.available?.(context) ?? true ? {
-			name: definition.name,
-			description: definition.description,
-			shape: definition.shape,
-			schema,
-			preapproved: definition.preapproved ?? true,
-			call: (args) => definition.run(context, schema.parse(args))
-		} : null
-	};
-};
-// ../runtime-claude/src/mcp-http.ts
-/**
-* @file A minimal MCP server over the streamable HTTP transport, for the
-*   `claude` CLI driver. It answers with plain JSON (no SSE stream), which the
-*   transport allows, and implements only what Ork needs: `initialize`, `ping`,
-*   `tools/list` and `tools/call`. Beside it, `/hold` answers the session's
-*   `PreToolUse` HTTP hook, which waits while the node is paused (ADR-041).
-*/
-const PATH = "/mcp";
-const HOLD_PATH = "/hold";
-const MAX_BODY = 1048576;
-const MCP_PROTOCOL_FALLBACK = "2025-06-18";
-const JsonRpcSchema = z.object({
-	jsonrpc: z.literal("2.0"),
-	id: z.union([z.string(), z.number()]).optional(),
-	method: z.string(),
-	params: z.record(z.string(), z.unknown()).optional()
-});
-/** Handles one JSON-RPC request; `null` for a notification (no reply). */
-const handleRpc = async (tools, message) => {
-	const parsed = JsonRpcSchema.safeParse(message);
-	if (!parsed.success) return { error: {
-		code: -32600,
-		message: "invalid request"
-	} };
-	const { id, method, params } = parsed.data;
-	if (id === void 0) return null;
-	switch (method) {
-		case "initialize": {
-			const requested = params?.["protocolVersion"];
-			return { result: {
-				protocolVersion: typeof requested === "string" ? requested : MCP_PROTOCOL_FALLBACK,
-				capabilities: { tools: {} },
-				serverInfo: {
-					name: "ork",
-					version: "0.0.0"
-				}
-			} };
-		}
-		case "ping": return { result: {} };
-		case "tools/list": return { result: { tools: tools.map((t) => ({
-			name: t.name,
-			description: t.description,
-			inputSchema: z.toJSONSchema(t.schema)
-		})) } };
-		case "tools/call": {
-			const tool = tools.find((t) => t.name === params?.["name"]);
-			if (tool === void 0) return { error: {
-				code: -32602,
-				message: "unknown tool"
-			} };
-			try {
-				return { result: await tool.call(params?.["arguments"] ?? {}) };
-			} catch (error) {
-				return { result: {
-					content: [{
-						type: "text",
-						text: error instanceof Error ? error.message : "tool failed"
-					}],
-					isError: true
-				} };
-			}
-		}
-		default: return { error: {
-			code: -32601,
-			message: `unknown method ${method}`
-		} };
-	}
-};
-const authorized = (req, token) => {
-	const expected = Buffer.from(`Bearer ${token}`);
-	const given = Buffer.from(req.headers.authorization ?? "");
-	return given.length === expected.length && timingSafeEqual(given, expected);
-};
-const readBody = async (req) => {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of req) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-		size += buffer.length;
-		if (size > MAX_BODY) return null;
-		chunks.push(buffer);
-	}
-	return Buffer.concat(chunks).toString("utf8");
-};
-const respond = (res, status, body) => {
-	if (body === void 0) {
-		res.writeHead(status).end();
-		return;
-	}
-	res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify(body));
-};
-/** The hook's POST: waits for `hold`; a closed connection gives up. */
-const serveHold = async (req, res, hold) => {
-	if (req.method !== "POST") {
-		respond(res, 405);
-		return;
-	}
-	if (await readBody(req) === null) {
-		respond(res, 413);
-		return;
-	}
-	const gone = new AbortController();
-	res.once("close", () => {
-		gone.abort();
-	});
-	const output = await hold(gone.signal);
-	if (!gone.signal.aborted) respond(res, 200, output);
-};
-const serve = async (req, res, tools, token, hold) => {
-	if (!authorized(req, token)) {
-		respond(res, 401);
-		return;
-	}
-	if (req.url === HOLD_PATH && hold !== void 0) {
-		await serveHold(req, res, hold);
-		return;
-	}
-	if (req.url !== PATH) {
-		respond(res, 404);
-		return;
-	}
-	if (req.method !== "POST") {
-		respond(res, 405);
-		return;
-	}
-	const body = await readBody(req);
-	if (body === null) {
-		respond(res, 413);
-		return;
-	}
-	let message;
-	try {
-		message = JSON.parse(body);
-	} catch {
-		respond(res, 400);
-		return;
-	}
-	const id = message !== null && typeof message === "object" && "id" in message ? message.id : null;
-	const reply = await handleRpc(tools, message);
-	if (reply === null) {
-		respond(res, 202);
-		return;
-	}
-	respond(res, 200, {
-		jsonrpc: "2.0",
-		id,
-		...reply
-	});
-};
-/**
-* Serves Ork's tools to one `claude` CLI session: on 127.0.0.1 only, on a
-* random port, behind a per-session bearer token.
-*/
-const startOrkMcpHttp = async (tools, hold) => {
-	const token = randomBytes(24).toString("hex");
-	const http = createServer((req, res) => {
-		serve(req, res, tools, token, hold).catch(() => {
-			if (!res.headersSent) respond(res, 500);
-		});
-	});
-	await new Promise((resolve) => {
-		http.listen(0, "127.0.0.1", resolve);
-	});
-	const address = http.address();
-	const port = typeof address === "object" && address !== null ? address.port : 0;
-	return {
-		url: `http://127.0.0.1:${port}${PATH}`,
-		holdUrl: `http://127.0.0.1:${port}${HOLD_PATH}`,
-		token,
-		close: () => new Promise((resolve) => {
-			http.closeAllConnections();
-			http.close(() => {
-				resolve();
-			});
-		})
-	};
-};
-// ../runtime-claude/src/tools/ask-user.ts
-const askUserTool = defineTool({
-	name: "ask_user",
-	description: "Ask the user to decide something only they can decide. Give two to four options and the one you recommend. The run waits for the answer.",
-	shape: {
-		question: z.string().describe("One clear question."),
-		options: z.array(z.object({
-			id: z.string().describe("A short id, e.g. 'keep-api'."),
-			label: z.string().optional(),
-			description: z.string().optional().describe("What choosing it means.")
-		})).min(2).max(4),
-		recommended: z.string().optional().describe("The id you recommend."),
-		context: z.string().optional().describe("What the user needs to know to decide, in a few sentences.")
-	},
-	run: async ({ nodeId, ports }, args) => {
-		let note;
-		let owner;
-		const question = {
-			nodeId,
-			onNote: (given) => {
-				note = given;
-			},
-			onOwner: (given) => {
-				owner = given;
-			},
-			question: args.question,
-			options: args.options.map((o) => {
-				const choice = { id: o.id };
-				if (o.label !== void 0) choice.label = o.label;
-				if (o.description !== void 0) choice.description = o.description;
-				return choice;
-			})
-		};
-		if (args.recommended !== void 0) question.recommended = args.recommended;
-		if (args.context !== void 0) question.context = args.context;
-		const answer = await ports.human.ask(question);
-		const who = owner === void 0 ? "The user" : `Your owner, \`${owner}\`,`;
-		return text(note === void 0 ? `${who} chose: ${answer}` : `${who} chose: ${answer}\nThey said: ${note}`);
-	}
-});
-// ../runtime-claude/src/tools/claims.ts
-/**
-* @file `claim` and `release`: a session's side of the run's claims. A node
-*   claims a file, folder or other resource before changing it, so nodes
-*   running at the same time do not change the same thing; a refused claim says
-*   who holds it. Only sessions that may write while another does get them.
-*/
-const contended = ({ ports }) => ports.claims?.contended() === true;
-const resource = z.string().min(1).describe("A path from the project root (a folder covers everything in it), or a name for something else shared, e.g. 'db:migrations'.");
-const claimTool = defineTool({
-	name: "claim",
-	description: "Claim a file, folder or other shared resource before you change it, so other nodes running in this run leave it alone. If another node holds it (or something overlapping), you are told who; Ork tells you when it is released.",
-	shape: { resource },
-	available: contended,
-	run: ({ ports }, args) => {
-		const claimed = ports.claims?.claim(args.resource);
-		if (claimed === void 0) return Promise.resolve(text("No claims."));
-		if (!claimed.ok) return Promise.resolve(text(`Not claimed: ${claimed.error}.`));
-		return Promise.resolve(text(claimed.already ? `You already hold ${claimed.resource}.` : `Claimed ${claimed.resource}.`));
-	}
-});
-const releaseTool = defineTool({
-	name: "release",
-	description: "Release a claim you are done with, so other nodes can take it. Ork releases your remaining claims when you finish.",
-	shape: { resource },
-	available: contended,
-	run: ({ ports }, args) => {
-		const released = ports.claims?.release(args.resource);
-		if (released === void 0) return Promise.resolve(text("No claims."));
-		return Promise.resolve(text(released.ok ? `Released ${released.resource}.` : `Not released: ${released.error}.`));
-	}
-});
-// ../runtime-claude/src/tools/delegate.ts
-const BRIEF = z.string().min(1).describe("Self-contained: the goal, the files that matter, and what done looks like. The child does not see your conversation.");
-/** What the leader reads back: each report without the usage details. */
-const reportLine = (report) => {
-	const { usage, ...output } = report.output;
-	const cost = usage !== null && typeof usage === "object" && "costUsd" in usage ? usage.costUsd : void 0;
-	return {
-		child: report.child,
-		ok: report.ok,
-		...output,
-		...cost === void 0 ? {} : { costUsd: cost },
-		...report.ok || report.error === void 0 || report.error === output["summary"] ? {} : { error: report.error }
-	};
-};
-const delegationText = (delegation) => text(JSON.stringify({
-	reports: delegation.reports.map(reportLine),
-	...delegation.notes.length > 0 ? { notes: delegation.notes } : {}
-}));
-const delegateTool = defineTool({
-	name: "delegate",
-	description: "Hand tasks to nodes you own. Tasks in one call run in parallel; the call returns every child's report when all are done. Ork merges a passing child's branch into yours.",
-	shape: { tasks: z.array(z.object({
-		child: z.string().describe("The id of a node you own."),
-		brief: BRIEF
-	})).min(1) },
-	available: ({ ports }) => (ports.ownership?.children.length ?? 0) > 0,
-	run: async ({ ports }, args) => {
-		if (ports.ownership === void 0) return text("You own no nodes.");
-		return delegationText(await ports.ownership.delegate(args.tasks));
-	}
-});
-const spawnWorkerTool = defineTool({
-	name: "spawn_worker",
-	description: "Start new instances of a child worker for work that splits into independent parts. Each runs in its own worktree; the call returns their reports when all are done.",
-	shape: { tasks: z.array(z.object({
-		template: z.string().describe("The id of a child worker you own."),
-		brief: BRIEF
-	})).min(1) },
-	available: ({ ports }) => ports.ownership !== void 0 && ports.ownership.templates.length > 0 && ports.ownership.workersLeft() > 0,
-	run: async ({ ports }, args) => {
-		if (ports.ownership === void 0) return text("You own no workers.");
-		return delegationText(await ports.ownership.spawn(args.tasks));
-	}
-});
-// ../runtime-claude/src/tools/feedback.ts
-/**
-* @file `feedback`: a session's way to report what got in its way, kept on the
-*   user's machine (specs/feedback.md). Every session inside a run gets it; Ork
-*   caps reports per session and drops a run's duplicates.
-*/
-const feedbackTool = defineTool({
-	name: "feedback",
-	description: "Report something that materially got in the way of your task: a tool that failed or misled you, context or instructions that were missing or wrong, a skill that did not fit, or a flaw in the workflow. One line plus a short body; at most a few per session. Do not report routine work or your own mistakes.",
-	shape: {
-		kind: z.enum(FEEDBACK_KINDS),
-		target: z.enum(FEEDBACK_TARGETS).optional().describe("What it is about: ork (the harness and its tools), workflow (this workflow's briefs, models, budgets, loops), or project (AGENTS.md, CLAUDE.md, skills, docs). Default: from the kind."),
-		severity: z.enum(FEEDBACK_SEVERITIES).optional(),
-		title: z.string().min(1).describe("One line."),
-		body: z.string().optional().describe("A few sentences: what happened and what would have helped."),
-		evidence: z.array(z.string()).optional().describe("File paths, tool names; never pasted file contents.")
-	},
-	available: ({ ports }) => ports.feedback !== void 0,
-	run: ({ ports }, args) => {
-		const draft = {
-			kind: args.kind,
-			title: args.title
-		};
-		if (args.target !== void 0) draft.target = args.target;
-		if (args.severity !== void 0) draft.severity = args.severity;
-		if (args.body !== void 0) draft.body = args.body;
-		if (args.evidence !== void 0) draft.evidence = args.evidence;
-		const sent = ports.feedback?.report(draft);
-		if (sent === void 0) return Promise.resolve(text("No feedback here."));
-		return Promise.resolve(text(sent.ok ? "Recorded. Thank you; carry on with your task." : `Not recorded: ${sent.error}.`));
-	}
-});
-// ../runtime-claude/src/tools/messages.ts
-/**
-* @file `send_message`, `read_inbox` and `answer`: a session's side of the
-*   run's message bus. A message lands in the recipient's inbox and a live
-*   session gets a one-line notice; `answer` replies to a question Ork asked an
-*   owner about a node it owns. Only sessions inside a run get them.
-*/
-/**
-* Peers are mutual: a node no one may write to has no inbox to read, unless it
-* may be linked later, since a session's tools are set when it starts.
-*/
-const hasPeers = ({ ports }) => (ports.mailbox?.peers().length ?? 0) > 0 || ports.mailbox?.linkable() === true;
-/** A program or a rule may write to a node with no one to write to itself. */
-const hasInbox = (context) => hasPeers(context) || context.ports.mailbox?.hears() === true;
-const MAX_WAIT_SECONDS = 3600;
-const DEFAULT_WAIT_SECONDS = 300;
-const inboxText = (unread) => JSON.stringify({ messages: unread.map((m) => ({
-	from: m.from,
-	...m.via === void 0 ? {} : { via: m.via },
-	body: m.body
-})) });
-const sendMessageTool = defineTool({
-	name: "send_message",
-	description: "Send a short message to a node you can reach: your owner, a node you own, one you share a declared channel with, or a node of another run the user linked you to. It sees a notice and reads the message with read_inbox. Use it for what they need to know now; your report still goes to your owner at the end.",
-	shape: {
-		to: z.string().describe("The node's id, or <run>/<node> for a linked node."),
-		body: z.string().min(1).describe("Self-contained: the recipient does not see your work.")
-	},
-	available: hasPeers,
-	run: ({ ports }, args) => {
-		const sent = ports.mailbox?.send(args.to, args.body);
-		if (sent === void 0) return Promise.resolve(text("No message bus."));
-		if (!sent.ok) return Promise.resolve(text(`Not sent: ${sent.error}.`));
-		return Promise.resolve(text(sent.delivered === "now" ? `Sent to ${args.to}; it sees a notice at its next step.` : `Sent to ${args.to}; it is not running now and sees the message if it starts again.`));
-	}
-});
-const readInboxTool = defineTool({
-	name: "read_inbox",
-	description: "Read your unread messages from other nodes, oldest first. Ork tells you when one arrives.",
-	shape: {},
-	available: hasInbox,
-	run: ({ ports }) => {
-		const unread = ports.mailbox?.read() ?? [];
-		return Promise.resolve(text(unread.length === 0 ? "No unread messages." : inboxText(unread)));
-	}
-});
-const waitForMessagesTool = defineTool({
-	name: "wait_for_messages",
-	description: "Wait for a message from another node when you cannot go on without its reply, instead of ending your session. Returns what arrived, or says none did in time. You hold no session slot while you wait.",
-	shape: { timeoutSeconds: z.number().int().positive().max(MAX_WAIT_SECONDS).optional().describe(`How long to wait. Default: ${String(DEFAULT_WAIT_SECONDS)}.`) },
-	available: hasInbox,
-	run: async ({ ports }, args) => {
-		const seconds = args.timeoutSeconds ?? DEFAULT_WAIT_SECONDS;
-		await ports.mailbox?.wait(seconds * 1e3);
-		const unread = ports.mailbox?.read() ?? [];
-		return text(unread.length === 0 ? `No message yet, after waiting up to ${String(seconds)} seconds. Ork may have told you something; if not, wait again or go on.` : inboxText(unread));
-	}
-});
-const answerTool = defineTool({
-	name: "answer",
-	description: "Answer a question Ork asked you as the owner of a node, such as a loop of yours that ran out of rounds. The question's id and options are in Ork's message.",
-	shape: {
-		question: z.string().describe("The question's id, e.g. 'q1'."),
-		choice: z.string().describe("One of its options."),
-		note: z.string().optional().describe("Why, in a sentence or two; it is recorded with your answer.")
-	},
-	available: ({ ports }) => ports.mailbox !== void 0 && ports.ownership !== void 0,
-	run: ({ ports }, args) => {
-		const answered = ports.mailbox?.answer(args.question, args.choice, args.note);
-		if (answered === void 0) return Promise.resolve(text("No questions."));
-		return Promise.resolve(text(answered.ok ? `Answered ${args.question}: ${args.choice}.` : `Not answered: ${answered.error}.`));
-	}
-});
-// ../runtime-claude/src/tools/registry.ts
-/**
-* @file The registry of Ork's MCP tools. Both drivers serve what it binds for a
-*   session; a new tool is one file here and one line in `ORK_TOOLS`.
-*/
-const ORK_TOOLS = [
-	askUserTool,
-	defineTool({
-		name: "permission",
-		description: "Ork's permission prompt for the claude CLI.",
-		shape: {
-			tool_name: z.string(),
-			input: z.record(z.string(), z.unknown()),
-			tool_use_id: z.string().optional()
-		},
-		preapproved: false,
-		available: ({ driver }) => driver === "cli",
-		run: async ({ nodeId, ports }, args) => {
-			const decision = await ports.human.permit({
-				nodeId,
-				toolName: args.tool_name,
-				input: args.input
-			});
-			return text(JSON.stringify(decision.allow ? {
-				behavior: "allow",
-				updatedInput: args.input
-			} : {
-				behavior: "deny",
-				message: decision.message
-			}));
-		}
-	}),
-	delegateTool,
-	spawnWorkerTool,
-	sendMessageTool,
-	readInboxTool,
-	waitForMessagesTool,
-	answerTool,
-	claimTool,
-	releaseTool,
-	feedbackTool
-];
-/** The tools one session gets. */
-const orkTools = (context) => ORK_TOOLS.flatMap((tool) => tool.bind(context) ?? []);
-/** Their Claude Code names, for the session's allowed tools. */
-const preapprovedTools = (tools) => tools.filter((t) => t.preapproved).map((t) => toolId(t.name));
-// ../runtime-claude/src/cli.ts
-/**
-* Per-request timeout for Ork's MCP server, in ms. The CLI otherwise gives an
-* HTTP server's request 60 seconds and drops a call silent for 5 minutes, and
-* `delegate` waits for whole child sessions (the per-server `timeout` raises
-* both; `MCP_TOOL_TIMEOUT` still caps it).
-*/
-const ORK_TOOL_TIMEOUT_MS = 864e5;
-/** A later message goes in at the next step, even mid-turn. */
-const userLine = (text, later = false) => `${JSON.stringify({
-	type: "user",
-	message: {
-		role: "user",
-		content: text
-	},
-	parent_tool_use_id: null,
-	...later ? { priority: "next" } : {}
-})}\n`;
-/**
-* The `claude -p` arguments for a session spec. The brief goes on stdin;
-* `allowed` are the Ork tools that need no permission prompt.
-*/
-const buildCliArgs = (spec, mcp, allowed) => {
-	const mcpConfig = { mcpServers: { ["ork"]: {
-		type: "http",
-		url: mcp.url,
-		headers: { Authorization: `Bearer ${mcp.token}` },
-		timeout: ORK_TOOL_TIMEOUT_MS
-	} } };
-	const args = [
-		"-p",
-		"--input-format",
-		"stream-json",
-		"--output-format",
-		"stream-json",
-		"--verbose",
-		"--setting-sources",
-		spec.settingSources.join(","),
-		"--append-system-prompt",
-		spec.systemAppend,
-		EXCLUDE_DYNAMIC_SECTIONS,
-		"--permission-mode",
-		spec.permissionMode,
-		"--json-schema",
-		JSON.stringify(spec.reportSchema),
-		"--mcp-config",
-		JSON.stringify(mcpConfig),
-		"--permission-prompt-tool",
-		toolId("permission"),
-		"--allowedTools",
-		[...spec.tools.allow, ...allowed].join(",")
-	];
-	if (spec.tools.only !== void 0) args.push("--tools", spec.tools.only.join(","));
-	if (strictMcpOf(spec)) args.push("--strict-mcp-config");
-	if (spec.agents !== void 0) args.push("--agents", JSON.stringify(spec.agents));
-	if (spec.tools.deny.length > 0) args.push("--disallowedTools", spec.tools.deny.join(","));
-	if (spec.model !== void 0) args.push("--model", spec.model);
-	if (spec.effort !== void 0) args.push("--effort", spec.effort);
-	if (spec.maxTurns !== void 0) args.push("--max-turns", String(spec.maxTurns));
-	if (spec.budgetUsd !== void 0) args.push("--max-budget-usd", String(spec.budgetUsd));
-	if (spec.resume !== void 0) args.push("--resume", spec.resume);
-	if (spec.resume !== void 0 && spec.fork === true) args.push("--fork-session");
-	for (const dir of spec.plugins ?? []) args.push("--plugin-dir", dir);
-	const settings = mcp.holdUrl === void 0 ? spec.settings : withHoldHook(spec.settings, mcp.holdUrl, mcp.token);
-	if (settings !== void 0) args.push("--settings", JSON.stringify(settings));
-	return args;
-};
-/**
-* Drives a session with the user's own `claude` CLI in print mode, logged in by
-* the user. Ork never reads or passes its credentials.
-*/
-const createCliRuntime = (options = {}) => ({
-	driver: "cli",
-	start: (spec, ports) => {
-		const pending = [userLine(spec.prompt)];
-		let io;
-		const ended = new AbortController();
-		/** The hold hook deferred a call in the running process. */
-		let deferring = false;
-		const { hold } = ports;
-		const events = async function* () {
-			const tools = orkTools({
-				nodeId: spec.nodeId,
-				driver: "cli",
-				ports
-			});
-			const mcp = await startOrkMcpHttp(tools, hold === void 0 ? void 0 : async (gone) => {
-				const answer = await holdAtTool(hold, AbortSignal.any([gone, ended.signal]), options.holdWindowMs);
-				if (answer === "defer") deferring = true;
-				return hookOutput(answer);
-			});
-			const allowed = preapprovedTools(tools);
-			const endpoint = hold === void 0 ? {
-				url: mcp.url,
-				token: mcp.token
-			} : mcp;
-			const legOf = (args, carried) => runLeg({
-				bin: options.bin ?? "claude",
-				env: {
-					...options.env ?? process.env,
-					...driverEnv(spec)
-				},
-				cwd: spec.cwd,
-				args,
-				carried,
-				pending,
-				deferred: () => deferring,
-				attach: (attached) => {
-					io = attached;
-				}
-			});
-			let args = buildCliArgs(spec, endpoint, allowed);
-			let spent;
-			try {
-				for (;;) {
-					const leg = yield* legOf(args, spent);
-					if (leg.kind === "failed") {
-						yield driverFailure(leg.reason);
-						return;
-					}
-					if (leg.kind === "finished") return;
-					deferring = false;
-					spent = spent === void 0 ? leg.usage : addUsage(spent, leg.usage);
-					await hold?.wait("tool", ended.signal);
-					if (ended.signal.aborted) {
-						yield leg.last;
-						return;
-					}
-					args = buildCliArgs({
-						...spec,
-						resume: leg.sessionId,
-						fork: false
-					}, endpoint, allowed);
-				}
-			} finally {
-				await mcp.close();
-			}
-		};
-		return {
-			events: events(),
-			send: (text) => {
-				const line = userLine(text, true);
-				if (io === void 0) pending.push(line);
-				else io.write(line);
-			},
-			interrupt: () => {
-				ended.abort();
-				io?.stop();
-				return Promise.resolve();
-			}
-		};
-	}
-});
-// ../runtime-claude/src/queue.ts
-const createQueue = () => {
-	const items = [];
-	const waiting = [];
-	let closed = false;
-	const push = (item) => {
-		if (closed) return;
-		const next = waiting.shift();
-		if (next === void 0) items.push({ value: item });
-		else next({
-			value: item,
-			done: false
-		});
-	};
-	const close = () => {
-		closed = true;
-		for (const next of waiting.splice(0)) next({
-			value: void 0,
-			done: true
-		});
-	};
-	const iterator = { next: () => {
-		const box = items.shift();
-		if (box !== void 0) return Promise.resolve({
-			value: box.value,
-			done: false
-		});
-		if (closed) return Promise.resolve({
-			value: void 0,
-			done: true
-		});
-		return new Promise((resolve) => {
-			waiting.push(resolve);
-		});
-	} };
-	return {
-		push,
-		close,
-		get closed() {
-			return closed;
-		},
-		[Symbol.asyncIterator]: () => iterator
-	};
-};
-// ../runtime-claude/src/sdk.ts
-/**
-* @file The SDK driver: runs a session in-process with the Claude Agent SDK,
-*   only with an API key or a cloud provider, never a claude.ai login, clean of
-*   the machine's Claude setup unless the run asks for it (ADR-065). A node
-*   that can be paused gets a `PreToolUse` callback hook: a short pause holds
-*   the call, a long one defers it and resumes the session when the node
-*   continues (ADR-041).
-*/
-/**
-* The SDK driver runs only with an API key or a cloud provider. It must never
-* fall back to a claude.ai login: Anthropic does not allow third-party tools to
-* route requests through subscription credentials.
-*/
-const sdkCredentials = (env) => {
-	if (env["CLAUDE_CODE_USE_BEDROCK"] === "1") return "Amazon Bedrock";
-	if (env["CLAUDE_CODE_USE_VERTEX"] === "1") return "Google Vertex AI";
-	if (env["CLAUDE_CODE_USE_FOUNDRY"] === "1") return "Microsoft Foundry";
-	if ((env["ANTHROPIC_API_KEY"] ?? "") !== "") return "ANTHROPIC_API_KEY";
-	return null;
-};
-const NO_SDK_CREDENTIALS = "the sdk driver needs ANTHROPIC_API_KEY (or CLAUDE_CODE_USE_BEDROCK=1 / CLAUDE_CODE_USE_VERTEX=1); use --driver cli to run with your own claude login";
-/** A later message goes in at the next step, even mid-turn. */
-const userMessage = (text, later = false) => ({
-	type: "user",
-	message: {
-		role: "user",
-		content: text
-	},
-	parent_tool_use_id: null,
-	...later ? { priority: "next" } : {}
-});
-const definedEnv = (env) => Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
-/**
-* The hold hook: waits before each tool call while the node is paused, and
-* defers the call (`onDefer`) when the pause outlasts the window.
-*/
-const holdHook = (hold, onDefer, windowMs) => ({
-	timeout: 600,
-	hooks: [async (_input, _toolUseId, { signal }) => {
-		if (await holdAtTool(hold, signal, windowMs) === "go") return {};
-		onDefer();
-		return { hookSpecificOutput: {
-			hookEventName: "PreToolUse",
-			permissionDecision: "defer",
-			permissionDecisionReason: "Ork paused this node; it goes on from this call when it continues."
-		} };
-	}]
-});
-/** The Agent SDK options for a session spec. */
-const buildSdkOptions = (spec, ports, env, held) => {
-	const { human } = ports;
-	const tools = orkTools({
-		nodeId: spec.nodeId,
-		driver: "sdk",
-		ports
-	});
-	const ork = createSdkMcpServer({
-		name: "ork",
-		version: "0.0.0",
-		tools: tools.map((t) => tool(t.name, t.description, t.shape, (args) => t.call(args)))
-	});
-	const options = {
-		cwd: spec.cwd,
-		env: definedEnv({
-			...env,
-			...driverEnv(spec)
-		}),
-		settingSources: spec.settingSources,
-		systemPrompt: {
-			type: "preset",
-			preset: "claude_code",
-			append: spec.systemAppend,
-			excludeDynamicSections: true
-		},
-		permissionMode: spec.permissionMode,
-		allowedTools: [...spec.tools.allow, ...preapprovedTools(tools)],
-		disallowedTools: spec.tools.deny,
-		mcpServers: { ["ork"]: ork },
-		outputFormat: {
-			type: "json_schema",
-			schema: spec.reportSchema
-		},
-		canUseTool: async (toolName, input) => {
-			const decision = await human.permit({
-				nodeId: spec.nodeId,
-				toolName,
-				input
-			});
-			return decision.allow ? {
-				behavior: "allow",
-				updatedInput: input
-			} : {
-				behavior: "deny",
-				message: decision.message
-			};
-		}
-	};
-	if (spec.tools.only !== void 0) options.tools = spec.tools.only;
-	if (strictMcpOf(spec)) options.strictMcpConfig = true;
-	if (spec.agents !== void 0) options.agents = spec.agents;
-	if (spec.model !== void 0) options.model = spec.model;
-	if (spec.effort !== void 0) options.effort = spec.effort;
-	if (spec.maxTurns !== void 0) options.maxTurns = spec.maxTurns;
-	if (spec.budgetUsd !== void 0) options.maxBudgetUsd = spec.budgetUsd;
-	if (spec.resume !== void 0) options.resume = spec.resume;
-	if (spec.resume !== void 0 && spec.fork === true) options.forkSession = true;
-	if (spec.plugins !== void 0) options.plugins = spec.plugins.map((dir) => ({
-		type: "local",
-		path: dir
-	}));
-	if (spec.settings !== void 0) options.settings = spec.settings;
-	if (ports.hold !== void 0 && held !== void 0) options.hooks = { PreToolUse: [holdHook(ports.hold, held.onDefer, held.windowMs)] };
-	return options;
-};
-/** Drives a session with the Claude Agent SDK, in this process. */
-const createSdkRuntime = (env = process.env, holdWindowMs) => ({
-	driver: "sdk",
-	start: (spec, ports) => {
-		let input = createQueue();
-		input.push(userMessage(spec.prompt));
-		let current;
-		const ended = new AbortController();
-		/** The hold hook deferred a call in the current query. */
-		let deferring = false;
-		const held = {
-			onDefer: () => {
-				deferring = true;
-			},
-			...holdWindowMs === void 0 ? {} : { windowMs: holdWindowMs }
-		};
-		/** One query: a leg of the session, until its result. */
-		const leg = async function* (resume, carried) {
-			deferring = false;
-			const legSpec = resume === void 0 ? spec : {
-				...spec,
-				resume,
-				fork: false
-			};
-			current = query({
-				prompt: input,
-				options: buildSdkOptions(legSpec, ports, env, held)
-			});
-			let outcome = {
-				kind: "failed",
-				reason: "the session ended early"
-			};
-			for await (const message of current) {
-				const { events, ended: end } = legStep(message, {
-					carried,
-					deferred: deferring,
-					driver: "sdk"
-				});
-				yield* events;
-				if (end !== void 0) {
-					input.close();
-					outcome = end;
-				}
-			}
-			return outcome;
-		};
-		const events = async function* () {
-			if (sdkCredentials(env) === null) {
-				yield driverFailure(NO_SDK_CREDENTIALS);
-				return;
-			}
-			let resume = spec.resume;
-			let spent;
-			try {
-				for (;;) {
-					const result = yield* leg(resume, spent);
-					if (result.kind === "failed") {
-						yield driverFailure(result.reason);
-						return;
-					}
-					if (result.kind === "finished") return;
-					input = createQueue();
-					spent = spent === void 0 ? result.usage : addUsage(spent, result.usage);
-					await ports.hold?.wait("tool", ended.signal);
-					if (ended.signal.aborted) {
-						yield result.last;
-						return;
-					}
-					resume = result.sessionId;
-				}
-			} catch (error) {
-				input.close();
-				yield driverFailure(error instanceof Error ? error.message : String(error));
-			}
-		};
-		return {
-			events: events(),
-			send: (text) => {
-				input.push(userMessage(text, true));
-			},
-			interrupt: async () => {
-				ended.abort();
-				await current?.interrupt();
-			}
-		};
-	}
-});
-// ../runtime-claude/src/registry.ts
-const RUNTIME_FACTORIES = {
-	sdk: (env) => createSdkRuntime(env),
-	cli: (env) => createCliRuntime({ env })
-};
-/** The runtime for a driver id, with the user's environment. */
-const createRuntime = (driver, env) => RUNTIME_FACTORIES[driver](env);
-export { createRuntime };