@xopcai/xopc 0.0.244 → 0.0.245

package/dist/src/agent/child-agent-factory.js

@@ -1,177 +1,131 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
-import { getApiKeySync, init_providers } from "../providers/index.js";
-import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
-import { extractTextContent } from "./context/workspace.js";
-import { resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "./orchestration/run-agent-turn-with-timeout.js";
+import { evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
+import { InMemoryTranscriptRuntime } from "./embedded/transcript-runtime.js";
+import { runXopcEmbeddedTurn } from "./embedded/run-turn.js";
+import { createAgentTurnPolicy } from "./orchestration/agent-turn-policy.js";
 import { buildSubagentSystemPrompt } from "./prompt/subagent-context.js";
 import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
-import { Agent } from "@earendil-works/pi-agent-core";
+import { randomUUID } from "node:crypto";
 //#region src/agent/child-agent-factory.ts
-init_sync_provider_auth();
-init_providers();
-init_logger();
-const log = createLogger("delegate-child");
-/**
-* Build an isolated tool factory (no extensions, no session memory hooks) and a child {@link Agent}.
-*/
+/** Leaf workers use the same execution, transcript and verification harness as foreground turns. */
 function createDelegateChildHandle(options) {
-	const allTools = options.buildChildTools({
-		workspace: options.workspace,
-		bus: options.bus,
-		model: options.model,
-		agentId: options.agentId,
-		getConfig: options.getConfig,
-		toolExecutorConfig: options.toolExecutorConfig
+	const controller = new AbortController();
+	const sessionKey = options.sessionKey ?? `agent:subagent:internal:${randomUUID()}`;
+	const runtime = options.transcriptRuntime ?? new InMemoryTranscriptRuntime({
+		runtimeId: sessionKey,
+		cwd: options.workspace
 	});
-	const allow = new Set(options.allowedToolNames);
-	const filteredTools = allTools.filter((t) => allow.has(t.name));
-	if (filteredTools.length === 0) return {
-		async run() {
-			return {
-				summary: "No tools matched the allowlist after factory registration.",
-				toolIterations: 0,
-				messages: []
-			};
-		},
-		abort() {}
-	};
-	let toolIterations = 0;
-	let aborted = false;
-	const progress = options.progressHooks;
-	const agent = new Agent({
-		initialState: {
-			systemPrompt: buildSubagentSystemPrompt({
-				goal: options.goal,
-				context: options.context,
-				workspace: options.workspace,
-				toolNames: filteredTools.map((t) => t.name),
-				responseLanguage: resolveResponseLanguageForSession(options.getConfig(), options.requesterSessionKey)
-			}),
-			model: options.model,
-			thinkingLevel: "low",
-			tools: filteredTools,
-			messages: []
-		},
-		toolExecution: "parallel",
-		streamFn: createExtensionAwareStreamFn(),
-		getApiKey: (provider) => resolveProviderApiKeySync(provider) ?? getApiKeySync(provider) ?? "",
-		beforeToolCall: async ({ toolCall, args }) => {
-			if (aborted) return {
-				block: true,
-				reason: "Sub-agent aborted."
-			};
-			if (toolIterations >= options.maxIterations) return {
-				block: true,
-				reason: `Sub-agent reached max tool iterations (${options.maxIterations}).`
-			};
-			progress?.onProgress({
-				type: "tool_start",
-				toolCallId: toolCall.id,
-				toolName: toolCall.name,
-				args: args ?? {}
-			});
-		},
-		afterToolCall: async ({ toolCall, isError }) => {
-			toolIterations += 1;
-			progress?.onProgress({
-				type: "iteration",
-				count: toolIterations,
-				max: options.maxIterations
-			});
-			progress?.onProgress({
-				type: "tool_end",
-				toolCallId: toolCall.id,
-				toolName: toolCall.name,
-				isError: Boolean(isError)
-			});
-		}
-	});
-	const userText = options.context?.trim() ? `${options.goal}\n\nAdditional context:\n${options.context.trim()}` : options.goal;
+	let started = false;
 	return {
+		abort: () => controller.abort(/* @__PURE__ */ new Error("Sub-agent cancelled")),
 		async run() {
-			toolIterations = 0;
-			aborted = false;
-			const unsub = agent.subscribe((ev) => {
-				if (progress?.mode === "full" && ev.type === "message_update") {
-					const delta = ev.assistantMessageEvent;
-					if (delta?.type === "text_delta" && typeof delta.delta === "string" && delta.delta) progress.onProgress({
-						type: "text_delta",
-						delta: delta.delta
-					});
-					if (delta?.type === "thinking_delta" && typeof delta.delta === "string" && delta.delta) progress.onProgress({
-						type: "thinking_delta",
-						delta: delta.delta
-					});
-				}
-				if (options.onTranscriptSnapshot && (ev.type === "message_end" || ev.type === "tool_execution_end")) try {
-					Promise.resolve(options.onTranscriptSnapshot(agent.state.messages)).catch((err) => {
-						const msg = err instanceof Error ? err.message : String(err);
-						log.warn({
-							err,
-							errorMessage: msg
-						}, `Failed to persist child transcript snapshot: ${msg}`);
-					});
-				} catch (err) {
-					const msg = err instanceof Error ? err.message : String(err);
-					log.warn({
-						err,
-						errorMessage: msg
-					}, `Failed to persist child transcript snapshot: ${msg}`);
+			if (started) throw new Error("A child handle can only run once");
+			started = true;
+			controller.signal.throwIfAborted();
+			const allow = new Set(options.allowedToolNames);
+			const tools = options.buildChildTools({
+				workspace: options.workspace,
+				bus: options.bus,
+				model: options.model,
+				agentId: options.agentId,
+				getConfig: options.getConfig,
+				toolExecutorConfig: options.toolExecutorConfig
+			}).filter((tool) => allow.has(tool.name));
+			const limit = Math.min(60, Math.max(1, Math.floor(options.maxIterations)));
+			let toolIterations = 0, exhausted = false, tokens = 0;
+			const policy = createAgentTurnPolicy({
+				maxTurns: limit + 1,
+				maxToolFailures: 5,
+				authorizeToolCall: async () => {
+					if (toolIterations >= limit || tokens >= 1e5) {
+						exhausted = true;
+						return {
+							block: true,
+							terminate: true,
+							reason: "Sub-agent budget exhausted."
+						};
+					}
+					toolIterations++;
 				}
 			});
+			const baseStop = policy.shouldStopAfterTurn;
+			policy.shouldStopAfterTurn = (context) => {
+				const stop = baseStop(context) || tokens >= 1e5;
+				if (stop) exhausted = true;
+				return stop;
+			};
 			try {
-				await runAgentTurnWithTimeout(agent, async () => {
-					await agent.prompt(userText);
-					await agent.waitForIdle();
-				}, resolveAgentTurnTimeoutMs(options.getConfig()));
-				const messages = agent.state.messages;
-				for (let i = messages.length - 1; i >= 0; i--) {
-					const msg = messages[i];
-					if (msg.role === "assistant") {
-						const content = msg.content;
-						if (typeof content === "string") return {
-							summary: content.trim() || "(empty assistant message)",
-							toolIterations,
-							messages
-						};
-						if (Array.isArray(content)) return {
-							summary: extractTextContent(content).trim() || "(empty assistant message)",
-							toolIterations,
-							messages
-						};
+				const result = await runXopcEmbeddedTurn({
+					sessionKey,
+					runId: randomUUID(),
+					workspaceDir: options.workspace,
+					userMessage: {
+						role: "user",
+						content: options.goal,
+						timestamp: Date.now()
+					},
+					model: options.model,
+					modelRef: `${options.model.provider}/${options.model.id}`,
+					tools,
+					transcriptRuntime: runtime,
+					turnPolicy: policy,
+					abortSignal: controller.signal,
+					timeoutMs: Math.min(options.timeoutMs ?? 3e5, 3e5),
+					thinkingLevel: "medium",
+					verifyChanges: options.verifyChanges,
+					systemPrompt: buildSubagentSystemPrompt({
+						goal: options.goal,
+						context: options.context,
+						workspace: options.workspace,
+						toolNames: tools.map((tool) => tool.name),
+						responseLanguage: resolveResponseLanguageForSession(options.getConfig(), options.requesterSessionKey)
+					}),
+					onEvent: (event) => {
+						const progress = options.progressHooks;
+						if (event.type === "message_end" && event.message.role === "assistant") {
+							const usage = event.message.usage;
+							tokens += usage?.totalTokens ?? (usage?.input ?? 0) + (usage?.output ?? 0);
+						}
+						if (event.type === "tool_execution_start") progress?.onProgress({
+							type: "tool_start",
+							toolCallId: event.toolCallId,
+							toolName: event.toolName,
+							args: event.args
+						});
+						if (event.type === "tool_execution_end") {
+							progress?.onProgress({
+								type: "tool_end",
+								toolCallId: event.toolCallId,
+								toolName: event.toolName,
+								isError: event.isError
+							});
+							progress?.onProgress({
+								type: "iteration",
+								count: toolIterations,
+								max: limit
+							});
+						}
+						if (progress?.mode === "full" && event.type === "message_update") {
+							const delta = event.assistantMessageEvent;
+							if (delta?.type === "text_delta" || delta?.type === "thinking_delta") progress.onProgress({
+								type: delta.type,
+								delta: delta.delta
+							});
+						}
 					}
-				}
-				return {
-					summary: aborted ? "Sub-agent was aborted before producing a result." : "Sub-agent completed but produced no assistant text.",
-					toolIterations,
-					messages
-				};
-			} catch (e) {
-				const msg = e instanceof Error ? e.message : String(e);
-				const m = options.model;
-				const modelId = m?.model ?? m?.id;
-				log.warn({
-					err: e,
-					errorMessage: msg,
-					goalPreview: options.goal.slice(0, 120),
-					maxIterations: options.maxIterations,
-					allowedToolCount: options.allowedToolNames.length,
-					modelId
-				}, `Delegate child run failed: ${msg}`);
+				});
+				const verification = runtime.openSessionManager(options.workspace).getBranch().findLast((entry) => entry.type === "custom" && entry.customType === "coding_verification");
+				const proof = verification?.type === "custom" ? verification.data : void 0;
+				const unverified = options.verifyChanges && proof?.changed && (!proof.evidence.some((item) => item.kind === "check" && item.status === "passed") || proof.evidence.some((item) => item.status !== "passed"));
 				return {
-					summary: `Sub-agent error: ${msg}`,
+					summary: result.lastAssistantText || result.errorMessage || (exhausted ? "Sub-agent budget exhausted." : "(no final response)"),
 					toolIterations,
-					messages: agent.state.messages
+					messages: await runtime.loadMessages(),
+					status: controller.signal.aborted ? "cancelled" : !result.ok ? "failed" : exhausted || unverified ? "partial" : "success",
+					...verification?.type === "custom" ? { verification: verification.data } : {}
 				};
 			} finally {
-				unsub?.();
+				evictEmbeddedSessionRunner(runtime.runtimeId, "leaf_worker_complete");
 			}
-		},
-		abort() {
-			aborted = true;
-			agent.abort();
 		}
 	};
 }

package/dist/src/agent/coding/index.d.ts

@@ -1 +1 @@
-export { TurnDiffTracker, type TurnDiffState, type TurnFileChange, type TurnVerificationRecord, type WorkspaceMutationKind, } from './turn-diff-tracker.js';
+export { RunVerification, type CodingVerificationEvidence } from './run-verification.js';

package/dist/src/agent/coding/index.js

@@ -1,2 +1,2 @@
-import { TurnDiffTracker } from "./turn-diff-tracker.js";
-export { TurnDiffTracker };
+import { RunVerification } from "./run-verification.js";
+export { RunVerification };

package/dist/src/agent/coding/repository-instructions.d.ts

@@ -0,0 +1,12 @@
+/** Reload scoped instructions on content changes; never follow instruction links outside the repository. */
+export declare class RepositoryInstructions {
+    private readonly root;
+    private readonly workspace;
+    private readonly seen;
+    private readonly pending;
+    acknowledge(): void;
+    private constructor();
+    static open(workspace: string): Promise<RepositoryInstructions>;
+    forTool(name: string, input: unknown): Promise<string>;
+    load(path: string, directory: boolean): Promise<string>;
+}

package/dist/src/agent/coding/repository-instructions.js

@@ -0,0 +1,76 @@
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { promisify } from "node:util";
+//#region src/agent/coding/repository-instructions.ts
+const exec$1 = promisify(execFile);
+function inside(root, path) {
+	const rel = relative(root, path);
+	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/** Reload scoped instructions on content changes; never follow instruction links outside the repository. */
+var RepositoryInstructions = class RepositoryInstructions {
+	seen = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	acknowledge() {
+		for (const [path, content] of this.pending) this.seen.set(path, content);
+		this.pending.clear();
+	}
+	constructor(root, workspace) {
+		this.root = root;
+		this.workspace = workspace;
+	}
+	static async open(workspace) {
+		let root = resolve(workspace);
+		try {
+			root = await realpath(root);
+		} catch {}
+		const canonicalWorkspace = root;
+		try {
+			root = await realpath((await exec$1("git", ["rev-parse", "--show-toplevel"], {
+				cwd: root,
+				timeout: 5e3
+			})).stdout.trim());
+		} catch {}
+		return new RepositoryInstructions(root, canonicalWorkspace);
+	}
+	async forTool(name, input) {
+		const args = input && typeof input === "object" ? input : {};
+		if (name === "apply_patch") {
+			const paths = [...String(args.patch ?? "").matchAll(/^\*\*\* (?:Add File|Update File|Delete File|Move to): (.+)$/gm)].map((match) => match[1].trim());
+			return (await Promise.all(paths.map((path) => this.load(path, false)))).filter(Boolean).join("\n\n");
+		}
+		if (["read_file", "write_file"].includes(name) && typeof args.path === "string") return this.load(args.path, false);
+		if (name === "exec_command" || name === "managed_job" && args.action === "start") return this.load(typeof args.cwd === "string" ? args.cwd : ".", true);
+		return "";
+	}
+	async load(path, directory) {
+		const target = resolve(this.workspace, path);
+		if (!inside(this.root, target)) return "";
+		const leaf = directory ? target : dirname(target);
+		const directories = [];
+		for (let current = leaf; inside(this.root, current); current = dirname(current)) {
+			directories.unshift(current);
+			if (current === this.root) break;
+		}
+		const sections = [];
+		for (const dir of directories) {
+			const file = resolve(dir, "AGENTS.md");
+			try {
+				const canonical = await realpath(file);
+				if (!inside(this.root, canonical)) throw new Error(`Instruction file escapes repository: ${file}`);
+				if ((await stat(canonical)).size > 32768) throw new Error(`Instruction file is too large; read it explicitly: ${file}`);
+				const content = await readFile(canonical, "utf8");
+				if (this.seen.get(file) === content) continue;
+				this.pending.set(file, content);
+				if (content.trim()) sections.push(`Instructions for ${dir} and its descendants (${file}):\n${content}`);
+			} catch (error) {
+				if (["ENOENT", "ENOTDIR"].includes(String(error.code))) continue;
+				throw error;
+			}
+		}
+		return sections.length ? `Repository instructions (more specific directory rules take precedence within their scope):\n\n${sections.join("\n\n")}` : "";
+	}
+};
+//#endregion
+export { RepositoryInstructions };

package/dist/src/agent/coding/run-verification.d.ts

@@ -0,0 +1,34 @@
+import type { AfterToolCallContext, AgentToolResult } from '@earendil-works/pi-agent-core';
+export interface CodingVerificationEvidence {
+    command: string;
+    kind: 'check' | 'diff-review';
+    status: 'passed' | 'failed' | 'unverified';
+    revision?: string;
+    toolCallId: string;
+    durationMs?: number;
+    logPath?: string;
+}
+export declare function toolResultFailed(result: AgentToolResult<unknown>, isError?: boolean): boolean;
+/** One run owns its evidence; transcript tool results are the durable record. */
+export declare class RunVerification {
+    private readonly snapshot;
+    private revision?;
+    private changed;
+    private readonly before;
+    private readonly evidence;
+    constructor(snapshot: () => Promise<string | undefined>);
+    static open(workspace: string): Promise<RunVerification>;
+    restore(value: unknown, includeEvidence: boolean): void;
+    beforeTool(toolCallId: string, toolName?: string): Promise<void>;
+    afterTool(context: AfterToolCallContext): Promise<{
+        result: AgentToolResult<unknown>;
+        isError: boolean;
+    }>;
+    private observeRevision;
+    pendingContext(): Promise<string>;
+    summary(): Promise<{
+        changed: boolean;
+        revision?: string;
+        evidence: CodingVerificationEvidence[];
+    }>;
+}

package/dist/src/agent/coding/run-verification.js

@@ -0,0 +1,134 @@
+import { readWorkspaceRevision } from "./workspace-revision.js";
+import { classifyVerificationCommand } from "./verification-command.js";
+//#region src/agent/coding/run-verification.ts
+const READ_ONLY_TOOLS = new Set([
+	"read_file",
+	"grep",
+	"find",
+	"list_dir",
+	"update_plan",
+	"session_status"
+]);
+function record(value) {
+	return value && typeof value === "object" ? value : {};
+}
+function toolResultFailed(result, isError = false) {
+	const details = record(result.details);
+	return isError || [
+		"failed",
+		"blocked",
+		"timed_out",
+		"cancelled",
+		"interrupted"
+	].includes(String(details.status)) || details.timedOut === true || typeof details.exitCode === "number" && details.exitCode !== 0;
+}
+/** One run owns its evidence; transcript tool results are the durable record. */
+var RunVerification = class RunVerification {
+	revision;
+	changed = false;
+	before = /* @__PURE__ */ new Map();
+	evidence = /* @__PURE__ */ new Map();
+	constructor(snapshot) {
+		this.snapshot = snapshot;
+	}
+	static async open(workspace) {
+		const run = new RunVerification(() => readWorkspaceRevision(workspace));
+		run.revision = await run.snapshot();
+		return run;
+	}
+	restore(value, includeEvidence) {
+		const checkpoint = record(value);
+		this.changed ||= checkpoint.changed === true || typeof checkpoint.revision === "string" && checkpoint.revision !== this.revision;
+		if (!includeEvidence) return;
+		for (const raw of Array.isArray(checkpoint.evidence) ? checkpoint.evidence : []) {
+			const item = record(raw);
+			if (typeof item.command !== "string" || typeof item.toolCallId !== "string" || !["check", "diff-review"].includes(String(item.kind))) continue;
+			const revision = typeof item.revision === "string" ? item.revision : void 0;
+			this.evidence.set(item.command, {
+				command: item.command,
+				toolCallId: item.toolCallId,
+				kind: item.kind,
+				revision,
+				status: revision && revision === this.revision && ["passed", "failed"].includes(String(item.status)) ? item.status : "unverified"
+			});
+		}
+	}
+	async beforeTool(toolCallId, toolName) {
+		const revision = toolName && READ_ONLY_TOOLS.has(toolName) ? this.revision : await this.snapshot();
+		this.observeRevision(revision);
+		this.before.set(toolCallId, revision);
+	}
+	async afterTool(context) {
+		const { toolCall, args, result } = context;
+		const before = this.before.get(toolCall.id);
+		this.before.delete(toolCall.id);
+		const revision = READ_ONLY_TOOLS.has(toolCall.name) ? this.revision : await this.snapshot();
+		this.observeRevision(revision);
+		const details = record(result.details);
+		const isError = toolResultFailed(result, context.isError);
+		if ((toolCall.name === "apply_patch" || toolCall.name === "write_file") && !isError) this.changed = true;
+		const command = toolCall.name === "exec_command" || toolCall.name === "managed_job" || toolCall.name === "language_diagnostics" || toolCall.name === "review_workspace" ? String(details.command ?? record(args).cmd ?? "") : "";
+		const kind = toolCall.name === "review_workspace" && details.complete === true ? "diff-review" : toolCall.name === "language_diagnostics" && details.diagnosticEngine === "typescript" ? "check" : classifyVerificationCommand(command);
+		let verification;
+		if (kind && details.status !== "running") {
+			const observedBefore = typeof details.startRevision === "string" ? details.startRevision : before;
+			const observedAfter = typeof details.endRevision === "string" ? details.endRevision : revision;
+			const completedJob = toolCall.name !== "managed_job" || !!details.startRevision && !!details.endRevision;
+			verification = {
+				command,
+				kind,
+				toolCallId: toolCall.id,
+				...typeof details.durationMs === "number" ? { durationMs: details.durationMs } : {},
+				...typeof details.logPath === "string" ? { logPath: details.logPath } : {},
+				status: isError ? "failed" : details.exitCode === 0 && completedJob && revision && revision === observedBefore && revision === observedAfter ? "passed" : "unverified",
+				...revision ? { revision } : {}
+			};
+			this.evidence.set(command, verification);
+		}
+		return {
+			isError,
+			result: {
+				...result,
+				details: {
+					...details,
+					workspaceRevision: revision ?? null,
+					workspaceChanged: this.changed,
+					...verification ? { verification } : {}
+				}
+			}
+		};
+	}
+	observeRevision(revision) {
+		if (this.revision && revision !== this.revision) this.changed = true;
+		this.revision = revision;
+	}
+	async pendingContext() {
+		this.observeRevision(await this.snapshot());
+		if (!this.changed) return "";
+		const current = [...this.evidence.values()].filter((item) => item.revision && item.revision === this.revision);
+		const checked = current.some((item) => item.kind === "check" && item.status === "passed");
+		const reviewed = current.some((item) => item.kind === "diff-review" && item.status === "passed");
+		const failed = current.filter((item) => item.kind === "check" && item.status === "failed");
+		if (checked && reviewed && failed.length === 0) return "";
+		return [
+			"Workspace changes still need verification against the current files.",
+			...!reviewed ? ["Inspect tracked and untracked changes using `review_workspace`."] : [],
+			...!checked ? ["Run the smallest meaningful check as a direct command using exec_command."] : [],
+			...failed.map((item) => `Resolve or explicitly report the failed check: ${item.command}`),
+			"If a check is unavailable or unrelated to the requested change, report what remains unverified and why. Do not claim verified completion."
+		].join("\n");
+	}
+	async summary() {
+		this.observeRevision(await this.snapshot());
+		return {
+			changed: this.changed,
+			revision: this.revision,
+			evidence: [...this.evidence.values()].map((item) => ({
+				...item,
+				status: !item.revision || item.revision !== this.revision ? "unverified" : item.status
+			}))
+		};
+	}
+};
+//#endregion
+export { RunVerification, toolResultFailed };

package/dist/src/agent/coding/verification-command.d.ts

@@ -0,0 +1,3 @@
+export type VerificationCommandKind = 'check' | 'diff-review';
+/** Recognize direct check invocations, never keywords inside arbitrary shell code. */
+export declare function classifyVerificationCommand(command: string): VerificationCommandKind | undefined;

package/dist/src/agent/coding/verification-command.js

@@ -0,0 +1,50 @@
+//#region src/agent/coding/verification-command.ts
+/** Recognize direct check invocations, never keywords inside arbitrary shell code. */
+function classifyVerificationCommand(command) {
+	if (/[\n\r;&|<>`$]/.test(command)) return void 0;
+	const tokens = command.match(/"[^"\\]*"|'[^'\\]*'|[^\s"']+/g) ?? [];
+	if (tokens.join(" ").replace(/\s/g, "") !== command.replace(/\s/g, "")) return void 0;
+	const args = tokens.map((token) => token.replace(/^(['"])(.*)\1$/, "$2"));
+	const executable = args.shift();
+	if (!executable) return void 0;
+	if ([
+		"pnpm",
+		"npm",
+		"yarn",
+		"bun"
+	].includes(executable)) {
+		while (args[0] === "-C" || args[0] === "--dir" || args[0] === "--prefix") args.splice(0, 2);
+		if (args[0] === "exec") return classifyVerificationCommand(args.slice(1).join(" "));
+		if (args[0] === "run") args.shift();
+		const script = args.shift() ?? "";
+		return /^(test|typecheck|type-check|lint|build)(:[\w-]+)*$/.test(script) && !args.some((arg) => [
+			"--help",
+			"-h",
+			"--version",
+			"-v",
+			"--list",
+			"--listTests",
+			"--dry-run",
+			"--watch"
+		].includes(arg)) ? "check" : void 0;
+	}
+	if (executable === "node" && args[0] === "--test") return args.some((arg) => /^(--help|--version|--test-only|--watch)(=|$)/.test(arg)) ? void 0 : "check";
+	if ([
+		"vitest",
+		"jest",
+		"pytest",
+		"tsc",
+		"mocha"
+	].includes(executable)) {
+		if (args.some((arg) => /^(--help|-h|--version|-v|--list|--listTests|--collect-only|--watch|-w)$/.test(arg))) return void 0;
+		if (executable === "vitest" && args[0] !== "run") return void 0;
+		return "check";
+	}
+	if (executable === "go" && args[0] === "test" || executable === "cargo" && [
+		"test",
+		"check",
+		"clippy"
+	].includes(args[0] ?? "") || executable === "python" && args[0] === "-m" && args[1] === "pytest") return args.some((arg) => /^(--help|--version|--collect-only|--no-run)$/.test(arg)) ? void 0 : "check";
+}
+//#endregion
+export { classifyVerificationCommand };

package/dist/src/agent/coding/workspace-revision.d.ts

@@ -0,0 +1,2 @@
+/** A content fingerprint, including user changes and untracked files, without changing Git state. */
+export declare function readWorkspaceRevision(workspace: string): Promise<string | undefined>;