@matteeh/osq 0.1.0 → 0.2.0

package/dist/watcher/runner.js

@@ -1,302 +1,26 @@
-import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { hashChangeFolder } from '../core/hasher.js';
-import { acquireLock, releaseLock } from '../core/lock.js';
-import { resolveSymbol } from '../core/logger.js';
-import { parseTaskMd } from '../core/parser.js';
-import { asRecord } from '../harness/stream.js';
-import { appendHarnessEvent, } from '../harness/types.js';
-/**
- * Single-line, human-readable summary of a task outcome. Kept pure so the exact
- * shape can be tested without running the runner, and used directly beside every
- * marker write (`done/<n>` or `dead/<n>.md`) so the log and the marker agree.
- */
-export function formatTaskOutcomeSummary(taskNumber, success, reason, extra) {
-    if (success) {
-        return `task ${taskNumber} verified (passed)`;
-    }
-    const detail = extra ? `, ${extra}` : '';
-    return `task ${taskNumber} dead (reason: ${reason}${detail})`;
-}
-export async function tickTaskCheckbox(specFolderPath, taskNumber) {
-    const tasksMdPath = path.join(specFolderPath, 'tasks.md');
-    let content = '';
-    try {
-        content = await fs.readFile(tasksMdPath, 'utf8');
-    }
-    catch {
-        return;
-    }
-    const regex = new RegExp(`^(\\s*-\\s*\\[)[ ](\\]\\s*${taskNumber}\\b.*)$`, 'm');
-    const updated = content.replace(regex, '$1x$2');
-    if (updated !== content) {
-        await fs.writeFile(tasksMdPath, updated, 'utf8');
-    }
-}
-/**
- * Single code path for process lifecycle observation: the events.jsonl entry and
- * its human readable summary are always emitted together.
- */
-async function recordLifecycleEvent(specFolderPath, taskNumber, event, summary, logger, level = 'info') {
-    await appendHarnessEvent(specFolderPath, taskNumber, event);
-    if (level === 'verbose') {
-        logger?.verbose(summary);
-    }
-    else {
-        logger?.info(summary);
-    }
-}
-/**
- * Append the `dead` event that always travels with a dead marker. The event
- * stream is the append-only source of truth for failure history, so it must
- * agree with the marker at every exit. A lock collision never writes a dead
- * marker and therefore never records a dead event.
- */
-async function recordDeadEvent(specFolderPath, taskNumber, reason) {
-    await appendHarnessEvent(specFolderPath, taskNumber, {
-        type: 'dead',
-        timestamp: new Date().toISOString(),
-        data: { task: taskNumber, reason },
-    });
-}
-/**
- * Append the `done` event that always travels with a `done/<n>` marker.
- */
-async function recordDoneEvent(specFolderPath, taskNumber) {
-    await appendHarnessEvent(specFolderPath, taskNumber, {
-        type: 'done',
-        timestamp: new Date().toISOString(),
-        data: { task: taskNumber },
-    });
-}
-const heartbeatAccumulators = new Map();
-function createHeartbeatAccumulator() {
-    return { byteOffset: 0, eventCount: 0, totalTokens: 0, toolCount: 0, cost: 0, hasCost: false };
-}
-/**
- * Snapshot of task progress. Counters are maintained in memory and advanced
- * with only the bytes appended since the previous poll; the event file may not
- * exist yet, in which case counters are zero.
- */
-export async function computeTaskHeartbeatStats(specFolderPath, taskNumber, startTime) {
-    const elapsedSeconds = Number(((Date.now() - startTime) / 1000).toFixed(1));
-    const eventFilePath = path.join(specFolderPath, '.run', 'events', `${taskNumber}.jsonl`);
-    let content = '';
-    try {
-        content = await fs.readFile(eventFilePath, 'utf8');
-    }
-    catch {
-        heartbeatAccumulators.delete(eventFilePath);
-        return { elapsedSeconds, eventCount: 0, totalTokens: 0, toolCount: 0 };
-    }
-    let accumulator = heartbeatAccumulators.get(eventFilePath);
-    if (!accumulator || accumulator.byteOffset > content.length) {
-        accumulator = createHeartbeatAccumulator();
-    }
-    const fresh = content.slice(accumulator.byteOffset);
-    const lastNewline = fresh.lastIndexOf('\n');
-    if (lastNewline !== -1) {
-        const complete = fresh.slice(0, lastNewline);
-        accumulator.byteOffset += lastNewline + 1;
-        for (const line of complete.split('\n')) {
-            if (!line.trim()) {
-                continue;
-            }
-            accumulator.eventCount += 1;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                // Ignore malformed lines rather than losing the whole heartbeat.
-                continue;
-            }
-            const event = asRecord(parsed);
-            if (!event) {
-                continue;
-            }
-            const data = asRecord(event.data);
-            if (event.type === 'tokens') {
-                accumulator.totalTokens += Number(data?.totalTokens ?? 0) || 0;
-                const cost = Number(data?.cost);
-                if (Number.isFinite(cost)) {
-                    accumulator.cost += cost;
-                    accumulator.hasCost = true;
-                }
-            }
-            else if (event.type === 'tool') {
-                accumulator.toolCount += 1;
-                const summary = data?.summary;
-                if (typeof summary === 'string') {
-                    accumulator.lastToolSummary = summary;
-                }
-            }
-        }
-    }
-    heartbeatAccumulators.set(eventFilePath, accumulator);
-    const stats = {
-        elapsedSeconds,
-        eventCount: accumulator.eventCount,
-        totalTokens: accumulator.totalTokens,
-        toolCount: accumulator.toolCount,
-    };
-    if (accumulator.hasCost) {
-        stats.cost = accumulator.cost;
-    }
-    if (accumulator.lastToolSummary !== undefined) {
-        stats.lastToolSummary = accumulator.lastToolSummary;
-    }
-    return stats;
-}
-/**
- * Drop the in-memory counters for a finished task so the map does not grow
- * across watcher cycles.
- */
-export function clearTaskHeartbeatStats(specFolderPath, taskNumber) {
-    const eventFilePath = path.join(specFolderPath, '.run', 'events', `${taskNumber}.jsonl`);
-    heartbeatAccumulators.delete(eventFilePath);
-}
-const STATUS_SPINNER_PREFIX_WIDTH = 2; // spinner frame plus a single space
-const ELLIPSIS = '…';
-function truncateToWidth(text, width) {
-    if (width <= 0) {
-        return '';
-    }
-    if (text.length <= width) {
-        return text;
-    }
-    if (width === 1) {
-        return ELLIPSIS;
-    }
-    return `${text.slice(0, width - 1)}${ELLIPSIS}`;
-}
-/**
- * Single-line running status row. The logger owns the animated spinner and
- * prepends `<frame> `, so this text is truncated to leave room for that prefix
- * while fitting `terminalWidth` columns.
- */
-export function formatTaskStatusRow(taskNumber, stats, terminalWidth = process.stderr.columns ?? 80) {
-    const segments = [
-        `task ${taskNumber}`,
-        `${stats.elapsedSeconds}s`,
-        `${stats.toolCount} tools`,
-        `${stats.totalTokens} tokens`,
-    ];
-    if (typeof stats.cost === 'number' && Number.isFinite(stats.cost)) {
-        segments.push(`$${stats.cost.toFixed(4)}`);
-    }
-    const budget = terminalWidth - STATUS_SPINNER_PREFIX_WIDTH;
-    const base = segments.join(' · ');
-    if (!stats.lastToolSummary) {
-        return truncateToWidth(base, budget);
-    }
-    const separator = ' · ';
-    const summaryBudget = budget - base.length - separator.length;
-    if (summaryBudget <= 1) {
-        return truncateToWidth(base, budget);
-    }
-    return `${base}${separator}${truncateToWidth(stats.lastToolSummary, summaryBudget)}`;
-}
-/** Periodic heartbeat line shared by the 1s TTY row and the non-TTY log. */
-export function formatTaskHeartbeatLine(taskNumber, stats) {
-    return `task ${taskNumber} heartbeat (elapsed: ${stats.elapsedSeconds}s, events: ${stats.eventCount}, tokens: ${stats.totalTokens})`;
-}
-/**
- * Curated task-started line: a single info line carrying the task title
- * truncated so the whole line fits the terminal width. The lifecycle details
- * (pid, timeout) travel with it so the marker and the log line stay in sync.
- */
-export function formatTaskStartedLine(taskNumber, title, pid, timeoutSeconds, symbols, terminalWidth = process.stderr.columns ?? 80) {
-    const symbol = resolveSymbol('▶', '[task]', symbols);
-    const prefix = `${symbol} task ${taskNumber} started (pid: ${pid ?? 'unknown'}, timeout: ${timeoutSeconds}s): `;
-    const budget = Math.max(0, terminalWidth - prefix.length);
-    return `${prefix}${truncateToWidth(title, budget)}`;
-}
-/**
- * Curated task-outcome line: verified or dead with the failure reason and the
- * elapsed seconds since the task began.
- */
-export function formatTaskOutcomeLine(taskNumber, success, reason, elapsedSeconds, symbols) {
-    if (success) {
-        return `${resolveSymbol('✓', '[ok]', symbols)} task ${taskNumber} verified (elapsed: ${elapsedSeconds}s)`;
-    }
-    return `${resolveSymbol('✗', '[dead]', symbols)} task ${taskNumber} dead (reason: ${reason}, elapsed: ${elapsedSeconds}s)`;
-}
-/**
- * Return the last text message emitted on the agent's event stream, or null
- * when the stream has no text at all. Synthesis reads exclusively from
- * first-class `text` events carrying the completed assistant message; raw
- * harness payload shapes are never inspected. The stream is the append-only
- * `.run/events/<n>.jsonl` file, so this survives a watcher restart.
- */
-export async function extractFinalTextFromStream(specFolderPath, taskNumber) {
-    const eventFilePath = path.join(specFolderPath, '.run', 'events', `${taskNumber}.jsonl`);
-    let content = '';
-    try {
-        content = await fs.readFile(eventFilePath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    let finalText = null;
-    for (const line of content.split('\n')) {
-        if (!line.trim()) {
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        const event = asRecord(parsed);
-        if (event?.type !== 'text') {
-            continue;
-        }
-        const text = asRecord(event.data)?.text;
-        if (typeof text === 'string' && text.trim().length > 0) {
-            finalText = text;
-        }
-    }
-    return finalText?.trim() ? finalText : null;
-}
-/**
- * Write a result file synthesized from the agent's final stream message. The
- * frontmatter flags it as `synthesized: true` and a comment attributes it to
- * the watcher so a reader never mistakes it for an agent-authored result.
- */
-export async function synthesizeResultFile(resultsDir, taskNumber, finalText) {
-    await fs.mkdir(resultsDir, { recursive: true });
-    const resultPath = path.join(resultsDir, `${taskNumber}.md`);
-    const body = finalText.endsWith('\n') ? finalText : `${finalText}\n`;
-    const content = [
-        '---',
-        'synthesized: true',
-        '---',
-        "<!-- Synthesized by the osq watcher from the agent's final stream message.",
-        '     The agent exited without writing a result file. -->',
-        '',
-        body,
-    ].join('\n');
-    await fs.writeFile(resultPath, content, 'utf8');
-    return resultPath;
-}
+import { hashChangeFolder } from '../core/spec/hasher.js';
+import { parseTaskMd } from '../core/spec/parser.js';
+import { runChangeVerifyGate } from './change-verify.js';
+import { clearTaskHeartbeatStats, computeTaskHeartbeatStats, formatTaskHeartbeatLine, formatTaskStatusRow, } from './heartbeat.js';
+import { acquireTaskLock, releaseTaskLock } from './lock.js';
+import { createTaskMeasures } from './measures.js';
+import { formatTaskOutcomeLine, recordDeadEvent, recordDoneEvent, tickTaskCheckbox, writeDeadMarker, writeDoneMarker, } from './outcome.js';
+import { buildDoneMetadata, guardScopeRegression } from './regression.js';
+import { ensureTaskResult, spawnTaskAgent } from './spawn.js';
+import { checkMissingVerifyPaths, runPreSpawnVerify, verifyRedFailure } from './task-verify.js';
+import { captureTestGate, findUndeclaredTestChanges, runVerificationGate } from './verify.js';
+/** Top-level sequential task pipeline; each phase delegates to its lifecycle module. */
 export async function runTask(projectRoot, specFolderPath, taskNumber, config, adapter, logger) {
     const runDir = path.join(specFolderPath, '.run');
-    const deadDir = path.join(runDir, 'dead');
-    const doneDir = path.join(runDir, 'done');
     const startTime = Date.now();
     const useSymbols = logger?.symbols === true;
     const interactive = logger?.interactive === true;
-    const heartbeatSeconds = config.log?.heartbeatSeconds ?? 60;
-    const heartbeatIntervalMs = heartbeatSeconds * 1000;
+    const heartbeatIntervalMs = (config.log?.heartbeatSeconds ?? 60) * 1000;
     let heartbeatTimer = null;
     let heartbeatActive = true;
     let lastHeartbeatLogAt = startTime;
-    // One timer owns both observation modes: the 1s TTY status row and the
-    // periodic non-TTY heartbeat log. TTY heartbeats are demoted to verbose.
     const stopHeartbeat = () => {
         heartbeatActive = false;
         if (heartbeatTimer) {
@@ -305,64 +29,58 @@ export async function runTask(projectRoot, specFolderPath, taskNumber, config, a
         }
         logger?.clearStatus();
     };
-    const logOutcome = (success, reason) => {
+    const logOutcome = (success, reason, extra) => {
         stopHeartbeat();
         const elapsedSeconds = Number(((Date.now() - startTime) / 1000).toFixed(1));
-        logger?.info(formatTaskOutcomeLine(taskNumber, success, reason, elapsedSeconds, useSymbols));
+        logger?.info(formatTaskOutcomeLine(taskNumber, success, reason, elapsedSeconds, useSymbols, extra));
+    };
+    let measures = null;
+    const finish = (result) => measures ? measures.emitEnd().then(() => result) : Promise.resolve(result);
+    const fail = async (reason, marker, error, extra) => {
+        await measures?.emitEnd();
+        await writeDeadMarker(runDir, taskNumber, marker, projectRoot);
+        await recordDeadEvent(specFolderPath, taskNumber, reason);
+        logOutcome(false, reason, extra);
+        return { success: false, reason, error };
     };
-    const approvedPath = path.join(runDir, 'approved');
     let approvedHash = '';
     try {
-        approvedHash = (await fs.readFile(approvedPath, 'utf8')).trim();
+        approvedHash = (await fs.readFile(path.join(runDir, 'approved'), 'utf8')).trim();
     }
     catch {
-        await fs.mkdir(deadDir, { recursive: true });
-        await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), '---\nreason: spec_conflict\n---\nSpec has not been approved (missing .run/approved).\n', 'utf8');
-        await recordDeadEvent(specFolderPath, taskNumber, 'spec_conflict');
-        logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'spec_conflict'));
-        logOutcome(false, 'spec_conflict');
-        return { success: false, reason: 'spec_conflict', error: 'Missing .run/approved' };
+        const marker = '---\nreason: spec_conflict\n---\nSpec has not been approved (missing .run/approved).\n';
+        return fail('spec_conflict', marker, 'Missing .run/approved');
     }
     const currentHash = await hashChangeFolder(specFolderPath);
     if (currentHash !== approvedHash) {
-        await fs.mkdir(deadDir, { recursive: true });
-        await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), `---\nreason: spec_conflict\napproved_hash: "${approvedHash}"\ncurrent_hash: "${currentHash}"\n---\nChange folder modified after approval. Expected ${approvedHash}, computed ${currentHash}.\n`, 'utf8');
-        await recordDeadEvent(specFolderPath, taskNumber, 'spec_conflict');
-        logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'spec_conflict'));
-        logOutcome(false, 'spec_conflict');
-        return {
-            success: false,
-            reason: 'spec_conflict',
-            error: `Folder hash mismatch: expected ${approvedHash}, got ${currentHash}`,
-        };
+        const marker = `---\nreason: spec_conflict\napproved_hash: "${approvedHash}"\ncurrent_hash: "${currentHash}"\n---\nChange folder modified after approval. Expected ${approvedHash}, computed ${currentHash}.\n`;
+        const error = `Folder hash mismatch: expected ${approvedHash}, got ${currentHash}`;
+        return fail('spec_conflict', marker, error);
     }
     const taskPath = path.join(specFolderPath, 'tasks', `${taskNumber}.md`);
     let taskContent = '';
     try {
         taskContent = await fs.readFile(taskPath, 'utf8');
     }
-    catch (err) {
-        await fs.mkdir(deadDir, { recursive: true });
-        await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), `---\nreason: crashed\n---\nTask file not found: ${taskPath}\n`, 'utf8');
-        await recordDeadEvent(specFolderPath, taskNumber, 'crashed');
-        logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'crashed'));
-        logOutcome(false, 'crashed');
-        return { success: false, reason: 'crashed', error: 'Task file not found' };
+    catch {
+        const marker = `---\nreason: crashed\n---\nTask file not found: ${taskPath}\n`;
+        return fail('crashed', marker, 'Task file not found');
     }
     const taskData = parseTaskMd(taskContent);
-    const lockResult = await acquireLock(runDir, taskNumber);
+    const regression = await guardScopeRegression(projectRoot, specFolderPath, taskNumber, config);
+    if (regression) {
+        logOutcome(false, 'regressed', regression.error);
+        return regression;
+    }
+    const lockResult = await acquireTaskLock(runDir, taskNumber);
     if (!lockResult.acquired) {
-        // A lock collision means another process is actively running this task, not
-        // that the task failed. It writes no dead marker, so it must not append a
-        // dead event either; only a dead marker write may record a dead event.
-        logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'already_running'));
         logOutcome(false, 'already_running');
         return { success: false, reason: 'already_running', error: 'Task is already running' };
     }
     if (heartbeatIntervalMs > 0) {
         const tickIntervalMs = interactive ? Math.min(heartbeatIntervalMs, 1000) : heartbeatIntervalMs;
         heartbeatTimer = setInterval(() => {
-            computeTaskHeartbeatStats(specFolderPath, taskNumber, startTime)
+            computeTaskHeartbeatStats(specFolderPath, taskNumber, startTime, projectRoot)
                 .then((stats) => {
                 if (!heartbeatActive)
                     return;
@@ -383,214 +101,47 @@ export async function runTask(projectRoot, specFolderPath, taskNumber, config, a
         heartbeatTimer.unref();
     }
     try {
-        const spawnStartMs = startTime;
-        const timeoutSeconds = config.timeouts.taskTimeoutSeconds;
-        // The runner alone owns lifecycle events. `started` is emitted the moment
-        // the child process exists via `onSpawn`, not after the adapter resolves.
-        let startedRecorded = false;
-        let startedPromise = null;
-        const recordStarted = (pid) => {
-            if (startedRecorded) {
-                return startedPromise ?? Promise.resolve();
-            }
-            startedRecorded = true;
-            startedPromise = recordLifecycleEvent(specFolderPath, taskNumber, {
-                type: 'started',
-                timestamp: new Date().toISOString(),
-                data: { pid, timeoutSeconds },
-            }, formatTaskStartedLine(taskNumber, taskData.title, pid, timeoutSeconds, useSymbols), logger);
-            return startedPromise;
-        };
-        const spawnResult = await adapter.spawn({
+        const testGate = await captureTestGate(projectRoot, taskData.scope, taskData.testsModify);
+        const verifyCtx = { projectRoot, specFolderPath, taskNumber, taskData, config, logger };
+        const preSpawn = await runPreSpawnVerify(verifyCtx);
+        if (!preSpawn.ok)
+            return fail('verify_precondition', preSpawn.marker, preSpawn.error);
+        measures = createTaskMeasures(projectRoot, specFolderPath, taskNumber, taskData);
+        await measures.emitStart();
+        const spawnOutcome = await spawnTaskAgent({
             projectRoot,
             specFolderPath,
             taskNumber,
-            taskTitle: taskData.title,
-            verifyCommand: taskData.verify,
-            scope: taskData.scope,
-            entry: taskData.entry,
-            skills: taskData.skills,
-            tier: 'coding',
-            timeoutSeconds,
+            taskData,
             config,
-            onSpawn: (pid) => recordStarted(pid),
-        });
-        // Fallback: an adapter that never invokes onSpawn (or a spawn that fails
-        // before the callback) still yields exactly one `started` event.
-        await recordStarted(spawnResult.pid);
-        const elapsedMs = spawnResult.elapsedMs ?? Date.now() - spawnStartMs;
-        const elapsedSeconds = Number((elapsedMs / 1000).toFixed(1));
-        await recordLifecycleEvent(specFolderPath, taskNumber, {
-            type: 'exited',
-            timestamp: new Date().toISOString(),
-            data: {
-                exitCode: spawnResult.exitCode,
-                pid: spawnResult.pid,
-                signal: spawnResult.signal ?? undefined,
-                timedOut: spawnResult.timedOut,
-                elapsedSeconds,
-            },
-        }, `task ${taskNumber} exited (code: ${spawnResult.exitCode}, elapsed: ${elapsedSeconds}s)`, logger, 'verbose');
-        if (spawnResult.exitCode !== 0 || spawnResult.timedOut) {
-            const failureReason = spawnResult.timedOut ? 'timeout' : 'crashed';
-            await fs.mkdir(deadDir, { recursive: true });
-            const deadMarkerLines = [
-                '---',
-                `reason: ${failureReason}`,
-                `exit_code: ${spawnResult.exitCode}`,
-            ];
-            if (spawnResult.signal) {
-                deadMarkerLines.push(`signal: ${spawnResult.signal}`);
-            }
-            deadMarkerLines.push('---');
-            deadMarkerLines.push(`Agent ${spawnResult.timedOut ? 'timed out' : 'crashed'} with code ${spawnResult.exitCode}: ${spawnResult.error || ''}\n`);
-            await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), deadMarkerLines.join('\n'), 'utf8');
-            await recordDeadEvent(specFolderPath, taskNumber, failureReason);
-            logger?.info(formatTaskOutcomeSummary(taskNumber, false, failureReason, failureReason === 'crashed' ? `code: ${spawnResult.exitCode}` : undefined));
-            logOutcome(false, failureReason);
-            return {
-                success: false,
-                reason: failureReason,
-                error: spawnResult.error || `Agent exited with code ${spawnResult.exitCode}`,
-            };
-        }
-        const resultPath = path.join(runDir, 'results', `${taskNumber}.md`);
-        let hasResult = false;
-        try {
-            await fs.stat(resultPath);
-            hasResult = true;
-        }
-        catch { }
-        if (!hasResult) {
-            const finalText = await extractFinalTextFromStream(specFolderPath, taskNumber);
-            if (finalText) {
-                await synthesizeResultFile(path.join(runDir, 'results'), taskNumber, finalText);
-                await appendHarnessEvent(specFolderPath, taskNumber, {
-                    type: 'result_written',
-                    timestamp: new Date().toISOString(),
-                    data: { path: resultPath, synthesized: true },
-                });
-                logger?.verbose(`task ${taskNumber} result synthesized from agent message`);
-            }
-            else {
-                await fs.mkdir(deadDir, { recursive: true });
-                await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), `---\nreason: no_result\n---\nAgent exited without writing result file at .run/results/${taskNumber}.md and produced no final text.\n`, 'utf8');
-                await recordDeadEvent(specFolderPath, taskNumber, 'no_result');
-                logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'no_result'));
-                logOutcome(false, 'no_result');
-                return {
-                    success: false,
-                    reason: 'no_result',
-                    error: `Agent exited without writing .run/results/${taskNumber}.md`,
-                };
-            }
-        }
-        await appendHarnessEvent(specFolderPath, taskNumber, {
-            type: 'verify_ran',
-            timestamp: new Date().toISOString(),
-            data: { command: taskData.verify },
-        });
-        const verifyTimeoutMs = (config.timeouts.verifyTimeoutSeconds ?? 600) * 1000;
-        let verifyTimedOut = false;
-        const verifyPromise = new Promise((resolve, reject) => {
-            const child = spawn(taskData.verify, {
-                cwd: projectRoot,
-                shell: true,
-                detached: true,
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let timer = null;
-            let killTimer = null;
-            if (verifyTimeoutMs > 0) {
-                timer = setTimeout(() => {
-                    verifyTimedOut = true;
-                    const childPid = child.pid;
-                    if (childPid) {
-                        try {
-                            process.kill(-childPid, 'SIGTERM');
-                        }
-                        catch {
-                            try {
-                                child.kill('SIGTERM');
-                            }
-                            catch { }
-                        }
-                        killTimer = setTimeout(() => {
-                            try {
-                                process.kill(-childPid, 'SIGKILL');
-                            }
-                            catch {
-                                try {
-                                    child.kill('SIGKILL');
-                                }
-                                catch { }
-                            }
-                        }, 5000);
-                    }
-                }, verifyTimeoutMs);
-            }
-            let stderr = '';
-            let stdout = '';
-            child.stderr?.on('data', (d) => {
-                stderr += d.toString();
-            });
-            child.stdout?.on('data', (d) => {
-                stdout += d.toString();
-            });
-            child.on('error', (err) => {
-                if (timer)
-                    clearTimeout(timer);
-                if (killTimer)
-                    clearTimeout(killTimer);
-                reject(err);
-            });
-            child.on('close', (code) => {
-                if (timer)
-                    clearTimeout(timer);
-                if (killTimer)
-                    clearTimeout(killTimer);
-                if (verifyTimedOut) {
-                    reject(new Error(`Verify command timed out after ${config.timeouts.verifyTimeoutSeconds ?? 600}s`));
-                }
-                else if (code !== 0) {
-                    reject(new Error(stderr || stdout || `Process exited with code ${code}`));
-                }
-                else {
-                    resolve();
-                }
-            });
+            adapter,
+            logger,
+            logOutcome,
         });
-        try {
-            await verifyPromise;
-        }
-        catch (verifyErr) {
-            const msg = verifyErr instanceof Error ? verifyErr.message : String(verifyErr);
-            await fs.mkdir(deadDir, { recursive: true });
-            const deadLines = ['---', 'reason: verify_red'];
-            if (verifyTimedOut) {
-                deadLines.push('timed_out: true');
-            }
-            deadLines.push(`command: "${taskData.verify}"`);
-            deadLines.push('---');
-            deadLines.push(`Watcher independent verify ${verifyTimedOut ? 'timed out' : 'failed'}:\n${msg}\n`);
-            await fs.writeFile(path.join(deadDir, `${taskNumber}.md`), deadLines.join('\n'), 'utf8');
-            await recordDeadEvent(specFolderPath, taskNumber, 'verify_red');
-            logger?.info(formatTaskOutcomeSummary(taskNumber, false, 'verify_red', verifyTimedOut ? 'timed_out: true' : undefined));
-            logOutcome(false, 'verify_red');
-            return {
-                success: false,
-                reason: 'verify_red',
-                error: `Verify failed: ${msg}`,
-            };
+        if (!spawnOutcome.ok)
+            return finish(spawnOutcome.result);
+        const undeclared = await findUndeclaredTestChanges(projectRoot, testGate.snapshot, testGate);
+        if (undeclared.length > 0) {
+            const marker = `---\nreason: undeclared_test_change\n---\nPreexisting test files were modified or deleted without both tests.modify: true and an authorizing scope entry:\n${undeclared.map((file) => `- ${file}`).join('\n')}\n`;
+            const error = `Undeclared test changes: ${undeclared.join(', ')}`;
+            return fail('undeclared_test_change', marker, error);
         }
-        try {
-            await fs.unlink(path.join(deadDir, `${taskNumber}.md`));
+        const ensured = await ensureTaskResult({ specFolderPath, taskNumber, logger, logOutcome });
+        if (!ensured.ok)
+            return finish(ensured.result);
+        const missingPath = await checkMissingVerifyPaths(projectRoot, taskData, fail);
+        if (missingPath)
+            return missingPath;
+        const verifyResult = await runVerificationGate(projectRoot, taskData.verify, config.timeouts.verifyTimeoutSeconds ?? 600, { specFolderPath, taskNumber });
+        if (!verifyResult.passed) {
+            return verifyRedFailure(taskData.verify, verifyResult, fail);
         }
-        catch { }
-        await fs.mkdir(doneDir, { recursive: true });
-        await fs.writeFile(path.join(doneDir, taskNumber), `${new Date().toISOString()}\n`, 'utf8');
+        const gate = await runChangeVerifyGate(projectRoot, specFolderPath, config);
+        if (!gate.ok)
+            return fail('change_verify_red', gate.marker, gate.error, gate.extra);
+        await measures.emitEnd();
+        await writeDoneMarker(runDir, taskNumber, await buildDoneMetadata(projectRoot, taskData.scope));
         await recordDoneEvent(specFolderPath, taskNumber);
-        logger?.info(formatTaskOutcomeSummary(taskNumber, true));
         logOutcome(true);
         await tickTaskCheckbox(specFolderPath, taskNumber);
         return { success: true };
@@ -598,7 +149,7 @@ export async function runTask(projectRoot, specFolderPath, taskNumber, config, a
     finally {
         stopHeartbeat();
         clearTaskHeartbeatStats(specFolderPath, taskNumber);
-        await releaseLock(runDir, taskNumber);
+        await releaseTaskLock(runDir, taskNumber);
     }
 }
 //# sourceMappingURL=runner.js.map