prompts-gpt 0.2.8

package/dist/sweep.js

@@ -0,0 +1,765 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { mkdir, open as fsOpen, readFile, writeFile, readdir, unlink, stat, rm } from "node:fs/promises";
+import { spawnSync } from "node:child_process";
+import { loadRunConfig, detectProviders, normalizeOrchestrationAgent, resolveRunProvider, resolveTimeoutSeconds, resolveDefaultPromptFile, assertPromptFitsLaunch, executeProviderCommandWithRetries, captureWorktreeStatus, buildWorktreeDelta, appendFileSafe, aggregateTokenUsage, DEFAULT_MODELS, extractTokenUsageFromLog, } from "./runtime.js";
+import { getAttribution } from "./index.js";
+const LOCK_FILE_NAME = ".sweep.lock";
+const LOCK_STALE_MS = 6 * 60 * 60 * 1000; // 6 hours
+const DEFAULT_ITERATIONS = 1;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_ITERATION_TIMEOUT = 5400;
+const DEFAULT_SUMMARY_LINES = 40;
+const DEFAULT_MAX_RUN_DIRS = 20;
+const GIT_SAFETY_RULE = "\nNEVER run `git stash`, `git reset`, `git checkout`, `git commit`, `git push`, or any destructive git command.\n";
+// ── Lock management ──────────────────────────────────────────────────────────
+export async function acquireSweepLock(cwd) {
+    const lockPath = path.resolve(cwd, LOCK_FILE_NAME);
+    if (existsSync(lockPath)) {
+        try {
+            const content = JSON.parse(await readFile(lockPath, "utf8"));
+            const lockAge = Date.now() - new Date(content.startedAt ?? 0).getTime();
+            const pidAlive = typeof content.pid === "number" && content.pid > 0
+                ? isProcessAlive(content.pid)
+                : false;
+            if (pidAlive && lockAge < LOCK_STALE_MS) {
+                throw new Error(`Another sweep is running (PID ${content.pid}, started ${content.startedAt}).\n` +
+                    `If the process is dead, remove the lock manually:\n` +
+                    `  rm ${lockPath}`);
+            }
+            if (lockAge >= LOCK_STALE_MS) {
+                // Stale lock — process likely crashed without cleanup
+            }
+            try {
+                await unlink(lockPath);
+            }
+            catch { }
+        }
+        catch (error) {
+            if (error.message.includes("Another sweep"))
+                throw error;
+        }
+    }
+    const payload = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        cwd,
+    };
+    const lockWriteController = new AbortController();
+    const lockTimeout = setTimeout(() => lockWriteController.abort(), 10_000);
+    lockTimeout.unref?.();
+    try {
+        await writeFile(lockPath, JSON.stringify(payload, null, 2), { mode: 0o644, signal: lockWriteController.signal });
+        if (!existsSync(lockPath)) {
+            throw new Error(`Failed to create sweep lock file: ${lockPath}. Filesystem may be full.`);
+        }
+    }
+    finally {
+        clearTimeout(lockTimeout);
+    }
+    return lockPath;
+}
+export async function releaseSweepLock(cwd) {
+    const lockPath = path.resolve(cwd, LOCK_FILE_NAME);
+    try {
+        await unlink(lockPath);
+    }
+    catch {
+        // Lock already removed
+    }
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EPERM")
+            return true;
+        if (code === "ESRCH")
+            return false;
+        if (process.platform === "win32") {
+            try {
+                const result = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH"], { encoding: "utf8", timeout: 3000, windowsHide: true });
+                return result.stdout?.includes(String(pid)) ?? false;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+}
+// ── Stream-JSON parsing ──────────────────────────────────────────────────────
+export function parseStreamJsonToolCounts(logContent) {
+    const counts = { reads: 0, writes: 0, shells: 0, searches: 0, webSearches: 0, total: 0 };
+    if (!logContent || !logContent.includes('"tool_use"'))
+        return counts;
+    for (const line of logContent.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{") || !trimmed.includes("tool_use"))
+            continue;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || parsed.type !== "tool_use")
+            continue;
+        const tool = (parsed.tool ?? parsed.toolName ?? "").toLowerCase();
+        if (tool.includes("read") || tool === "file_read")
+            counts.reads++;
+        else if (tool.includes("write") || tool.includes("edit") || tool === "file_write" || tool === "str_replace")
+            counts.writes++;
+        else if (tool.includes("shell") || tool === "bash" || tool === "command")
+            counts.shells++;
+        else if (tool.includes("grep") || tool.includes("glob") || tool.includes("search") || tool === "file_search") {
+            if (tool.includes("web"))
+                counts.webSearches++;
+            else
+                counts.searches++;
+        }
+        else if (tool.includes("web"))
+            counts.webSearches++;
+        counts.total++;
+    }
+    return counts;
+}
+export function streamJsonHasResult(logContent) {
+    for (const line of logContent.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === "result")
+                return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+// ── Summary extraction ───────────────────────────────────────────────────────
+export function extractIterationSummary(logContent, maxLines) {
+    const lines = [];
+    for (const rawLine of logContent.split("\n")) {
+        const trimmed = rawLine.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === "assistant" || parsed.type === "text") {
+                const text = parsed.content ?? parsed.message ?? "";
+                if (text.trim()) {
+                    lines.push(...text.split("\n"));
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (lines.length >= maxLines * 2)
+            break;
+    }
+    return lines.slice(0, maxLines);
+}
+// ── Prompt building ──────────────────────────────────────────────────────────
+export function buildIterationPrompt(basePrompt, iteration, totalIterations, previousSummary, config) {
+    const parts = [];
+    if (totalIterations > 1) {
+        parts.push(`[Iteration ${iteration}/${totalIterations}]`);
+    }
+    if (config.phase) {
+        parts.push(`[Phase: ${config.phase}]`);
+    }
+    if (parts.length > 0)
+        parts.push("");
+    parts.push(basePrompt);
+    if (config.disallowDestructiveGit) {
+        parts.push(GIT_SAFETY_RULE);
+    }
+    if (previousSummary && previousSummary.length > 0) {
+        parts.push("");
+        parts.push("## Previous iteration summary");
+        parts.push("");
+        parts.push("The previous iteration completed the following work. Continue from where it left off — do NOT repeat already-completed items:");
+        parts.push("");
+        parts.push(previousSummary.join("\n"));
+    }
+    return parts.join("\n");
+}
+export async function runPreFlight(input) {
+    const errors = [];
+    const warnings = [];
+    if (!input.providerHealth.available) {
+        errors.push(`Provider ${input.provider} is not available. Install CLI or set PATH.`);
+    }
+    let promptSizeBytes = 0;
+    if (existsSync(input.promptFile)) {
+        const promptStat = await stat(input.promptFile);
+        promptSizeBytes = promptStat.size;
+        if (promptSizeBytes === 0) {
+            errors.push(`Prompt file is empty: ${input.promptFile}`);
+        }
+    }
+    else {
+        errors.push(`Prompt file not found: ${input.promptFile}`);
+    }
+    const gitBranchResult = spawnSync("git", ["-C", input.cwd, "branch", "--show-current"], { encoding: "utf8", timeout: 10_000 });
+    const gitBranch = gitBranchResult.stdout?.trim() ?? "unknown";
+    const gitStatusResult = spawnSync("git", ["-C", input.cwd, "status", "--porcelain=v1", "-uall"], { encoding: "utf8", timeout: 30_000 });
+    const gitDirtyFiles = (gitStatusResult.stdout?.trim().split("\n").filter(Boolean) ?? []).length;
+    let diskFreeMb = 0;
+    try {
+        if (process.platform === "win32") {
+            const driveLetter = input.cwd.charAt(0).toUpperCase();
+            const psResult = spawnSync("powershell", ["-NoProfile", "-Command", `(Get-PSDrive ${driveLetter}).Free`], { encoding: "utf8", timeout: 10_000, windowsHide: true });
+            const freeBytes = parseInt((psResult.stdout ?? "").trim(), 10);
+            if (Number.isFinite(freeBytes) && freeBytes > 0) {
+                diskFreeMb = Math.floor(freeBytes / (1024 * 1024));
+            }
+            else {
+                const wmicResult = spawnSync("wmic", ["logicaldisk", "where", `DeviceID='${driveLetter}:'`, "get", "FreeSpace", "/value"], { encoding: "utf8", timeout: 10_000, windowsHide: true });
+                const match = wmicResult.stdout?.match(/FreeSpace=(\d+)/);
+                diskFreeMb = match ? Math.floor(parseInt(match[1], 10) / (1024 * 1024)) : 0;
+            }
+        }
+        else {
+            let dfResult = spawnSync("df", ["-m", input.cwd], { encoding: "utf8", timeout: 10_000, windowsHide: true });
+            if (dfResult.status !== 0) {
+                dfResult = spawnSync("df", ["-k", input.cwd], { encoding: "utf8", timeout: 10_000, windowsHide: true });
+                const dfLine = dfResult.stdout?.split("\n")[1] ?? "";
+                const dfParts = dfLine.trim().split(/\s+/);
+                diskFreeMb = Math.floor((parseInt(dfParts[3] ?? "0", 10) || 0) / 1024);
+            }
+            else {
+                const dfLine = dfResult.stdout?.split("\n")[1] ?? "";
+                const dfParts = dfLine.trim().split(/\s+/);
+                diskFreeMb = parseInt(dfParts[3] ?? "0", 10) || 0;
+            }
+        }
+        if (diskFreeMb > 0 && diskFreeMb < 500) {
+            warnings.push(`Low disk space: ${diskFreeMb}MB free`);
+        }
+    }
+    catch {
+        warnings.push("Could not determine disk space");
+    }
+    if (input.iterations < 1 || input.iterations > 50) {
+        errors.push(`Iterations must be between 1 and 50, got ${input.iterations}`);
+    }
+    return {
+        cwd: input.cwd,
+        provider: input.provider,
+        providerBin: input.providerHealth.bin,
+        providerAvailable: input.providerHealth.available,
+        model: input.model,
+        nodeVersion: process.version,
+        gitBranch,
+        gitDirtyFiles,
+        diskFreeMb,
+        promptFile: input.promptFile,
+        promptSizeBytes,
+        iterations: input.iterations,
+        iterationTimeoutSeconds: input.iterationTimeoutSeconds,
+        maxRetries: input.maxRetries,
+        disallowDestructiveGit: input.config.safety.disallowDestructiveGit,
+        errors,
+        warnings,
+    };
+}
+// ── Run directory rotation ───────────────────────────────────────────────────
+async function rotateRunDirs(artifactsDir, maxDirs) {
+    if (!existsSync(artifactsDir))
+        return;
+    if (maxDirs < 1)
+        return;
+    try {
+        const resolvedArtifactsDir = path.resolve(artifactsDir);
+        const entries = await readdir(resolvedArtifactsDir, { withFileTypes: true });
+        const dirs = entries
+            .filter((e) => e.isDirectory())
+            .map((e) => {
+            const fullPath = path.join(resolvedArtifactsDir, e.name);
+            return { name: e.name, path: fullPath };
+        })
+            .filter((d) => {
+            const normalized = path.resolve(d.path);
+            return normalized.startsWith(resolvedArtifactsDir + path.sep) && normalized !== resolvedArtifactsDir;
+        });
+        if (dirs.length <= maxDirs)
+            return;
+        const withStats = await Promise.all(dirs.map(async (d) => {
+            const s = await stat(d.path).catch(() => null);
+            return { ...d, mtime: s?.mtimeMs ?? 0 };
+        }));
+        withStats.sort((a, b) => a.mtime - b.mtime || a.name.localeCompare(b.name));
+        const toRemove = withStats.slice(0, withStats.length - maxDirs);
+        for (const dir of toRemove) {
+            await rm(dir.path, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    catch {
+        // Best-effort rotation
+    }
+}
+// ── Manifest writer ──────────────────────────────────────────────────────────
+export async function writeSweepManifest(runDir, result, config) {
+    const attribution = getAttribution();
+    const manifest = {
+        version: 2,
+        runId: result.runId,
+        model: result.model,
+        provider: result.provider,
+        cwd: result.cwd,
+        runDir: path.relative(result.cwd, result.runDir) || ".",
+        started: result.startedAt,
+        finished: result.finishedAt,
+        totalIterations: result.totalIterations,
+        succeeded: result.succeeded,
+        failed: result.failed,
+        elapsedMs: result.totalDurationMs,
+        promptFile: result.promptFile,
+        safety: { disallowDestructiveGit: config.safety.disallowDestructiveGit },
+        attribution: {
+            generatedBy: `prompts-gpt@${attribution.version}`,
+            accountId: attribution.accountId,
+            buildFingerprint: `${attribution.version}/${attribution.accountId}`,
+        },
+        iterations: result.iterations.map((iter) => ({
+            iteration: iter.iteration,
+            status: iter.status,
+            exitCode: iter.exitCode,
+            durationMs: iter.durationMs,
+            attempts: iter.attempts,
+            toolCounts: iter.toolCounts,
+            tokenUsage: iter.tokenUsage,
+            summaryLines: iter.summary.length,
+        })),
+        tokenUsage: result.tokenUsage,
+    };
+    const manifestPath = path.join(runDir, "sweep-manifest.json");
+    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return manifestPath;
+}
+// ── Main sweep engine ────────────────────────────────────────────────────────
+export async function sweepPrompt(input) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const config = await loadRunConfig(cwd);
+    const providers = await detectProviders(cwd);
+    const agent = normalizeOrchestrationAgent(input.agent ?? config.defaultAgent);
+    const provider = resolveRunProvider(agent, providers, config.providerOrder);
+    const providerHealth = providers.find((p) => p.provider === provider);
+    if (!providerHealth || !providerHealth.available) {
+        throw new Error(`Provider ${provider} is not available. ` +
+            `Run \`prompts-gpt doctor\` to check provider installation, ` +
+            `or use \`--agent <provider>\` to select a different provider.`);
+    }
+    const model = input.model?.trim() || config.modelOverrides[provider]?.trim() || DEFAULT_MODELS[provider] || "auto";
+    const promptFile = input.promptFile
+        ? path.resolve(cwd, input.promptFile)
+        : await resolveDefaultPromptFile(cwd, config);
+    const rawIterations = input.iterations ?? DEFAULT_ITERATIONS;
+    const iterations = Math.max(1, Math.min(Math.trunc(rawIterations), 50));
+    const iterationTimeoutSeconds = resolveTimeoutSeconds(input.iterationTimeoutSeconds, DEFAULT_ITERATION_TIMEOUT);
+    const maxRetries = Math.max(0, Math.min(Math.trunc(input.maxRetries ?? DEFAULT_MAX_RETRIES), 10));
+    const maxRunDirs = Math.max(1, Math.min(Math.trunc(input.maxRunDirs ?? DEFAULT_MAX_RUN_DIRS), 200));
+    const summaryLines = input.summaryLines ?? DEFAULT_SUMMARY_LINES;
+    const notify = input.onProgress ?? (() => undefined);
+    // Pre-flight
+    const preflight = await runPreFlight({
+        cwd,
+        provider,
+        providerHealth,
+        model,
+        promptFile,
+        iterations,
+        iterationTimeoutSeconds,
+        maxRetries,
+        config,
+    });
+    notify({ type: "preflight", message: JSON.stringify(preflight) });
+    if (preflight.errors.length > 0) {
+        throw new Error(`Pre-flight failed:\n${preflight.errors.map((e) => `  - ${e}`).join("\n")}`);
+    }
+    // Dry-run mode — no lock needed
+    if (input.dryRun) {
+        const dryResult = {
+            runId: "dry-run",
+            provider,
+            model,
+            cwd,
+            runDir: "",
+            manifestFile: "",
+            iterations: [],
+            totalIterations: iterations,
+            succeeded: 0,
+            failed: 0,
+            startedAt: new Date().toISOString(),
+            finishedAt: new Date().toISOString(),
+            totalDurationMs: 0,
+            worktreeBeforeFile: "",
+            worktreeAfterFile: "",
+            worktreeDeltaFile: "",
+            promptFile,
+            dryRun: true,
+            tokenUsage: null,
+        };
+        notify({ type: "sweep_end", result: dryResult });
+        return dryResult;
+    }
+    // Acquire lock after pre-flight passes and dry-run is handled
+    await acquireSweepLock(cwd);
+    const runId = input.runId?.trim() || `sweep-${new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)}-${process.pid}`;
+    const artifactsDir = input.artifactsDir ? path.resolve(cwd, input.artifactsDir) : config.artifactsDir;
+    const runDir = path.resolve(artifactsDir, runId);
+    let basePrompt;
+    try {
+        await mkdir(runDir, { recursive: true });
+        basePrompt = await readFile(promptFile, "utf8");
+    }
+    catch (err) {
+        await rm(runDir, { recursive: true, force: true }).catch(() => undefined);
+        await releaseSweepLock(cwd);
+        throw err;
+    }
+    await rotateRunDirs(artifactsDir, maxRunDirs);
+    const worktreeBeforeFile = path.join(runDir, "worktree-before.txt");
+    const worktreeAfterFile = path.join(runDir, "worktree-after.txt");
+    const worktreeDeltaFile = path.join(runDir, "worktree-delta.diff");
+    const worktreeBefore = captureWorktreeStatus(cwd);
+    await writeFile(worktreeBeforeFile, worktreeBefore);
+    const startedAt = new Date();
+    const startedMs = Date.now();
+    const iterationResults = [];
+    let previousSummary = null;
+    await writeFile(path.join(runDir, "base-prompt.md"), basePrompt);
+    let cleanedUp = false;
+    let cancelled = false;
+    const onExit = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        releaseSweepLock(cwd).catch(() => undefined);
+    };
+    const onSigterm = () => {
+        cancelled = true;
+        onExit();
+        removeSignalHandlers();
+        process.kill(process.pid, "SIGTERM");
+    };
+    const onSigint = () => {
+        cancelled = true;
+        onExit();
+        removeSignalHandlers();
+        process.kill(process.pid, "SIGINT");
+    };
+    const removeSignalHandlers = () => {
+        process.removeListener("exit", onExit);
+        process.removeListener("SIGTERM", onSigterm);
+        process.removeListener("SIGINT", onSigint);
+    };
+    process.on("exit", onExit);
+    process.on("SIGTERM", onSigterm);
+    process.on("SIGINT", onSigint);
+    try {
+        for (let i = 1; i <= iterations; i++) {
+            if (cancelled)
+                break;
+            notify({ type: "iteration_start", iteration: i, total: iterations, provider, model });
+            const iterPrompt = buildIterationPrompt(basePrompt, i, iterations, previousSummary, { disallowDestructiveGit: config.safety.disallowDestructiveGit, phase: input.phase });
+            const iterPromptFile = path.join(runDir, `iteration-${i}-prompt.md`);
+            await writeFile(iterPromptFile, iterPrompt);
+            assertPromptFitsLaunch(provider, iterPrompt, iterPromptFile);
+            const iterLogFile = path.join(runDir, `iteration-${i}.log`);
+            const iterSummaryFile = path.join(runDir, `iteration-${i}.summary.md`);
+            // Create log file before starting so tailing can begin
+            await writeFile(iterLogFile, "");
+            notify({ type: "message", text: `  log: ${iterLogFile}`, elapsed: "0s" });
+            // Start live log monitoring
+            const logMonitor = startLiveLogMonitor(iterLogFile, Date.now(), notify, i, iterations, provider);
+            const iterStartMs = Date.now();
+            let exitCode = 1;
+            let attempts = 0;
+            let commandPreview = "";
+            let iterStatus = "failed";
+            const maxAttempts = maxRetries + 1;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                attempts = attempt;
+                try {
+                    const result = await executeProviderCommandWithRetries({
+                        provider,
+                        bin: providerHealth.bin,
+                        model,
+                        cwd,
+                        promptText: iterPrompt,
+                        promptFile: iterPromptFile,
+                        summaryFile: iterSummaryFile,
+                        logFile: iterLogFile,
+                        timeoutSeconds: iterationTimeoutSeconds,
+                        retryCount: 0,
+                        approveMcps: input.approveMcps ?? true,
+                        sandboxMode: input.sandboxMode ?? "workspace-write",
+                        background: input.background,
+                        permissionMode: input.permissionMode,
+                    });
+                    exitCode = result.exitCode;
+                    commandPreview = result.commandPreview;
+                    break;
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    if (errMsg.includes("timed out") || errMsg.includes("PROVIDER_TIMEOUT")) {
+                        iterStatus = "timeout";
+                    }
+                    if (attempt < maxAttempts) {
+                        const backoffMs = Math.min(5_000 * (1 << Math.min(attempt - 1, 4)), 60_000);
+                        notify({ type: "attempt_retry", iteration: i, attempt, maxAttempts, backoffMs });
+                        await appendFileSafe(iterLogFile, `\n[retry] iteration ${i}, attempt ${attempt}/${maxAttempts}, backoff ${backoffMs}ms\n`);
+                        await sleep(backoffMs);
+                        continue;
+                    }
+                    exitCode = 1;
+                }
+            }
+            // Read log for analysis
+            let logContent = "";
+            try {
+                logContent = await readFile(iterLogFile, "utf8");
+            }
+            catch { /* no log */ }
+            // SIGTERM (143) with result in log = success
+            if (exitCode === 143 && streamJsonHasResult(logContent)) {
+                exitCode = 0;
+            }
+            // Classify status
+            if (exitCode === 0) {
+                iterStatus = "success";
+            }
+            else if (iterStatus !== "timeout") {
+                // Check stderr for auth errors (NOT the agent log which contains code discussions)
+                let stderrContent = "";
+                try {
+                    const stderrFile = iterLogFile.replace(/\.log$/, ".stderr");
+                    if (existsSync(stderrFile)) {
+                        stderrContent = await readFile(stderrFile, "utf8");
+                    }
+                }
+                catch { /* no stderr */ }
+                const authCheckContent = `${stderrContent}\n${logContent}`;
+                if (/unauthorized|authentication.*fail|not.*logged.*in/i.test(authCheckContent)) {
+                    iterStatus = "auth_error";
+                }
+                else if (/cannot use this model/i.test(authCheckContent)) {
+                    iterStatus = "model_error";
+                }
+                else {
+                    iterStatus = "failed";
+                }
+            }
+            // Stop live log monitor
+            logMonitor.stop();
+            const toolCounts = parseStreamJsonToolCounts(logContent);
+            const tokenUsage = extractTokenUsageFromLog(logContent);
+            const summary = extractIterationSummary(logContent, summaryLines);
+            const iterDurationMs = Date.now() - iterStartMs;
+            // Write summary to file
+            if (summary.length > 0) {
+                await writeFile(iterSummaryFile, summary.join("\n"));
+            }
+            const iterResult = {
+                iteration: i,
+                status: iterStatus,
+                exitCode,
+                durationMs: iterDurationMs,
+                promptFile: iterPromptFile,
+                logFile: iterLogFile,
+                summaryFile: iterSummaryFile,
+                summary,
+                toolCounts,
+                tokenUsage,
+                attempts,
+                commandPreview,
+            };
+            iterationResults.push(iterResult);
+            notify({ type: "iteration_end", iteration: i, status: iterStatus, durationMs: iterDurationMs, provider, model });
+            if (summary.length > 0) {
+                notify({ type: "summary", iteration: i, lines: summary });
+            }
+            previousSummary = summary;
+            // Fatal errors stop the sweep
+            if (iterStatus === "auth_error" || iterStatus === "model_error") {
+                break;
+            }
+        }
+    }
+    finally {
+        removeSignalHandlers();
+        const worktreeAfter = captureWorktreeStatus(cwd);
+        await writeFile(worktreeAfterFile, worktreeAfter);
+        await writeFile(worktreeDeltaFile, buildWorktreeDelta(worktreeBefore, worktreeAfter));
+        await releaseSweepLock(cwd);
+    }
+    const totalDurationMs = Date.now() - startedMs;
+    const finishedAt = new Date();
+    const succeeded = iterationResults.filter((r) => r.status === "success").length;
+    const failed = iterationResults.filter((r) => r.status !== "success").length;
+    const result = {
+        runId,
+        provider,
+        model,
+        cwd,
+        runDir,
+        manifestFile: "",
+        iterations: iterationResults,
+        totalIterations: iterations,
+        succeeded,
+        failed,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        totalDurationMs,
+        worktreeBeforeFile,
+        worktreeAfterFile,
+        worktreeDeltaFile,
+        promptFile,
+        dryRun: false,
+        tokenUsage: aggregateTokenUsage(iterationResults.map((iteration) => iteration.tokenUsage)),
+    };
+    const manifestFile = await writeSweepManifest(runDir, result, config).catch(() => "");
+    result.manifestFile = manifestFile;
+    notify({ type: "sweep_end", result });
+    return result;
+}
+function startLiveLogMonitor(logFile, startMs, notify, iteration, totalIterations, provider) {
+    let stopped = false;
+    let lastOffset = 0;
+    const counts = { reads: 0, writes: 0, shells: 0, searches: 0, webSearches: 0, total: 0 };
+    let lineBuf = "";
+    const poll = setInterval(async () => {
+        if (stopped)
+            return;
+        try {
+            let fh;
+            try {
+                fh = await fsOpen(logFile, "r");
+            }
+            catch {
+                return;
+            }
+            try {
+                const fstat = await fh.stat();
+                if (fstat.size <= lastOffset) {
+                    return;
+                }
+                const readSize = Math.min(fstat.size - lastOffset, 256 * 1024);
+                const buf = Buffer.alloc(readSize);
+                const { bytesRead } = await fh.read(buf, 0, readSize, lastOffset);
+                lastOffset += bytesRead;
+                if (bytesRead === 0)
+                    return;
+                const raw = lineBuf + buf.slice(0, bytesRead).toString("utf8");
+                const lastNewline = raw.lastIndexOf("\n");
+                if (lastNewline === -1) {
+                    lineBuf = raw;
+                    return;
+                }
+                lineBuf = raw.slice(lastNewline + 1);
+                const newContent = raw.slice(0, lastNewline);
+                for (const line of newContent.split("\n")) {
+                    const trimmed = line.trim();
+                    if (!trimmed.startsWith("{"))
+                        continue;
+                    let parsed = null;
+                    try {
+                        parsed = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!parsed || !parsed.type)
+                        continue;
+                    const elapsed = formatDurationShort(Date.now() - startMs);
+                    if (parsed.type === "assistant" || parsed.type === "text") {
+                        const text = parsed.message?.content?.[0]?.text || "";
+                        if (text.trim()) {
+                            notify({ type: "message", text: text.trim().slice(0, 120), elapsed });
+                        }
+                    }
+                    else if (parsed.type === "tool_call" && parsed.subtype === "started") {
+                        const tcKey = parsed.tool_call ? Object.keys(parsed.tool_call)[0] ?? "" : "";
+                        const tc = parsed.tool_call?.[tcKey];
+                        const arg = tc?.args?.path || tc?.args?.command || tc?.args?.pattern || tc?.args?.glob_pattern || "";
+                        let action = "";
+                        if (tcKey.includes("read") || tcKey === "readToolCall") {
+                            counts.reads++;
+                            action = "read";
+                        }
+                        else if (tcKey.includes("write") || tcKey.includes("edit") || tcKey === "writeToolCall" || tcKey === "editToolCall") {
+                            counts.writes++;
+                            action = "write";
+                        }
+                        else if (tcKey.includes("shell") || tcKey === "shellToolCall") {
+                            counts.shells++;
+                            action = "shell";
+                        }
+                        else if (tcKey.includes("grep") || tcKey.includes("glob") || tcKey.includes("search")) {
+                            counts.searches++;
+                            action = "search";
+                        }
+                        else {
+                            action = tcKey.replace("ToolCall", "");
+                        }
+                        counts.total++;
+                        const shortArg = arg.split("/").pop()?.slice(0, 50) || arg.slice(0, 50);
+                        notify({ type: "tool", action, file: shortArg, counts: { ...counts } });
+                    }
+                    else if (parsed.type === "tool_use") {
+                        const tool = (parsed.tool ?? parsed.toolName ?? "").toLowerCase();
+                        if (tool.includes("read")) {
+                            counts.reads++;
+                        }
+                        else if (tool.includes("write") || tool.includes("edit") || tool === "str_replace") {
+                            counts.writes++;
+                        }
+                        else if (tool.includes("shell") || tool === "bash") {
+                            counts.shells++;
+                        }
+                        else if (tool.includes("grep") || tool.includes("glob") || tool.includes("search")) {
+                            counts.searches++;
+                        }
+                        counts.total++;
+                        notify({ type: "tool", action: tool, file: "", counts: { ...counts } });
+                    }
+                }
+            }
+            finally {
+                await fh.close();
+            }
+        }
+        catch { /* file not ready yet */ }
+    }, 1000);
+    poll.unref?.();
+    return {
+        stop() {
+            stopped = true;
+            clearInterval(poll);
+        },
+    };
+}
+function formatDurationShort(ms) {
+    const totalSec = Math.round(ms / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return m > 0 ? `${m}m${s.toString().padStart(2, "0")}s` : `${s}s`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=sweep.js.map