@krapht/ork 0.0.0-stage → 0.2.0

package/dist/src-DAsOYtoR.mjs

@@ -0,0 +1,853 @@
+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";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
+/** 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`.
+*/
+const PATH = "/mcp";
+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));
+};
+const serve = async (req, res, tools, token) => {
+	if (!authorized(req, token)) {
+		respond(res, 401);
+		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) => {
+	const token = randomBytes(24).toString("hex");
+	const http = createServer((req, res) => {
+		serve(req, res, tools, token).catch(() => {
+			if (!res.headersSent) respond(res, 500);
+		});
+	});
+	await new Promise((resolve) => {
+		http.listen(0, "127.0.0.1", resolve);
+	});
+	const address = http.address();
+	return {
+		url: `http://127.0.0.1:${typeof address === "object" && address !== null ? address.port : 0}${PATH}`,
+		token,
+		close: () => new Promise((resolve) => {
+			http.closeAllConnections();
+			http.close(() => {
+				resolve();
+			});
+		})
+	};
+};
+// ../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") : []
+	};
+};
+/** 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 "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]
+	}
+});
+// ../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) => {
+		const question = {
+			nodeId,
+			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);
+		return text(`The user chose: ${answer}`);
+	}
+});
+// ../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. */
+const hasPeers = ({ ports }) => (ports.mailbox?.peers().length ?? 0) > 0;
+const sendMessageTool = defineTool({
+	name: "send_message",
+	description: "Send a short message to another node in this run: your owner, a node you own, or one you share a declared channel with. 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."),
+		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 when it next starts.`));
+	}
+});
+const readInboxTool = defineTool({
+	name: "read_inbox",
+	description: "Read your unread messages from other nodes in this run, oldest first. Ork tells you when one arrives.",
+	shape: {},
+	available: hasPeers,
+	run: ({ ports }) => {
+		const unread = ports.mailbox?.read() ?? [];
+		return Promise.resolve(text(unread.length === 0 ? "No unread messages." : JSON.stringify({ messages: unread.map((m) => ({
+			from: m.from,
+			body: m.body
+		})) })));
+	}
+});
+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.")
+	},
+	available: ({ ports }) => ports.mailbox !== void 0 && ports.ownership !== void 0,
+	run: ({ ports }, args) => {
+		const answered = ports.mailbox?.answer(args.question, args.choice);
+		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,
+	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
+/**
+* @file The CLI driver: runs a session through the user's own `claude -p` in
+*   stream-json mode, with Ork's tools served by a local MCP server.
+*/
+const STDERR_LINES = 20;
+/**
+* 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,
+		"--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 (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);
+	for (const dir of spec.plugins ?? []) args.push("--plugin-dir", dir);
+	if (spec.settings !== void 0) args.push("--settings", JSON.stringify(spec.settings));
+	return args;
+};
+const parseLine = (line) => {
+	try {
+		return JSON.parse(line);
+	} catch {
+		return;
+	}
+};
+/**
+* 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 write;
+		let stop;
+		const events = async function* () {
+			const tools = orkTools({
+				nodeId: spec.nodeId,
+				driver: "cli",
+				ports
+			});
+			const mcp = await startOrkMcpHttp(tools);
+			const args = buildCliArgs(spec, mcp, preapprovedTools(tools));
+			const child = spawn(options.bin ?? "claude", args, {
+				cwd: spec.cwd,
+				env: { ...options.env ?? process.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));
+			});
+			write = (line) => {
+				if (child.stdin.writable) child.stdin.write(line);
+			};
+			stop = () => {
+				child.kill("SIGINT");
+			};
+			for (const line of pending.splice(0)) write(line);
+			let finished = false;
+			try {
+				const lines = createInterface({ input: child.stdout });
+				for await (const line of lines) for (const event of normalize(parseLine(line))) {
+					if (event.type === "session.finished") {
+						finished = true;
+						child.stdin.end();
+					}
+					yield withDriver(event, "cli");
+				}
+				const code = await Promise.race([exited, spawnError.then((error) => error)]);
+				if (!finished) {
+					const reason = code instanceof Error ? `could not start ${options.bin ?? "claude"}: ${code.message}` : stderr.at(-1) ?? `claude exited with code ${String(code)}`;
+					yield driverFailure(reason);
+				}
+			} finally {
+				if (child.exitCode === null) child.kill();
+				await mcp.close();
+			}
+		};
+		return {
+			events: events(),
+			send: (text) => {
+				const line = userLine(text, true);
+				if (write === void 0) pending.push(line);
+				else write(line);
+			},
+			interrupt: () => {
+				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.
+*/
+/**
+* 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 Agent SDK options for a session spec. */
+const buildSdkOptions = (spec, ports, env) => {
+	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),
+		settingSources: spec.settingSources,
+		systemPrompt: {
+			type: "preset",
+			preset: "claude_code",
+			append: spec.systemAppend
+		},
+		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 (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.plugins !== void 0) options.plugins = spec.plugins.map((dir) => ({
+		type: "local",
+		path: dir
+	}));
+	if (spec.settings !== void 0) options.settings = spec.settings;
+	return options;
+};
+/** Drives a session with the Claude Agent SDK, in this process. */
+const createSdkRuntime = (env = process.env) => ({
+	driver: "sdk",
+	start: (spec, ports) => {
+		const input = createQueue();
+		input.push(userMessage(spec.prompt));
+		let current;
+		const events = async function* () {
+			if (sdkCredentials(env) === null) {
+				yield driverFailure(NO_SDK_CREDENTIALS);
+				return;
+			}
+			try {
+				current = query({
+					prompt: input,
+					options: buildSdkOptions(spec, ports, env)
+				});
+				for await (const message of current) for (const event of normalize(message)) {
+					if (event.type === "session.finished") input.close();
+					yield withDriver(event, "sdk");
+				}
+			} 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 () => {
+				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 };