@iowarp/clio-coder 0.4.3 → 0.4.5

package/src/engine/antigravity/subprocess-runtime.ts

@@ -117,6 +117,15 @@ export function buildAgyArgs(input: WorkerRunInput, gateEnv: NodeJS.ProcessEnv =
 		"--disable-slash-commands",
 	];
 	if (input.wireModelId.trim().length > 0) args.push("--model", input.wireModelId.trim());
+	if (typeof input.sessionId === "string" && input.sessionId.length > 0) {
+		if (Buffer.byteLength(input.sessionId, "utf8") > MAX_CONVERSATION_ID_BYTES) {
+			throw new Error(`Antigravity sessionId exceeded ${MAX_CONVERSATION_ID_BYTES} bytes`);
+		}
+		if (/\p{Cc}/u.test(input.sessionId)) {
+			throw new Error("Antigravity sessionId must not contain control characters");
+		}
+		args.push("--conversation", input.sessionId);
+	}
 	return args;
 }
 
@@ -245,7 +254,12 @@ function emitTextDelta(emit: WorkerEventEmit, state: StreamState, delta: string)
 	} as AgentEvent);
 }
 
-async function readStream(child: AntigravityChildProcess, emit: WorkerEventEmit, state: StreamState): Promise<void> {
+async function readStream(
+	child: AntigravityChildProcess,
+	emit: WorkerEventEmit,
+	state: StreamState,
+	requestedConversationId: string | undefined,
+): Promise<void> {
 	for await (const bounded of readBoundedLines(child.stdout, {
 		maxLineBytes: ANTIGRAVITY_MAX_STREAM_LINE_BYTES,
 		maxTotalBytes: ANTIGRAVITY_MAX_STREAM_BYTES,
@@ -272,6 +286,9 @@ async function readStream(child: AntigravityChildProcess, emit: WorkerEventEmit,
 					break;
 				}
 				state.initSeen = true;
+				if (requestedConversationId && event.conversationId !== requestedConversationId) {
+					protocolFailure(state, "requested conversation was not resumed");
+				}
 				state.conversationId = boundedConversationId(event.conversationId);
 				if (event.model?.trim()) state.model = event.model.trim();
 				break;
@@ -354,8 +371,7 @@ function buildAssistantMessage(input: {
 		stopReason: input.aborted ? "aborted" : succeeded ? "stop" : "error",
 		timestamp: Date.now(),
 	} as AgentMessage & { role: "assistant" };
-	// Opaque provider observation only. This runtime never accepts it as a
-	// resumable Clio session id.
+	// Opaque provider observation only; callers must explicitly request resume.
 	if (input.conversationId) message.responseId = input.conversationId;
 	if (input.diagnostic) message.errorMessage = boundedExternalDiagnostic(input.diagnostic);
 	return message;
@@ -414,7 +430,7 @@ export function startAntigravityWorkerRun(
 		emit({ type: "agent_start" } as AgentEvent);
 		try {
 			const stderrPromise = readStderr(child);
-			const stdoutPromise = readStream(child, emit, streamState).catch((cause) => {
+			const stdoutPromise = readStream(child, emit, streamState, input.sessionId).catch((cause) => {
 				streamError = boundedExternalDiagnostic(cause instanceof Error ? cause.message : String(cause));
 				terminator.terminate();
 			});

package/src/engine/api-registry.ts

@@ -27,6 +27,7 @@ import "@earendil-works/pi-ai/providers/images/register-builtins";
 
 import { getEngineEnvApiKey } from "./env-api-keys.js";
 import { engineModels } from "./models.js";
+import { instrumentProviderCall } from "./provider-diagnostics.js";
 
 export interface EngineRegisteredApiProvider extends ProviderStreams {
 	api: Api;
@@ -134,7 +135,7 @@ function hasCloudflareAuth(options?: StreamOptions): boolean {
 	);
 }
 
-export function engineStream(
+function dispatchEngineStream(
 	model: Model<Api>,
 	context: Context,
 	options?: StreamOptions,
@@ -151,7 +152,7 @@ export function engineStream(
 	return resolved(model.api).stream(model, context, withEnvApiKey(model, options));
 }
 
-export function engineStreamSimple(
+function dispatchEngineStreamSimple(
 	model: Model<Api>,
 	context: Context,
 	options?: SimpleStreamOptions,
@@ -168,6 +169,22 @@ export function engineStreamSimple(
 	return resolved(model.api).streamSimple(model, context, withEnvApiKey(model, options));
 }
 
+export function engineStream(
+	model: Model<Api>,
+	context: Context,
+	options?: StreamOptions,
+): AssistantMessageEventStream {
+	return instrumentProviderCall(model, options, (effective) => dispatchEngineStream(model, context, effective));
+}
+
+export function engineStreamSimple(
+	model: Model<Api>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	return instrumentProviderCall(model, options, (effective) => dispatchEngineStreamSimple(model, context, effective));
+}
+
 export async function completeEngineSimple(
 	model: Model<Api>,
 	context: Context,

package/src/engine/apis/ollama-native.ts

@@ -41,6 +41,7 @@ import { mergeSamplingOverride } from "./sampling-overrides.js";
 import type { EngineApiProvider } from "./types.js";
 
 const REASONING_CHARS_PER_TOKEN = 4;
+const ownedModelsByTarget = new Map<string, Set<string>>();
 
 interface ClioRuntimeMetadata {
 	clioCoder?: {
@@ -293,7 +294,10 @@ async function listResidentOllamaModels(client: OllamaEvictClient): Promise<Resi
  * weights release.
  */
 async function unloadOllamaModel(baseUrl: string, modelId: string, headers?: Record<string, string>): Promise<void> {
+	const owned = ownedModelsByTarget.get(residencyTargetKey("ollama-native", baseUrl));
+	if (!owned?.has(modelId)) return;
 	await ollamaEvictClient(baseUrl, headers).generate({ model: modelId, prompt: "", keep_alive: 0, stream: false });
+	owned.delete(modelId);
 }
 
 function mapStopReason(reason: string | undefined, hadToolCall: boolean): AssistantMessage["stopReason"] {
@@ -466,8 +470,19 @@ function runStream(
 					else emitText(segment.content);
 				}
 			};
+			let recordedOwnership = false;
 			for await (const chunk of iterator) {
 				const response = chunk as ChatResponse;
+				if (!recordedOwnership && model.baseUrl) {
+					const targetKey = residencyTargetKey("ollama-native", model.baseUrl);
+					let owned = ownedModelsByTarget.get(targetKey);
+					if (!owned) {
+						owned = new Set<string>();
+						ownedModelsByTarget.set(targetKey, owned);
+					}
+					owned.add(response.model || model.id);
+					recordedOwnership = true;
+				}
 				const msg = response.message;
 				if (msg?.thinking && msg.thinking.length > 0) {
 					emitThinking(msg.thinking);

package/src/engine/apis/openai-completions.ts

@@ -297,13 +297,14 @@ function withLiteLLMRouteFailureAdvice(
 	(async () => {
 		try {
 			for await (const event of source) {
-				if (event.type === "error") {
+				if (event.type === "error" && event.reason !== "aborted" && event.error.stopReason !== "aborted") {
 					event.error.errorMessage = liteLLMRouteFailureMessage(event.error.errorMessage, metadata.targetId, model.id);
 				}
 				advised.push(event as AssistantMessageEvent);
 			}
 			advised.end();
 		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") throw err;
 			const message = err instanceof Error ? err.message : String(err);
 			throw new Error(liteLLMRouteFailureMessage(message, metadata.targetId, model.id));
 		}
@@ -922,11 +923,17 @@ function guardMalformedToolCalls(
 	(async () => {
 		try {
 			for await (const event of source) {
-				if (event.type === "toolcall_end") {
-					const required = requiredByTool.get(event.toolCall.name);
-					if (required && hasEmptyArguments(event.toolCall.arguments)) {
-						const message = malformedToolArgsMessage(model, event.toolCall.name, required);
-						const error = finalErrorFromPartial(event.partial, message);
+				// The final stop reason distinguishes malformed output from a token
+				// limit. pi rejects every call in a length-truncated message (even
+				// salvage-parsed arguments) and continues with error tool results.
+				// Turning that into an error here aborts the worker before recovery.
+				if (event.type === "done" && event.message.stopReason !== "length") {
+					const malformed = event.message.content.find(
+						(block) => block.type === "toolCall" && requiredByTool.has(block.name) && hasEmptyArguments(block.arguments),
+					);
+					if (malformed?.type === "toolCall") {
+						const message = malformedToolArgsMessage(model, malformed.name, requiredByTool.get(malformed.name) ?? []);
+						const error = finalErrorFromPartial(event.message, message);
 						guarded.push({ type: "error", reason: "error", error });
 						guarded.end(error);
 						return;

package/src/engine/apis/output-budget.ts

@@ -32,18 +32,38 @@ export function setGlobalDefaultMaxOutputTokens(value: number): void {
 
 /**
  * Tokens a preflight context check should hold back for the response: the
- * smaller of the model's advertised output limit and the default output
- * budget. The safety margin is deliberately not added here; at request time
+ * smaller of the model's advertised output limit and the configured output
+ * budget, falling back to the product default when no budget is configured.
+ * The safety margin is deliberately not added here; at request time
  * {@link remainingContextMaxTokens} subtracts it from the window and degrades
  * the output budget gracefully, so a hard preflight reservation of
  * limit + safety would compact earlier than the engine actually needs.
  */
-export function resolveReservedOutputTokens(maxOutputTokens?: number | null): number {
+export function resolveReservedOutputTokens(
+	maxOutputTokens?: number | null,
+	request?: { api: string; contextWindow: number; inputTokens: number },
+): number {
+	const requested = globalDefaultMaxOutputTokens > 0 ? globalDefaultMaxOutputTokens : DEFAULT_MAX_OUTPUT_TOKENS;
 	const limit =
 		typeof maxOutputTokens === "number" && Number.isFinite(maxOutputTokens) && maxOutputTokens > 0
 			? maxOutputTokens
-			: DEFAULT_MAX_OUTPUT_TOKENS;
-	return Math.min(limit, DEFAULT_MAX_OUTPUT_TOKENS);
+			: Number.POSITIVE_INFINITY;
+	const ceiling = Math.min(limit, requested);
+	// These Clio transports already reduce the wire ceiling to remaining room.
+	// Preflight must use that same allocation, rather than demanding room for
+	// the entire configured maximum (which may equal the context window).
+	// Other transports retain their existing reservation contract.
+	return request && (request.api === "openai-completions" || request.api === "ollama-native")
+		? clampOutputToRemainingContext(ceiling, request.contextWindow, request.inputTokens)
+		: ceiling;
+}
+
+function clampOutputToRemainingContext(ceiling: number, contextWindow: number, inputTokens: number): number {
+	const available =
+		contextWindow > 0 && Number.isFinite(contextWindow)
+			? Math.max(1, contextWindow - inputTokens - CONTEXT_BUDGET_SAFETY_TOKENS)
+			: Number.POSITIVE_INFINITY;
+	return Math.min(ceiling, available);
 }
 
 export function estimateInputTokensFromContext(context: Context): number {
@@ -59,15 +79,11 @@ export function remainingContextMaxTokens(
 	options: Pick<StreamOptions, "maxTokens"> | undefined,
 	limits?: { contextWindow?: number; maxOutputTokens?: number },
 ): number {
-	const safety = CONTEXT_BUDGET_SAFETY_TOKENS;
 	const inputTokens = estimateInputTokensFromContext(context);
 	const configuredContextWindow = model.contextWindow > 0 ? model.contextWindow : Number.POSITIVE_INFINITY;
 	const loadedContextWindow =
 		limits?.contextWindow !== undefined && limits.contextWindow > 0 ? limits.contextWindow : Number.POSITIVE_INFINITY;
 	const contextWindow = Math.min(configuredContextWindow, loadedContextWindow);
-	const budget = Number.isFinite(contextWindow)
-		? Math.max(1, contextWindow - inputTokens - safety)
-		: Number.POSITIVE_INFINITY;
 	const modelLimit = model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY;
 	// Precedence for the requested ceiling when the caller gave no explicit
 	// maxTokens: a more-specific tool-turn limit, then the global default, then
@@ -84,6 +100,6 @@ export function remainingContextMaxTokens(
 					? modelLimit
 					: DEFAULT_MAX_OUTPUT_TOKENS;
 	const requested = options?.maxTokens ?? defaultLimit;
-	const resolved = Math.min(requested, modelLimit, budget);
+	const resolved = clampOutputToRemainingContext(Math.min(requested, modelLimit), contextWindow, inputTokens);
 	return Number.isFinite(resolved) ? resolved : DEFAULT_MAX_OUTPUT_TOKENS;
 }

package/src/engine/claude/sdk-runtime.ts

@@ -314,7 +314,7 @@ export interface ClaudeWorkerBudgetGate {
 }
 
 /** Canonical call counter shared by the SDK's PreToolUse/canUseTool mediation seam. */
-function createClaudeWorkerBudgetGate(
+export function createClaudeWorkerBudgetGate(
 	budget: WorkerBudget,
 	onBoundary: () => void,
 	onHardCap: () => void,
@@ -330,6 +330,7 @@ function createClaudeWorkerBudgetGate(
 	let admitted = 0;
 	let locked = false;
 	const phaseDecision = (canonicalToolName: string): { kind: "allow" } | { kind: "deny"; reason: string } => {
+		if (budget.mode === "advisory") return { kind: "allow" };
 		const reserveAdmits = isReserveAdmittedTool(canonicalToolName, deliveryTools);
 		if (locked || admitted >= budget.toolCalls) {
 			// Same rule the native guard applies: the soft budget ends discovery,
@@ -365,7 +366,7 @@ function createClaudeWorkerBudgetGate(
 	return {
 		attempt(canonicalToolName) {
 			attempts += 1;
-			if (attempts > budget.hardCap) {
+			if (budget.mode !== "advisory" && attempts > budget.hardCap) {
 				onHardCap();
 				return { kind: "deny", reason: `workerToolCallCap reached (${budget.hardCap}); abort run` };
 			}
@@ -381,7 +382,7 @@ function createClaudeWorkerBudgetGate(
 			// Locking here is what ends the work phase. A delivery-capable agent is
 			// not locked at its soft budget: it still owes the files it was
 			// dispatched to write, and hardCap in attempt() is its bound.
-			if (admitted >= budget.toolCalls && deliveryTools.length === 0) {
+			if (budget.mode !== "advisory" && admitted >= budget.toolCalls && deliveryTools.length === 0) {
 				locked = true;
 				onBoundary();
 			}

package/src/engine/claude/subprocess-runtime.ts

@@ -1,17 +1,30 @@
 import { type ChildProcessByStdio, spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import type { Readable } from "node:stream";
+import type { Readable, Writable } from "node:stream";
 
+import { boundedExternalDiagnostic } from "../../core/external-diagnostic.js";
+import { buildSafeToolEnv, resolveSafeCwd } from "../../core/safe-exec.js";
 import type { AutonomyLevel } from "../../domains/safety/autonomy.js";
 import { assertToolProfileEnforceable } from "../../tools/profiles.js";
-import { readStderr, waitForClose } from "../external-subprocess.js";
+import { createProcessTreeTerminator, readBoundedLines, readStderr, waitForClose } from "../external-subprocess.js";
 import type { AgentEvent, AgentMessage, Usage } from "../types.js";
 import type { WorkerEventEmit, WorkerRunHandle, WorkerRunInput, WorkerRunResult } from "../worker-runtime.js";
 import { isClaudeCodeSessionId } from "./session-id.js";
 
 const READ_ONLY_CLAUDE_TOOLS = ["Read", "Grep", "Glob", "LS", "WebFetch", "WebSearch"] as const;
 
-type ClaudeChildProcess = ChildProcessByStdio<null, Readable, Readable>;
+/** Official CLI binary, resolved from the operator's PATH. */
+const CLAUDE_BINARY = "claude";
+export const CLAUDE_MAX_STREAM_LINE_BYTES = 1024 * 1024;
+export const CLAUDE_MAX_STREAM_BYTES = 8 * 1024 * 1024;
+
+type ClaudeChildProcess = ChildProcessByStdio<Writable, Readable, Readable>;
+
+export interface ClaudeRuntimeDependencies {
+	binary?: string;
+	workspaceRoot?: string;
+	environment?: NodeJS.ProcessEnv;
+	killGraceMs?: number;
+}
 
 export interface ClaudeSubprocessPermissionConfig {
 	permissionMode: "plan" | "dontAsk" | "acceptEdits" | "default" | "bypassPermissions";
@@ -48,15 +61,20 @@ export function claudeSubprocessPermissionConfigForAutonomy(
 	return { permissionMode: "default", extraArgs: [], dangerousBypass: false };
 }
 
-function buildClaudeCodePrompt(input: WorkerRunInput): string {
+export function buildClaudeCodePrompt(input: WorkerRunInput): string {
 	const parts = (input.dynamicPromptMessages ?? []).map((message) => message.body.trim()).filter(Boolean);
 	parts.push(input.task);
 	return parts.join("\n\n");
 }
 
-function buildClaudeCodeArgs(input: WorkerRunInput): string[] {
+/**
+ * `claude -p` reads the user prompt from stdin when no positional prompt is
+ * given, so the prompt never appears in argv. The system prompt stays on
+ * `--append-system-prompt`: stdin carries only the user turn.
+ */
+export function buildClaudeCodeArgs(input: WorkerRunInput, gateEnv: NodeJS.ProcessEnv = process.env): string[] {
 	assertToolProfileEnforceable(input.toolProfile, "claude-code");
-	const permission = claudeSubprocessPermissionConfigForAutonomy(input.autonomy);
+	const permission = claudeSubprocessPermissionConfigForAutonomy(input.autonomy, gateEnv);
 	const args = [
 		"-p",
 		"--output-format",
@@ -71,7 +89,6 @@ function buildClaudeCodeArgs(input: WorkerRunInput): string[] {
 	const systemPrompt = input.systemPrompt.trim();
 	if (systemPrompt.length > 0) args.push("--append-system-prompt", systemPrompt);
 	if (isClaudeCodeSessionId(input.sessionId)) args.push("--session-id", input.sessionId.trim());
-	args.push(buildClaudeCodePrompt(input));
 	return args;
 }
 
@@ -170,8 +187,11 @@ function buildAssistantMessage(input: {
 	exitCode: number;
 	aborted: boolean;
 	stderr: string;
+	transportError?: string;
 }): AgentMessage & { role: "assistant" } {
-	const errorMessage = input.exitCode === 0 ? "" : resultError(input.result, input.stderr);
+	const transportError = input.transportError ?? "";
+	const failed = input.exitCode !== 0 || transportError.length > 0;
+	const errorMessage = !failed ? "" : transportError || resultError(input.result, input.stderr);
 	const message: AgentMessage & { role: "assistant" } = {
 		role: "assistant",
 		content: [{ type: "text", text: input.text }],
@@ -179,12 +199,12 @@ function buildAssistantMessage(input: {
 		provider: "anthropic",
 		model: input.model,
 		usage: normalizeUsage(input.result?.usage, finite(input.result?.total_cost_usd)),
-		stopReason: input.aborted ? "aborted" : input.exitCode === 0 ? "stop" : "error",
+		stopReason: input.aborted ? "aborted" : failed ? "error" : "stop",
 		timestamp: Date.now(),
 	} as AgentMessage & { role: "assistant" };
 	if (typeof input.result?.request_id === "string") message.responseId = input.result.request_id;
 	if (typeof input.result?.model === "string") message.responseModel = input.result.model;
-	if (errorMessage.length > 0) message.errorMessage = errorMessage;
+	if (errorMessage.length > 0) message.errorMessage = boundedExternalDiagnostic(errorMessage);
 	return message;
 }
 
@@ -224,9 +244,14 @@ async function readJsonLines(
 	emit: WorkerEventEmit,
 	state: { started: boolean; text: string; model: string; result: Record<string, unknown> | null },
 ): Promise<void> {
-	const rl = createInterface({ input: child.stdout });
-	for await (const line of rl) {
-		const trimmed = line.trim();
+	for await (const bounded of readBoundedLines(child.stdout, {
+		maxLineBytes: CLAUDE_MAX_STREAM_LINE_BYTES,
+		maxTotalBytes: CLAUDE_MAX_STREAM_BYTES,
+	})) {
+		if (bounded.kind === "oversized") {
+			throw new Error(`claude stream-json line exceeded ${CLAUDE_MAX_STREAM_LINE_BYTES} bytes`);
+		}
+		const trimmed = bounded.line.trim();
 		if (trimmed.length === 0) continue;
 		let parsed: unknown;
 		try {
@@ -250,12 +275,21 @@ async function readJsonLines(
 	}
 }
 
-export function startClaudeCodeWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): WorkerRunHandle {
-	const args = buildClaudeCodeArgs(input);
-	const child = spawn("claude", args, {
-		cwd: process.cwd(),
-		env: process.env,
-		stdio: ["ignore", "pipe", "pipe"],
+export function startClaudeCodeWorkerRun(
+	input: WorkerRunInput,
+	emit: WorkerEventEmit,
+	dependencies: ClaudeRuntimeDependencies = {},
+): WorkerRunHandle {
+	const sourceEnv = dependencies.environment ?? process.env;
+	const args = buildClaudeCodeArgs(input, sourceEnv);
+	const prompt = buildClaudeCodePrompt(input);
+	const workspaceRoot = dependencies.workspaceRoot ?? process.cwd();
+	const cwd = resolveSafeCwd(input.cwd, workspaceRoot);
+	const child: ClaudeChildProcess = spawn(dependencies.binary ?? CLAUDE_BINARY, args, {
+		cwd,
+		env: buildSafeToolEnv({}, sourceEnv),
+		detached: process.platform !== "win32",
+		stdio: ["pipe", "pipe", "pipe"],
 	});
 	const streamState = {
 		started: false,
@@ -264,53 +298,66 @@ export function startClaudeCodeWorkerRun(input: WorkerRunInput, emit: WorkerEven
 		result: null as Record<string, unknown> | null,
 	};
 	let aborted = false;
-	let killTimer: NodeJS.Timeout | null = null;
-
+	let settled = false;
+	let transportError = "";
+	const terminator = createProcessTreeTerminator(child, dependencies.killGraceMs ?? 1500);
 	const abort = (): void => {
+		if (settled) return;
 		aborted = true;
-		if (child.killed) return;
-		child.kill("SIGTERM");
-		killTimer = setTimeout(() => {
-			if (!child.killed) child.kill("SIGKILL");
-		}, 1500);
+		terminator.terminate();
 	};
-	if (input.signal) {
-		if (input.signal.aborted) abort();
-		else input.signal.addEventListener("abort", abort, { once: true });
-	}
+	const onAbort = (): void => abort();
+	if (input.signal?.aborted) abort();
+	else input.signal?.addEventListener("abort", onAbort, { once: true });
+	child.once("error", (cause) => {
+		transportError ||=
+			(cause as NodeJS.ErrnoException).code === "ENOENT"
+				? "Claude Code CLI (`claude`) is not installed or not on PATH."
+				: cause.message;
+	});
+	child.stdin.on("error", (cause) => {
+		if (!aborted) transportError ||= `could not send prompt to Claude Code CLI: ${cause.message}`;
+	});
+	child.stdin.end(prompt);
 
 	const promise = (async (): Promise<WorkerRunResult> => {
 		emit({ type: "agent_start" } as AgentEvent);
-		const stderrPromise = readStderr(child);
-		const stdoutPromise = readJsonLines(child, emit, streamState);
-		const exitCode = await waitForClose(child);
-		await stdoutPromise.catch(() => {});
-		const stderr = await stderrPromise.catch(() => "");
-		if (killTimer) clearTimeout(killTimer);
-		const finalText =
-			streamState.text ||
-			resultText(streamState.result) ||
-			(exitCode === 0 ? "" : resultError(streamState.result, stderr));
-		const finalMessage = buildAssistantMessage({
-			model: streamState.model,
-			text: finalText,
-			result: streamState.result,
-			exitCode,
-			aborted,
-			stderr,
-		});
-		if (!streamState.started) emit({ type: "message_start", message: finalMessage } as AgentEvent);
-		emit({ type: "message_end", message: finalMessage } as AgentEvent);
-		const messages: AgentMessage[] = [finalMessage];
-		emit({ type: "agent_end", messages } as AgentEvent);
-		if (exitCode !== 0 && stderr.trim().length > 0 && !aborted) {
-			process.stderr.write(`[worker:claude-code] ${stderr.trim()}\n`);
+		try {
+			const stderrPromise = readStderr(child);
+			const stdoutPromise = readJsonLines(child, emit, streamState).catch((cause) => {
+				transportError ||= cause instanceof Error ? cause.message : String(cause);
+				terminator.terminate();
+			});
+			const exitCode = await waitForClose(child);
+			await stdoutPromise;
+			const stderr = await stderrPromise.catch(() => "");
+			const finalText =
+				streamState.text ||
+				resultText(streamState.result) ||
+				(exitCode === 0 ? "" : resultError(streamState.result, stderr));
+			const finalMessage = buildAssistantMessage({
+				model: streamState.model,
+				text: finalText,
+				result: streamState.result,
+				exitCode,
+				aborted,
+				stderr,
+				transportError,
+			});
+			if (!streamState.started) emit({ type: "message_start", message: finalMessage } as AgentEvent);
+			emit({ type: "message_end", message: finalMessage } as AgentEvent);
+			const messages: AgentMessage[] = [finalMessage];
+			emit({ type: "agent_end", messages } as AgentEvent);
+			if (finalMessage.stopReason === "error" && finalMessage.errorMessage && !aborted) {
+				process.stderr.write(`[worker:claude-code] ${finalMessage.errorMessage}\n`);
+			}
+			return { messages, exitCode: finalMessage.stopReason === "stop" ? 0 : 1 };
+		} finally {
+			settled = true;
+			terminator.cleanup();
+			input.signal?.removeEventListener("abort", onAbort);
 		}
-		return { messages, exitCode: exitCode === 0 ? 0 : 1 };
 	})();
 
-	return {
-		promise,
-		abort,
-	};
+	return { promise, abort };
 }

package/src/engine/env-api-keys.ts

@@ -12,6 +12,7 @@ const ENV_KEYS: Readonly<Record<string, string>> = {
 	"ant-ling": "ANT_LING_API_KEY",
 	"qwen-token-plan": "QWEN_TOKEN_PLAN_API_KEY",
 	"qwen-token-plan-cn": "QWEN_TOKEN_PLAN_CN_API_KEY",
+	"qwen-token-plan-individual": "QWEN_TOKEN_PLAN_API_KEY",
 	openai: "OPENAI_API_KEY",
 	"azure-openai-responses": "AZURE_OPENAI_API_KEY",
 	nvidia: "NVIDIA_API_KEY",
@@ -59,7 +60,7 @@ function apiKeyEnvVars(provider: string): readonly string[] | undefined {
 	return name ? [name] : undefined;
 }
 
-/** Synchronous provider-key discovery pinned to pi-ai 0.84's public behavior. */
+/** Synchronous provider-key discovery pinned to pi-ai 0.85's public behavior. */
 export function findEngineEnvKeys(provider: string, env?: ProviderEnv): string[] | undefined {
 	const names = apiKeyEnvVars(provider);
 	if (!names) return undefined;

package/src/engine/external-subprocess.ts

@@ -1,4 +1,4 @@
-import type { ChildProcessByStdio } from "node:child_process";
+import { type ChildProcessByStdio, spawn } from "node:child_process";
 import type { Readable } from "node:stream";
 
 import { boundedExternalDiagnostic } from "../core/external-diagnostic.js";
@@ -81,16 +81,18 @@ export interface ProcessTreeTerminator {
 	cleanup(): void;
 }
 
-/** POSIX process-group termination with a direct-child fallback; Windows is direct-child only. */
+/** POSIX process groups or Windows taskkill trees, with a direct-child fallback. */
 export function createProcessTreeTerminator(
 	child: { pid?: number | undefined; exitCode: number | null; kill(signal?: NodeJS.Signals): boolean },
 	graceMs = 1500,
+	options: { platform?: NodeJS.Platform; spawn?: typeof spawn } = {},
 ): ProcessTreeTerminator {
+	const platform = options.platform ?? process.platform;
+	const spawnKiller = options.spawn ?? spawn;
 	let sent = false;
 	let timer: ReturnType<typeof setTimeout> | null = null;
 	const signal = (name: NodeJS.Signals): void => {
-		if (child.exitCode !== null) return;
-		if (child.pid && process.platform !== "win32") {
+		if (child.pid && platform !== "win32") {
 			try {
 				process.kill(-child.pid, name);
 				return;
@@ -98,6 +100,15 @@ export function createProcessTreeTerminator(
 				// The child may not have established its group yet.
 			}
 		}
+		if (platform === "win32" && child.pid !== undefined && Number.isSafeInteger(child.pid) && child.pid > 0) {
+			const args = ["/PID", String(child.pid), "/T", ...(name === "SIGKILL" ? ["/F"] : [])];
+			const killer = spawnKiller("taskkill.exe", args, { stdio: "ignore", windowsHide: true });
+			killer.once("error", () => {
+				if (child.exitCode === null) child.kill(name);
+			});
+			return;
+		}
+		if (child.exitCode !== null) return;
 		child.kill(name);
 	};
 	return {
@@ -105,11 +116,19 @@ export function createProcessTreeTerminator(
 			if (sent) return;
 			sent = true;
 			signal("SIGTERM");
-			timer = setTimeout(() => signal("SIGKILL"), graceMs);
+			timer = setTimeout(() => {
+				timer = null;
+				signal("SIGKILL");
+			}, graceMs);
 		},
 		cleanup() {
-			if (timer) clearTimeout(timer);
-			timer = null;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+				// A closed leader can leave descendants with independent stdio.
+				// Finish the requested cancellation before releasing its escalation.
+				signal("SIGKILL");
+			}
 		},
 	};
 }