@visorcraft/idlehands 4.1.0 → 4.2.0

package/dist/anton-DXL8jrY_.js

@@ -0,0 +1,792 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as CONFIG_DIR } from "./utils-CXzXXV2o.js";
+import path from "node:path";
+import { promisify } from "node:util";
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+
+//#region src/commands/anton.ts
+var anton_exports = /* @__PURE__ */ __exportAll({
+	antonStatus: () => antonStatus,
+	antonStop: () => antonStop,
+	formatProgressMessage: () => formatProgressMessage,
+	runAnton: () => runAnton
+});
+const ANTON_STATE_PATH = path.join(CONFIG_DIR, "anton.state.json");
+const ANTON_LOCK_PATH = path.join(CONFIG_DIR, "anton.lock");
+const execFile$1 = promisify(execFile);
+async function ensureStateDir() {
+	await fs.mkdir(CONFIG_DIR, { recursive: true });
+}
+async function readState() {
+	try {
+		return JSON.parse(await fs.readFile(ANTON_STATE_PATH, "utf8"));
+	} catch {
+		return { running: false };
+	}
+}
+async function writeState(state) {
+	await ensureStateDir();
+	await fs.writeFile(ANTON_STATE_PATH, `${JSON.stringify({
+		...state,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2)}\n`, "utf8");
+}
+async function acquireLock(force = false) {
+	await ensureStateDir();
+	try {
+		await fs.writeFile(ANTON_LOCK_PATH, JSON.stringify({
+			pid: process.pid,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}), {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	} catch {
+		if (!force) throw new Error("Anton is already running (lock held)");
+		await fs.rm(ANTON_LOCK_PATH, { force: true });
+		await fs.writeFile(ANTON_LOCK_PATH, JSON.stringify({
+			pid: process.pid,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			force: true
+		}), {
+			encoding: "utf8",
+			flag: "wx"
+		});
+	}
+}
+async function releaseLock() {
+	await fs.rm(ANTON_LOCK_PATH, { force: true });
+}
+async function shouldStop() {
+	const s = await readState();
+	return Boolean(s.stopRequested);
+}
+function parsePendingTasks(markdown) {
+	const lines = markdown.split(/\r?\n/);
+	const tasks = [];
+	for (let i = 0; i < lines.length; i++) {
+		const m = (lines[i] ?? "").match(/^(\s*)- \[ \] (.+)$/);
+		if (!m) continue;
+		tasks.push({
+			line: i + 1,
+			indent: m[1] ?? "",
+			text: (m[2] ?? "").trim()
+		});
+	}
+	return tasks;
+}
+function markTaskDone(markdown, lineNo) {
+	const lines = markdown.split(/\r?\n/);
+	const idx = lineNo - 1;
+	if (idx < 0 || idx >= lines.length) return markdown;
+	lines[idx] = (lines[idx] ?? "").replace(/^(\s*)- \[ \] /, "$1- [x] ");
+	return `${lines.join("\n")}\n`;
+}
+function buildDirectTaskPrompt(task) {
+	return [
+		"You are executing one item from a managed checklist.",
+		`Task: ${task}`,
+		"Rules:",
+		"1) Make the minimal code changes required for this task.",
+		"2) Run targeted tests for your change.",
+		"3) Return a concise completion summary."
+	].join("\n");
+}
+function buildDiscoveryPrompt(task, taskFile, planFilePath) {
+	return `You are running PRE-FLIGHT for an autonomous coding orchestrator.
+
+## RULES
+- DO NOT implement code changes. DO NOT modify source files.
+- You may ONLY write to the plan file specified below.
+- Read the codebase to understand what needs to change.
+
+## TASK
+From task file: ${taskFile}
+Task: ${task}
+
+## DECISION FLOW
+
+**If task is ALREADY COMPLETE** (you are CERTAIN it's done after checking with tools):
+→ Return ONLY: {"status":"complete","filename":""}
+
+**If task is INCOMPLETE or UNCERTAIN**:
+1. Read relevant source files to understand the current state
+2. Write a detailed implementation plan to: ${planFilePath}
+3. The plan MUST include:
+   - Task description (verbatim from above)
+   - What needs to change and why
+   - Implementation approach with specific steps
+   - Files to modify/create
+   - How to verify (test commands)
+4. Verify the file exists and is non-empty
+5. Return ONLY: {"status":"incomplete","filename":"${planFilePath}"}
+
+## OUTPUT
+Return ONLY the JSON object. No markdown fences. No explanation.`;
+}
+function buildReviewPrompt(planFilePath) {
+	return `Review this implementation plan and improve it:
+${planFilePath}
+
+Treat it as written by a junior developer. Look for:
+- Missing edge cases
+- Opportunities to reuse existing code
+- Unclear or ambiguous steps
+- Missing test scenarios
+
+Update the SAME file in-place with your improvements.
+
+After review, return ONLY:
+{"status":"ready","filename":"${planFilePath}"}
+
+Do not return status=ready unless the file exists and has content.
+Return JSON only. No markdown fences. No commentary.`;
+}
+function buildImplementationPrompt(task, planFilePath) {
+	return [
+		"You are implementing a task from a managed checklist.",
+		"A planning agent has already analyzed the codebase and written a detailed spec.",
+		"",
+		`Task: ${task}`,
+		"",
+		`Implementation plan: ${planFilePath}`,
+		"",
+		"Rules:",
+		"1) Read the plan file FIRST — it contains the implementation approach.",
+		"2) Follow the plan precisely. Make the code changes specified.",
+		"3) Run the verification steps from the plan.",
+		"4) Return a concise completion summary.",
+		"",
+		"Do not deviate from the plan unless you find a clear error in it."
+	].join("\n");
+}
+function formatDuration(ms) {
+	const seconds = Math.floor(ms / 1e3);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const secs = seconds % 60;
+	if (minutes < 60) return `${minutes}m ${secs}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function formatProgressMessage(event) {
+	switch (event.phase) {
+		case "start": return `🤚 **Anton activated**\n📄 Task file: \`${path.basename(event.taskFile)}\`\n📋 ${event.totalTasks} task${event.totalTasks === 1 ? "" : "s"} pending`;
+		case "task_start": return `\n🔪 **Task ${event.index}/${event.total}**: ${event.task}`;
+		case "discovery_start": return `🔎 Discovery: analyzing codebase for task ${event.index}/${event.total}...`;
+		case "discovery_complete": return `📝 Plan written: \`${path.basename(event.planFile)}\``;
+		case "discovery_failed": return `⚠️ Discovery failed: ${event.error}\n└ Falling back to direct execution`;
+		case "discovery_already_complete": return `✅ Discovery says task already complete — skipping implementation`;
+		case "review_start": return `🧪 Reviewing plan: \`${path.basename(event.planFile)}\`...`;
+		case "review_complete": return `✅ Plan reviewed and refined`;
+		case "review_failed": return `⚠️ Review failed: ${event.error}\n└ Proceeding with unreviewed plan`;
+		case "implementation_start": return event.planFile ? `🛠️ Implementation: following spec \`${path.basename(event.planFile)}\`` : `🛠️ Implementation: direct execution`;
+		case "task_agent_spawned": return `🤖 Agent spawned (session: \`${event.sessionId}\`)`;
+		case "task_complete": return `✅ **Task ${event.index}/${event.total} complete**: ${event.task}`;
+		case "task_failed": return `❌ **Task ${event.index}/${event.total} failed**: ${event.task}\n└ ${event.error}`;
+		case "task_skipped": return `⏭️ **Task ${event.index}/${event.total} skipped**: ${event.task}\n└ ${event.reason}`;
+		case "stopped": return `🛑 **Anton stopped** (${event.completedSoFar}/${event.total} completed before stop)`;
+		case "finish": return [
+			`\n🏁 **Anton finished**`,
+			`✅ Completed: ${event.completed}/${event.total}`,
+			event.skipped > 0 ? `⏭️ Skipped: ${event.skipped}` : null,
+			`⏱️ Duration: ${formatDuration(event.durationMs)}`
+		].filter(Boolean).join("\n");
+	}
+}
+async function antonStatus(runtime) {
+	const s = await readState();
+	if (!s.running) {
+		runtime.log("Anton is idle.");
+		if (s.lastSummary) runtime.log(s.lastSummary);
+		return;
+	}
+	runtime.log(`Anton running: ${s.completed ?? 0}/${s.total ?? 0} complete` + (s.taskFile ? ` | file=${s.taskFile}` : "") + (typeof s.currentIndex === "number" ? ` | current=${s.currentIndex + 1}` : ""));
+}
+async function antonStop(runtime) {
+	const s = await readState();
+	if (!s.running) {
+		runtime.log("Anton is not running.");
+		return;
+	}
+	await writeState({
+		...s,
+		stopRequested: true
+	});
+	runtime.log("Anton stop requested. It will stop after current task.");
+}
+/** Load Anton config from the IdleHands config file. */
+async function loadAntonConfig() {
+	try {
+		const { loadConfig } = await import("./model-selection-0dGxYGp8.js").then((n) => n.Mt);
+		return loadConfig().anton ?? {};
+	} catch {
+		return {};
+	}
+}
+async function runAgentTask(args) {
+	const { agentCliCommand } = await import("./agent-via-gateway-oMn0WfUq.js").then((n) => n.n);
+	const extraSystemPrompt = args.workspaceDir ? `Your working directory is: ${args.workspaceDir}\nAll file paths are relative to this directory. Use this as your cwd for all operations.` : void 0;
+	const result = await agentCliCommand({
+		message: args.message,
+		agent: args.agent,
+		to: args.to,
+		sessionId: args.sessionId,
+		timeout: args.timeout,
+		json: true,
+		deliver: false,
+		extraSystemPrompt,
+		workspaceDir: args.workspaceDir
+	}, args.runtime, args.deps);
+	return { text: (result && typeof result === "object" && "result" in result ? result.result?.payloads ?? [] : []).map((p) => typeof p?.text === "string" ? p.text.trim() : "").filter(Boolean).join("\n\n").trim() };
+}
+function makePlanFilePath(planDir, taskIndex) {
+	return path.join(planDir, `task-${taskIndex}-${Date.now()}.md`);
+}
+async function ensurePlanDir(planDir) {
+	await fs.mkdir(planDir, { recursive: true });
+}
+function looksLikeStatusJsonOnly(text) {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return false;
+	try {
+		const parsed = JSON.parse(trimmed);
+		const keys = Object.keys(parsed).toSorted();
+		return keys.length <= 3 && keys.includes("status") && keys.includes("filename");
+	} catch {
+		return false;
+	}
+}
+function isUsefulPlanText(text) {
+	const trimmed = text.trim();
+	if (trimmed.length < 120) return false;
+	if (looksLikeStatusJsonOnly(trimmed)) return false;
+	return /^#\s+/m.test(trimmed) || /\b(Implementation approach|What needs to change|Files to modify|How to verify)\b/i.test(trimmed);
+}
+async function isPlanFileValid(filePath) {
+	try {
+		const stat = await fs.stat(filePath);
+		if (!stat.isFile() || stat.size < 20) return false;
+		return isUsefulPlanText(await fs.readFile(filePath, "utf8"));
+	} catch {
+		return false;
+	}
+}
+async function getGitChangedFileCount(cwd, ignorePaths = []) {
+	try {
+		const { stdout } = await execFile$1("git", ["status", "--porcelain"], { cwd });
+		const ignores = ignorePaths.map((p) => p.replace(/\\/g, "/").replace(/^\.\//, "")).filter(Boolean);
+		return stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+			const raw = line.slice(3).trim();
+			return (raw.includes(" -> ") ? raw.split(" -> ").at(-1) ?? raw : raw).replace(/\\/g, "/").replace(/^\.\//, "");
+		}).filter((file) => {
+			if (!file) return false;
+			if (file.startsWith(".agents/tasks/")) return false;
+			return !ignores.some((ignore) => file === ignore || file.startsWith(`${ignore}/`));
+		}).length;
+	} catch {
+		return null;
+	}
+}
+function extractJsonObject(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const tryParse = (candidate) => {
+		try {
+			const parsed = JSON.parse(candidate);
+			if (!parsed || typeof parsed !== "object") return null;
+			return parsed;
+		} catch {
+			return null;
+		}
+	};
+	const direct = tryParse(trimmed);
+	if (direct) return direct;
+	const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+	if (fencedMatch?.[1]) {
+		const fenced = tryParse(fencedMatch[1].trim());
+		if (fenced) return fenced;
+	}
+	const first = trimmed.indexOf("{");
+	const last = trimmed.lastIndexOf("}");
+	if (first >= 0 && last > first) {
+		const sliced = tryParse(trimmed.slice(first, last + 1));
+		if (sliced) return sliced;
+	}
+	return null;
+}
+function extractPlanMarkdownFromText(text) {
+	const candidate = text.match(/```(?:markdown|md)?\s*([\s\S]*?)```/i)?.[1]?.trim() ?? text.trim();
+	if (!isUsefulPlanText(candidate)) return;
+	return candidate;
+}
+function normalizeDiscoveryFilename(filename, expectedPlanFile) {
+	const trimmed = filename?.trim();
+	if (!trimmed) return expectedPlanFile;
+	return path.resolve(trimmed);
+}
+function buildDiscoveryRepairPrompt(task, taskFile, planFilePath) {
+	return `RETRY: your previous preflight response did not produce a valid plan file.
+
+You MUST complete these steps exactly:
+1) Write the implementation plan to: ${planFilePath}
+2) Verify the file exists and is non-empty
+3) Return ONLY strict JSON: {"status":"incomplete","filename":"${planFilePath}"}
+
+If task is already complete, return ONLY: {"status":"complete","filename":""}
+
+Do not include THOUGHT, markdown fences, or extra commentary.
+Task file: ${taskFile}
+Task: ${task}`;
+}
+async function tryPersistPlanFallback(params) {
+	const planText = (((typeof params.parsed?.planMarkdown === "string" ? params.parsed.planMarkdown : void 0) ?? (typeof params.parsed?.plan === "string" ? params.parsed.plan : void 0))?.trim() || extractPlanMarkdownFromText(params.rawText) || "").trim();
+	if (!isUsefulPlanText(planText)) return false;
+	await fs.writeFile(params.planFile, `${planText}\n`, "utf8");
+	return await isPlanFileValid(params.planFile);
+}
+async function writeDeterministicPlanFallback(params) {
+	const plan = `# Task\n\n${params.taskText}\n\n## What needs to change\n- Implement the task exactly as described in the checklist item.\n- Keep changes scoped to files directly related to this task.\n\n## Implementation approach\n1. Inspect existing CI/workflow/config files relevant to this task.\n2. Apply minimal edits needed to satisfy the task requirements.\n3. Keep behavior/style consistent with adjacent repository conventions.\n\n## Files to modify\n- Determine from ${params.taskFile} and related source/config files.\n\n## Verification\n- Run targeted tests for touched areas.\n- Run repository checks required by this project (for example: pnpm test / pnpm check) as appropriate.\n- Confirm git diff contains only task-relevant changes.\n`;
+	await fs.writeFile(params.planFile, plan, "utf8");
+	return await isPlanFileValid(params.planFile);
+}
+async function runDiscoveryPhase(args) {
+	const planFile = makePlanFilePath(args.planDir, args.taskNum);
+	await ensurePlanDir(args.planDir);
+	await args.notify({
+		phase: "discovery_start",
+		index: args.taskNum,
+		total: args.total,
+		task: args.task.text
+	});
+	for (let attempt = 0; attempt <= args.maxRetries; attempt++) {
+		const sessionId = `anton-discovery-${Date.now()}-${args.taskNum}-${attempt}`;
+		try {
+			await args.notify({
+				phase: "task_agent_spawned",
+				index: args.taskNum,
+				total: args.total,
+				task: `Discovery (attempt ${attempt + 1})`,
+				sessionId
+			});
+			const firstPass = await runAgentTask({
+				message: buildDiscoveryPrompt(args.task.text, args.taskFile, planFile),
+				sessionId,
+				timeout: args.timeout,
+				agent: args.agent,
+				to: args.to,
+				runtime: args.runtime,
+				deps: args.deps,
+				workspaceDir: args.workspaceDir
+			});
+			const firstParsed = extractJsonObject(firstPass.text);
+			const declaredPlanFile = normalizeDiscoveryFilename(firstParsed?.filename, planFile);
+			if (await isPlanFileValid(planFile)) {
+				await args.notify({
+					phase: "discovery_complete",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					planFile
+				});
+				return {
+					status: "plan_ready",
+					planFile
+				};
+			}
+			if (declaredPlanFile !== planFile && await isPlanFileValid(declaredPlanFile)) {
+				await args.notify({
+					phase: "discovery_complete",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					planFile: declaredPlanFile
+				});
+				return {
+					status: "plan_ready",
+					planFile: declaredPlanFile
+				};
+			}
+			if ((firstParsed?.status ?? "").toLowerCase() === "incomplete") {
+				if (await tryPersistPlanFallback({
+					planFile: declaredPlanFile,
+					parsed: firstParsed,
+					rawText: firstPass.text
+				}) || await writeDeterministicPlanFallback({
+					planFile: declaredPlanFile,
+					taskText: args.task.text,
+					taskFile: args.taskFile
+				})) {
+					await args.notify({
+						phase: "discovery_complete",
+						index: args.taskNum,
+						total: args.total,
+						task: args.task.text,
+						planFile: declaredPlanFile
+					});
+					return {
+						status: "plan_ready",
+						planFile: declaredPlanFile
+					};
+				}
+			}
+			const repairSessionId = `anton-discovery-repair-${Date.now()}-${args.taskNum}-${attempt}`;
+			await args.notify({
+				phase: "task_agent_spawned",
+				index: args.taskNum,
+				total: args.total,
+				task: `Discovery repair (attempt ${attempt + 1})`,
+				sessionId: repairSessionId
+			});
+			const repairPass = await runAgentTask({
+				message: buildDiscoveryRepairPrompt(args.task.text, args.taskFile, declaredPlanFile),
+				sessionId: repairSessionId,
+				timeout: args.timeout,
+				agent: args.agent,
+				to: args.to,
+				runtime: args.runtime,
+				deps: args.deps,
+				workspaceDir: args.workspaceDir
+			});
+			const repairParsed = extractJsonObject(repairPass.text);
+			if (await isPlanFileValid(declaredPlanFile)) {
+				await args.notify({
+					phase: "discovery_complete",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					planFile: declaredPlanFile
+				});
+				return {
+					status: "plan_ready",
+					planFile: declaredPlanFile
+				};
+			}
+			const repairPlanFile = normalizeDiscoveryFilename(repairParsed?.filename, declaredPlanFile);
+			if (await isPlanFileValid(repairPlanFile) || await tryPersistPlanFallback({
+				planFile: repairPlanFile,
+				parsed: repairParsed,
+				rawText: repairPass.text
+			}) || (repairParsed?.status ?? "").toLowerCase() === "incomplete" && await writeDeterministicPlanFallback({
+				planFile: repairPlanFile,
+				taskText: args.task.text,
+				taskFile: args.taskFile
+			})) {
+				await args.notify({
+					phase: "discovery_complete",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					planFile: repairPlanFile
+				});
+				return {
+					status: "plan_ready",
+					planFile: repairPlanFile
+				};
+			}
+			if (attempt === args.maxRetries) {
+				const reason = "Discovery did not produce a valid plan file after primary + repair passes";
+				await args.notify({
+					phase: "discovery_failed",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					error: reason
+				});
+				return {
+					status: "failed",
+					error: reason
+				};
+			}
+		} catch (err) {
+			const errorMsg = err instanceof Error ? err.message : String(err);
+			if (attempt === args.maxRetries) {
+				await args.notify({
+					phase: "discovery_failed",
+					index: args.taskNum,
+					total: args.total,
+					task: args.task.text,
+					error: errorMsg
+				});
+				return {
+					status: "failed",
+					error: errorMsg
+				};
+			}
+		}
+	}
+	return {
+		status: "failed",
+		error: "Discovery exhausted retries"
+	};
+}
+async function runReviewPhase(args) {
+	await args.notify({
+		phase: "review_start",
+		index: args.taskNum,
+		total: args.total,
+		task: args.task.text,
+		planFile: args.planFile
+	});
+	const sessionId = `anton-review-${Date.now()}-${args.taskNum}`;
+	try {
+		await args.notify({
+			phase: "task_agent_spawned",
+			index: args.taskNum,
+			total: args.total,
+			task: "Requirements review",
+			sessionId
+		});
+		await runAgentTask({
+			message: buildReviewPrompt(args.planFile),
+			sessionId,
+			timeout: args.timeout,
+			agent: args.agent,
+			to: args.to,
+			runtime: args.runtime,
+			deps: args.deps,
+			workspaceDir: args.workspaceDir
+		});
+		await args.notify({
+			phase: "review_complete",
+			index: args.taskNum,
+			total: args.total,
+			task: args.task.text,
+			planFile: args.planFile
+		});
+		return { success: true };
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		await args.notify({
+			phase: "review_failed",
+			index: args.taskNum,
+			total: args.total,
+			task: args.task.text,
+			error: errorMsg
+		});
+		return {
+			success: false,
+			error: errorMsg
+		};
+	}
+}
+async function runAnton(args) {
+	const filePath = path.resolve(args.taskFile);
+	const pending = parsePendingTasks(await fs.readFile(filePath, "utf8"));
+	const notify = args.onProgress ?? (async () => {});
+	if (args.dryRun) {
+		args.runtime.log(`Dry run: ${pending.length} pending task(s)`);
+		for (const t of pending) args.runtime.log(`- [ ] ${t.text}`);
+		return;
+	}
+	if (pending.length === 0) {
+		args.runtime.log("No pending tasks.");
+		await notify({
+			phase: "finish",
+			completed: 0,
+			skipped: 0,
+			total: 0,
+			durationMs: 0
+		});
+		return;
+	}
+	const antonCfg = await loadAntonConfig();
+	const mode = args.mode ?? antonCfg.mode ?? "direct";
+	const requirementsReview = antonCfg.requirementsReview ?? false;
+	const taskTimeout = antonCfg.taskTimeoutSec ?? 1200;
+	const discoveryTimeout = antonCfg.discoveryTimeoutSec ?? taskTimeout;
+	const reviewTimeout = antonCfg.reviewTimeoutSec ?? taskTimeout;
+	const preflightMaxRetries = antonCfg.preflightMaxRetries ?? 2;
+	const planDir = antonCfg.planDir ? path.resolve(antonCfg.planDir) : path.resolve(path.dirname(filePath), ".agents", "tasks");
+	const { loadConfig } = await import("./model-selection-0dGxYGp8.js").then((n) => n.Mt);
+	const cfg = loadConfig();
+	const defaultTimeout = String(Number.isFinite(args.timeoutSec) && (args.timeoutSec ?? 0) > 0 ? args.timeoutSec : cfg.agents?.defaults?.timeoutSeconds ?? taskTimeout);
+	await acquireLock(Boolean(args.force));
+	const startedAt = Date.now();
+	await writeState({
+		running: true,
+		taskFile: filePath,
+		startedAt: new Date(startedAt).toISOString(),
+		currentIndex: 0,
+		total: pending.length,
+		completed: 0,
+		skipped: 0,
+		stopRequested: false
+	});
+	await notify({
+		phase: "start",
+		taskFile: filePath,
+		totalTasks: pending.length
+	});
+	args.runtime.log(`[Anton] Mode: ${mode}${mode === "preflight" ? requirementsReview ? " (with review)" : " (discovery → implementation)" : ""}`);
+	let completed = 0;
+	let skipped = 0;
+	try {
+		for (let i = 0; i < pending.length; i++) {
+			if (await shouldStop()) {
+				args.runtime.log("Anton stop acknowledged.");
+				await notify({
+					phase: "stopped",
+					completedSoFar: completed,
+					total: pending.length
+				});
+				break;
+			}
+			const task = pending[i];
+			if (!task) continue;
+			const taskNum = i + 1;
+			await writeState({
+				running: true,
+				taskFile: filePath,
+				startedAt: new Date(startedAt).toISOString(),
+				currentIndex: i,
+				total: pending.length,
+				completed,
+				skipped,
+				stopRequested: false
+			});
+			args.runtime.log(`\n[Anton] Task ${taskNum}/${pending.length}: ${task.text}`);
+			await notify({
+				phase: "task_start",
+				index: taskNum,
+				total: pending.length,
+				task: task.text
+			});
+			try {
+				let planFile;
+				const gitCwdForBaseline = args.workspaceDir ? path.resolve(args.workspaceDir) : path.dirname(filePath);
+				const taskFileRelForBaseline = path.relative(gitCwdForBaseline, filePath).replace(/\\/g, "/");
+				const changedBeforeTask = await getGitChangedFileCount(gitCwdForBaseline, taskFileRelForBaseline.startsWith("..") ? [] : [taskFileRelForBaseline]);
+				if (mode === "preflight") {
+					const discoveryResult = await runDiscoveryPhase({
+						task,
+						taskNum,
+						total: pending.length,
+						taskFile: filePath,
+						planDir,
+						timeout: String(discoveryTimeout),
+						maxRetries: preflightMaxRetries,
+						agent: args.agent,
+						to: args.to,
+						runtime: args.runtime,
+						deps: args.deps,
+						notify,
+						workspaceDir: args.workspaceDir
+					});
+					if (discoveryResult.status === "complete") {
+						await notify({
+							phase: "discovery_already_complete",
+							index: taskNum,
+							total: pending.length,
+							task: task.text
+						});
+						const updated = markTaskDone(await fs.readFile(filePath, "utf8"), task.line);
+						await fs.writeFile(filePath, updated, "utf8");
+						completed += 1;
+						await notify({
+							phase: "task_complete",
+							index: taskNum,
+							total: pending.length,
+							task: task.text
+						});
+						continue;
+					}
+					if (discoveryResult.status === "plan_ready" && discoveryResult.planFile) {
+						planFile = discoveryResult.planFile;
+						if (requirementsReview) await runReviewPhase({
+							task,
+							taskNum,
+							total: pending.length,
+							planFile,
+							timeout: String(reviewTimeout),
+							agent: args.agent,
+							to: args.to,
+							runtime: args.runtime,
+							deps: args.deps,
+							notify,
+							workspaceDir: args.workspaceDir
+						});
+					}
+					if (!planFile) throw new Error("Preflight discovery did not produce a verified plan file; refusing direct implementation fallback");
+				}
+				await notify({
+					phase: "implementation_start",
+					index: taskNum,
+					total: pending.length,
+					task: task.text,
+					planFile
+				});
+				const implSessionId = `anton-impl-${Date.now()}-${taskNum}`;
+				await notify({
+					phase: "task_agent_spawned",
+					index: taskNum,
+					total: pending.length,
+					task: task.text,
+					sessionId: implSessionId
+				});
+				const implPrompt = planFile ? buildImplementationPrompt(task.text, planFile) : buildDirectTaskPrompt(task.text);
+				const gitCwd = args.workspaceDir ? path.resolve(args.workspaceDir) : path.dirname(filePath);
+				const taskFileRel = path.relative(gitCwd, filePath).replace(/\\/g, "/");
+				const changeIgnores = taskFileRel.startsWith("..") ? [] : [taskFileRel];
+				await runAgentTask({
+					message: implPrompt,
+					sessionId: implSessionId,
+					timeout: defaultTimeout,
+					agent: args.agent,
+					to: args.to,
+					runtime: args.runtime,
+					deps: args.deps,
+					workspaceDir: args.workspaceDir
+				});
+				const changedAfter = await getGitChangedFileCount(gitCwd, changeIgnores);
+				if (mode === "preflight" && changedBeforeTask !== null && changedAfter !== null && changedAfter <= changedBeforeTask) throw new Error("Implementation made no repository changes; refusing to mark task complete");
+				const updated = markTaskDone(await fs.readFile(filePath, "utf8"), task.line);
+				await fs.writeFile(filePath, updated, "utf8");
+				completed += 1;
+				await notify({
+					phase: "task_complete",
+					index: taskNum,
+					total: pending.length,
+					task: task.text
+				});
+			} catch (err) {
+				skipped += 1;
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				args.runtime.error(`[Anton] Task failed and was skipped: ${task.text}`);
+				args.runtime.error(errorMsg);
+				await notify({
+					phase: "task_failed",
+					index: taskNum,
+					total: pending.length,
+					task: task.text,
+					error: errorMsg
+				});
+			}
+		}
+		const durationMs = Date.now() - startedAt;
+		const summary = `Anton finished: completed=${completed}, skipped=${skipped}, total=${pending.length}, duration=${formatDuration(durationMs)}`;
+		await writeState({
+			running: false,
+			taskFile: filePath,
+			startedAt: new Date(startedAt).toISOString(),
+			total: pending.length,
+			completed,
+			skipped,
+			lastSummary: summary,
+			stopRequested: false
+		});
+		args.runtime.log(`\n${summary}`);
+		await notify({
+			phase: "finish",
+			completed,
+			skipped,
+			total: pending.length,
+			durationMs
+		});
+	} finally {
+		await releaseLock();
+	}
+}
+
+//#endregion
+export { runAnton as i, antonStop as n, anton_exports as r, antonStatus as t };