patchwarden 0.4.0 → 0.6.1

package/dist/runner/runTask.js

@@ -1,15 +1,20 @@
 import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { getTasksDir, getPlansDir, getConfig, resolveWorkspaceRoot } from "../config.js";
 import { guardPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { guardAgentCommand, guardTestCommand, sanitizePromptArg, } from "../security/commandGuard.js";
+import { guardTestCommand, } from "../security/commandGuard.js";
 import { writeTaskProgress } from "../taskProgress.js";
 import { writeTaskRuntime } from "../taskRuntime.js";
-import { buildChangeArtifacts, captureRepoSnapshot, compareSnapshots, writeSnapshot, } from "./changeCapture.js";
+import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { buildAgentInvocation, buildExecutionPrompt } from "./agentInvocation.js";
+import { buildChangeArtifacts, captureRepoSnapshot, compareSnapshots, emptyArtifactHygiene, writeSnapshot, extractExternalDirtyFiles, findNewExternalDirtyFiles, buildArtifactManifest, groupChangedFiles, } from "./changeCapture.js";
+import { errorPayload } from "../errors.js";
+import { diagnoseAndroidBuild } from "../tools/androidDoctor.js";
 const HEARTBEAT_INTERVAL_MS = 2000;
 const GRACEFUL_KILL_MS = 2000;
 const MAX_CAPTURE_CHARS = 100_000;
+const ARTIFACT_COLLECTION_TIMEOUT_MS = 60_000;
 export async function runTask(taskId) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -29,11 +34,10 @@ export async function runTask(taskId) {
     let verifyCommands;
     let timeoutSeconds;
     try {
-        verifyCommands = normalizeVerifyCommands(initialStatus.verify_commands, testCommand, config);
         timeoutSeconds = normalizeTimeout(initialStatus.timeout_seconds, config);
     }
     catch (error) {
-        return failBeforeExecution(taskId, taskDir, errorMessage(error));
+        return failBeforeExecution(taskId, taskDir, errorMessage(error), error);
     }
     const startedAtMs = Date.now();
     const deadlineMs = startedAtMs + timeoutSeconds * 1000;
@@ -43,7 +47,30 @@ export async function runTask(taskId) {
     }
     catch (error) {
         const message = `repo_path validation failed: ${errorMessage(error)}`;
-        return failBeforeExecution(taskId, taskDir, message);
+        return failBeforeExecution(taskId, taskDir, message, error);
+    }
+    try {
+        verifyCommands = normalizeVerifyCommands(initialStatus.verify_commands, testCommand, config, repoPath);
+    }
+    catch (error) {
+        const message = `verification metadata validation failed: ${errorMessage(error)}`;
+        return failBeforeExecution(taskId, taskDir, message, error);
+    }
+    // ── Assessment freshness revalidation before execution ──
+    const assessmentId = String(initialStatus.assessment_id || "");
+    if (assessmentId) {
+        try {
+            const preExecSnapshot = captureRepoSnapshot(repoPath);
+            const validation = validateAssessmentFreshness(assessmentId, preExecSnapshot);
+            if (!validation.valid) {
+                const message = `assessment validation failed: ${validation.failure_reason}. Re-run create_task with execution_mode=assess_only to get a fresh assessment_id.`;
+                return failBeforeExecution(taskId, taskDir, message);
+            }
+        }
+        catch (error) {
+            const message = `assessment validation error: ${errorMessage(error)}`;
+            return failBeforeExecution(taskId, taskDir, message, error);
+        }
     }
     updateStatus(taskDir, {
         status: "running",
@@ -57,40 +84,37 @@ export async function runTask(taskId) {
     setTaskPhase(taskDir, "preparing", null, "Capturing pre-task repository state.");
     let beforeSnapshot;
     let beforeWorkspaceSnapshot;
+    let externalDirtyBaseline = [];
     try {
         beforeSnapshot = captureRepoSnapshot(repoPath);
         beforeWorkspaceSnapshot = repoPath === wsRoot ? beforeSnapshot : captureRepoSnapshot(wsRoot);
         writeSnapshot(taskDir, "git-before.json", beforeSnapshot);
         writeSnapshot(taskDir, "workspace-before.json", beforeWorkspaceSnapshot);
+        // Phase 4: Record external dirty files as baseline before task execution
+        externalDirtyBaseline = extractExternalDirtyFiles(beforeWorkspaceSnapshot, repoPath, wsRoot);
     }
     catch (error) {
         const message = `Pre-task snapshot failed: ${errorMessage(error)}`;
-        return failBeforeExecution(taskId, taskDir, message);
+        return failBeforeExecution(taskId, taskDir, message, error);
     }
     let agentResult = null;
     let testResult = skippedTest(testCommand, repoPath, "Agent did not complete successfully.");
     const verifyResults = [];
     let finalStatus = "failed";
     let finalError = null;
+    let lastCaughtError = null;
     try {
         const planFile = resolve(plansDir, planId, "plan.md");
         if (!existsSync(planFile))
             throw new Error(`Plan not found: "${planId}". Save the plan first.`);
         const planContent = readFileSync(planFile, "utf-8");
-        const agentCmd = guardAgentCommand(agentName, config);
-        const prompt = sanitizePromptArg(buildExecutionPrompt(planContent, repoPath, testCommand));
-        const resolvedArgs = agentCmd.args.map((arg) => {
-            if (arg === "{repo}")
-                return repoPath;
-            if (arg === "{prompt}")
-                return prompt;
-            return arg;
-        });
-        const agentCommandLabel = `${basename(agentCmd.command)} (configured agent command)`;
+        const prompt = buildExecutionPrompt(planContent, repoPath, testCommand);
+        const invocation = buildAgentInvocation(agentName, repoPath, prompt, config);
+        const agentCommandLabel = invocation.commandLabel;
         setTaskPhase(taskDir, "executing_agent", agentCommandLabel);
         agentResult = await runManagedProcess({
-            command: agentCmd.command,
-            args: resolvedArgs,
+            command: invocation.command,
+            args: invocation.args,
             cwd: repoPath,
             taskDir,
             statusFile,
@@ -154,19 +178,45 @@ export async function runTask(taskId) {
         }
     }
     catch (error) {
+        lastCaughtError = error;
         finalError = errorMessage(error);
     }
     setTaskPhase(taskDir, "collecting_artifacts", null, "Capturing post-task state and writing reports.");
+    const artifactCollectionStartedAt = new Date().toISOString();
     let changes;
+    let artifactStatus = "collected";
+    let artifactCollectionError = null;
+    let timeoutHandle;
     try {
-        const afterSnapshot = captureRepoSnapshot(repoPath);
-        writeSnapshot(taskDir, "git-after.json", afterSnapshot);
-        changes = buildChangeArtifacts(repoPath, beforeSnapshot, afterSnapshot);
+        // Phase 5: Wrap artifact collection with a timeout
+        const collectionResult = await Promise.race([
+            Promise.resolve().then(() => {
+                const afterSnapshot = captureRepoSnapshot(repoPath);
+                writeSnapshot(taskDir, "git-after.json", afterSnapshot);
+                return buildChangeArtifacts(repoPath, beforeSnapshot, afterSnapshot);
+            }),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error("Artifact collection timed out")), ARTIFACT_COLLECTION_TIMEOUT_MS);
+            }),
+        ]);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        changes = collectionResult;
     }
     catch (error) {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        lastCaughtError = error;
+        artifactCollectionError = errorMessage(error);
+        if (artifactCollectionError.includes("timed out")) {
+            artifactStatus = "timeout";
+        }
+        else {
+            artifactStatus = "failed";
+        }
         changes = {
             changed_files: [],
-            diff: `(change capture failed: ${errorMessage(error)})\n`,
+            diff: `(change capture failed: ${artifactCollectionError})\n`,
             diff_available: false,
             diff_truncated: false,
             diff_size_bytes: 0,
@@ -176,15 +226,50 @@ export async function runTask(taskId) {
             workspace_dirty_before: beforeSnapshot.workspace_dirty,
             workspace_dirty_after: beforeSnapshot.workspace_dirty,
             patch_mode: "hash_only",
-            unavailable_reason: `Change capture failed: ${errorMessage(error)}`,
+            unavailable_reason: `Change capture failed: ${artifactCollectionError}`,
+            artifact_hygiene: emptyArtifactHygiene(),
         };
-        finalError ||= `Change capture failed: ${errorMessage(error)}`;
-        finalStatus = "failed";
+        // Phase 5: Write partial_result.md when artifact collection fails
+        writeFileSync(join(taskDir, "partial_result.md"), [
+            "# PatchWarden Partial Result",
+            "",
+            `Task: ${taskId}`,
+            "",
+            "## Artifact Collection Status",
+            artifactStatus,
+            "",
+            "## Error",
+            artifactCollectionError,
+            "",
+            "## Agent Status",
+            agentResult ? `Exit code: ${agentResult.exitCode}` : "Agent did not run",
+            "",
+            "## Verification Status",
+            verifyResults.length > 0 ? verifyResults.map((r) => `- ${r.command}: exit ${r.exitCode}`).join("\n") : "No verification ran",
+            "",
+            "## Note",
+            "Artifact collection did not complete. The task result may be incomplete. Review stdout.log, stderr.log, and verify.json for details.",
+            "",
+        ].join("\n"), "utf-8");
+        // Don't override test failure with artifact failure
+        if (finalStatus === "done") {
+            finalError = `Change capture failed: ${artifactCollectionError}`;
+            finalStatus = "failed";
+        }
+        else {
+            finalError ||= `Change capture failed: ${artifactCollectionError}`;
+        }
     }
+    const artifactCollectionFinishedAt = new Date().toISOString();
     let outOfScopeChanges = [];
+    let preexistingExternalDirty = externalDirtyBaseline;
+    let newOutOfScopeChanges = [];
     try {
         const afterWorkspaceSnapshot = repoPath === wsRoot ? captureRepoSnapshot(repoPath) : captureRepoSnapshot(wsRoot);
         writeSnapshot(taskDir, "workspace-after.json", afterWorkspaceSnapshot);
+        const allExternalDirty = extractExternalDirtyFiles(afterWorkspaceSnapshot, repoPath, wsRoot);
+        // Phase 4: Only NEW external dirty files (not in baseline) are scope violations
+        newOutOfScopeChanges = findNewExternalDirtyFiles(externalDirtyBaseline, allExternalDirty);
         outOfScopeChanges = compareSnapshots(beforeWorkspaceSnapshot, afterWorkspaceSnapshot)
             .filter((file) => !isPathInside(resolve(wsRoot, file.path), repoPath) ||
             Boolean(file.old_path && !isPathInside(resolve(wsRoot, file.old_path), repoPath)));
@@ -194,15 +279,20 @@ export async function runTask(taskId) {
         if (finalStatus === "done")
             finalStatus = "failed";
     }
-    if (outOfScopeChanges.length > 0) {
+    // Phase 4: Pre-existing external dirty files are warnings, not failures
+    const preexistingWarnings = preexistingExternalDirty.length > 0
+        ? [`Pre-existing external dirty files (not caused by this task): ${preexistingExternalDirty.length} file(s)`]
+        : [];
+    if (newOutOfScopeChanges.length > 0) {
         finalStatus = "failed_scope_violation";
-        finalError = `Detected ${outOfScopeChanges.length} change(s) outside resolved_repo_path.`;
+        finalError = `Detected ${newOutOfScopeChanges.length} new change(s) outside resolved_repo_path during task execution.`;
         writeFileSync(join(taskDir, "rollback-plan.json"), JSON.stringify({
             task_id: taskId,
             status: "review_required",
             automatic_rollback_performed: false,
             warning: "Review ownership and concurrent edits before rollback. PatchWarden did not modify or restore these files.",
-            out_of_scope_changes: outOfScopeChanges,
+            out_of_scope_changes: newOutOfScopeChanges,
+            preexisting_external_dirty_files: preexistingExternalDirty,
         }, null, 2), "utf-8");
         writeFileSync(join(taskDir, "rollback_scope_violation_plan.md"), [
             "# Scope Violation Rollback Plan",
@@ -211,8 +301,8 @@ export async function runTask(taskId) {
             "",
             "PatchWarden did not automatically roll back any file. Review concurrent or user-owned edits before acting.",
             "",
-            "## Out-of-scope files only",
-            ...outOfScopeChanges.map((file) => `- ${file.change}: ${file.old_path ? `${file.old_path} -> ` : ""}${file.path}`),
+            "## New out-of-scope files (caused by this task)",
+            ...newOutOfScopeChanges.map((file) => `- ${file.change}: ${file.path}`),
             "",
         ].join("\n"), "utf-8");
     }
@@ -223,6 +313,10 @@ export async function runTask(taskId) {
     writeFileSync(join(taskDir, "git.diff"), changes.diff, "utf-8");
     writeFileSync(join(taskDir, "diff.patch"), changes.diff, "utf-8");
     writeFileSync(join(taskDir, "changed-files.json"), JSON.stringify(changes, null, 2), "utf-8");
+    // Phase 6: Generate artifact_manifest.json and group changed files
+    const artifactManifest = buildArtifactManifest(changes.changed_files, repoPath, taskId);
+    writeFileSync(join(taskDir, "artifact_manifest.json"), JSON.stringify(artifactManifest, null, 2), "utf-8");
+    const changedFileGroups = groupChangedFiles(changes.changed_files);
     writeFileSync(join(taskDir, "file-stats.json"), JSON.stringify({
         task_id: taskId,
         additions: changes.additions,
@@ -231,7 +325,10 @@ export async function runTask(taskId) {
     }, null, 2), "utf-8");
     writeFileSync(join(taskDir, "test.log"), buildTestLog(testResult), "utf-8");
     const verifyJson = buildVerifyJson(verifyCommands, verifyResults, repoPath);
-    if (outOfScopeChanges.length > 0) {
+    // Phase 4: Use newOutOfScopeChanges (not outOfScopeChanges) for verify_status
+    // to stay consistent with finalStatus. Pre-existing external dirty files
+    // that didn't change during the task should NOT cause verify_status to fail.
+    if (newOutOfScopeChanges.length > 0) {
         verifyJson.status = "failed";
         verifyJson.failure_reason = "scope_violation";
     }
@@ -245,6 +342,20 @@ export async function runTask(taskId) {
         finalStatus = "failed";
     const finalPhase = finalStatus === "done" ? "completed" : finalStatus;
     const followup = buildFailureFollowup(finalStatus, finalError, verifyJson.commands);
+    // Phase 7: Run Android build environment diagnostics if android_app exists
+    const androidDiagnostic = diagnoseAndroidBuild(repoPath);
+    let androidWarning = null;
+    if (androidDiagnostic.status !== "skip") {
+        if (androidDiagnostic.status === "fail") {
+            androidWarning = "Android project exists, APK not built because Android SDK is missing.";
+        }
+        else if (androidDiagnostic.status === "warn") {
+            const apkCheck = androidDiagnostic.checks.find((c) => c.check === "APK output path");
+            if (apkCheck && apkCheck.status !== "ok") {
+                androidWarning = `Android build environment has warnings: ${apkCheck.reason}`;
+            }
+        }
+    }
     const resultMd = buildResultMarkdown({
         taskId,
         planId,
@@ -256,6 +367,12 @@ export async function runTask(taskId) {
         verify: verifyJson,
         changes,
         outOfScopeChanges,
+        artifactStatus,
+        artifactManifest,
+        changedFileGroups,
+        androidDiagnostic,
+        androidWarning,
+        preexistingWarnings,
     });
     writeFileSync(join(taskDir, "result.md"), resultMd, "utf-8");
     writeFileSync(join(taskDir, "result.json"), JSON.stringify({
@@ -270,7 +387,26 @@ export async function runTask(taskId) {
         change_policy: changePolicy,
         summary: finalError || "Agent execution and configured verification completed successfully.",
         changed_files: changes.changed_files,
+        changed_file_groups: {
+            source_changes: changedFileGroups.source_changes.length,
+            docs_changes: changedFileGroups.docs_changes.length,
+            config_changes: changedFileGroups.config_changes.length,
+            test_changes: changedFileGroups.test_changes.length,
+            release_artifacts: changedFileGroups.release_artifacts.length,
+            runtime_generated_files: changedFileGroups.runtime_generated_files.length,
+        },
+        artifact_hygiene: changes.artifact_hygiene,
+        artifact_status: artifactStatus,
+        artifact_collection_error: artifactCollectionError,
+        artifact_collection_started_at: artifactCollectionStartedAt,
+        artifact_collection_finished_at: artifactCollectionFinishedAt,
+        artifact_manifest: artifactManifest,
         out_of_scope_changes: outOfScopeChanges,
+        new_out_of_scope_changes: newOutOfScopeChanges,
+        preexisting_external_dirty_files: preexistingExternalDirty,
+        target_repo_status: changes.workspace_dirty_after ? "dirty" : "clean",
+        workspace_status: changes.workspace_dirty_after ? "dirty" : "clean",
+        android_diagnostic: androidDiagnostic,
         verify_status: verifyJson.status,
         verify_commands: verifyJson.commands,
         commands_run: verifyJson.commands.map((command) => ({
@@ -281,12 +417,15 @@ export async function runTask(taskId) {
         commands_observed: [],
         verify: verifyJson,
         artifacts: [
-            "result.md", "result.json", "diff.patch", "git.diff", "test.log", "verify.log", "verify.json", "changed-files.json", "file-stats.json",
+            "result.md", "result.json", "diff.patch", "git.diff", "test.log", "verify.log", "verify.json", "changed-files.json", "file-stats.json", "artifact_manifest.json",
             ...(outOfScopeChanges.length > 0 ? ["rollback_scope_violation_plan.md", "rollback-plan.json"] : []),
+            ...(artifactStatus !== "collected" ? ["partial_result.md"] : []),
         ],
         warnings: [
             ...beforeSnapshot.warnings,
             ...(changes.diff_truncated ? ["diff.patch was truncated; changed-files.json retains file evidence."] : []),
+            ...preexistingWarnings,
+            ...(androidWarning ? [androidWarning] : []),
         ],
         errors: finalError ? [finalError] : [],
         known_issues: finalError ? [finalError] : [],
@@ -298,8 +437,14 @@ export async function runTask(taskId) {
             ? ["Review get_task_summary and audit_task before accepting the work."]
             : ["Resolve the reported failure before accepting the work."],
     }, null, 2), "utf-8");
-    if (finalError)
-        writeFileSync(join(taskDir, "error.log"), finalError, "utf-8");
+    if (finalError) {
+        // Phase 9: Preserve PatchWardenError structured info in error.log
+        const structuredError = errorPayload(lastCaughtError);
+        writeFileSync(join(taskDir, "error.log"), JSON.stringify({
+            summary: finalError,
+            ...structuredError,
+        }, null, 2), "utf-8");
+    }
     const finishedAt = new Date().toISOString();
     updateStatus(taskDir, {
         status: finalStatus,
@@ -309,7 +454,14 @@ export async function runTask(taskId) {
         finished_at: finishedAt,
         error: finalError,
         changed_files: changes.changed_files.map(({ path, change }) => ({ path, change })),
+        artifact_hygiene_counts: changes.artifact_hygiene.counts,
+        artifact_status: artifactStatus,
+        artifact_collection_error: artifactCollectionError,
+        artifact_collection_started_at: artifactCollectionStartedAt,
+        artifact_collection_finished_at: artifactCollectionFinishedAt,
         out_of_scope_changes: outOfScopeChanges,
+        new_out_of_scope_changes: newOutOfScopeChanges,
+        preexisting_external_dirty_files: preexistingExternalDirty,
         verify_status: verifyJson.status,
         verify_commands: verifyCommands,
         diff_available: changes.diff_available,
@@ -403,6 +555,8 @@ async function runManagedProcess(options) {
     let spawnError = null;
     let terminationReason = null;
     let forceTimer = null;
+    let fallbackTimer = null;
+    let childExitFinish = null;
     let terminationStarted = false;
     const heartbeat = () => {
         const now = new Date().toISOString();
@@ -442,6 +596,22 @@ async function runManagedProcess(options) {
             gracefulKill(child);
             forceTimer = setTimeout(() => forceKill(child), GRACEFUL_KILL_MS);
         }
+        // Fallback: if neither close nor exit fires within 10s after taskkill,
+        // force-resolve to prevent the runner from hanging indefinitely.
+        // Only starts AFTER termination is requested — normal long tasks are unaffected.
+        fallbackTimer = setTimeout(() => {
+            try {
+                forceKill(child);
+            }
+            catch { }
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+            // Resolve the exit promise via the shared finish handle
+            if (childExitFinish)
+                childExitFinish(null);
+        }, 10000);
     };
     child.stdout?.on("data", (chunk) => {
         const text = chunk.toString("utf-8");
@@ -461,9 +631,19 @@ async function runManagedProcess(options) {
             if (settled)
                 return;
             settled = true;
+            if (fallbackTimer)
+                clearTimeout(fallbackTimer);
+            childExitFinish = null;
             resolveExit(code);
         };
+        childExitFinish = finish;
         child.once("close", (code) => finish(code));
+        child.once("exit", (code) => {
+            // On Windows, "close" can lag behind "exit" when stdio pipes drain
+            // after taskkill. Resolve on exit to avoid hanging the runner, but
+            // still let "close" fire if it arrives first.
+            finish(code);
+        });
         child.once("error", (error) => {
             spawnError = error.message;
             finish(null);
@@ -472,8 +652,8 @@ async function runManagedProcess(options) {
     clearInterval(heartbeatTimer);
     if (forceTimer)
         clearTimeout(forceTimer);
-    stdoutStream?.end();
-    stderrStream?.end();
+    stdoutStream?.destroy();
+    stderrStream?.destroy();
     writeTaskRuntime(options.taskDir, {
         phase: options.phase,
         last_heartbeat_at: new Date().toISOString(),
@@ -485,7 +665,7 @@ async function runManagedProcess(options) {
 }
 async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile, deadlineMs) {
     const config = getConfig();
-    const trusted = guardTestCommand(testCommand, config);
+    const trusted = guardTestCommand(testCommand, config, repoPath);
     const startedAtMs = Date.now();
     const startedAt = new Date(startedAtMs).toISOString();
     const parts = trusted.split(/\s+/).filter(Boolean);
@@ -518,28 +698,6 @@ async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile,
         duration_ms: finishedAtMs - startedAtMs,
     };
 }
-function buildExecutionPrompt(plan, repoPath, testCommand) {
-    let prompt = `You are executing a pre-written plan in a local repository.
-
-## Repository
-${repoPath}
-
-## Plan
-${plan}
-
-## Instructions
-1. Read the plan carefully.
-2. Implement the changes in this repository only.
-3. Do NOT modify files outside this repository.
-4. Do NOT commit or push changes.
-5. After implementing, describe what you changed.
-6. Output a summary with what was done, files modified, and issues encountered.
-`;
-    if (testCommand) {
-        prompt += `\n7. You may run ${testCommand}; PatchWarden will independently run it again for verification.`;
-    }
-    return prompt;
-}
 function buildTestLog(result) {
     if (result.skipped)
         return `${result.command || "(no test command)"}\nExit code: not run\n${result.stderr}\n`;
@@ -560,6 +718,40 @@ function buildResultMarkdown(input) {
     const outOfScope = input.outOfScopeChanges.length
         ? input.outOfScopeChanges.map((file) => `- ${file.change}: ${file.old_path ? `${file.old_path} -> ` : ""}${file.path}`).join("\n")
         : "(none)";
+    // Phase 6: Artifact manifest summary
+    const artifactCount = input.artifactManifest?.artifacts.length || 0;
+    const artifactLines = artifactCount > 0
+        ? input.artifactManifest.artifacts.map((a) => `- ${a.type}: ${a.path} (${a.size} bytes, sha256: ${a.sha256.slice(0, 16)}...)`).join("\n")
+        : "(no release artifacts)";
+    // Phase 6: Changed file group summary
+    const groupLines = input.changedFileGroups
+        ? [
+            `- source_changes: ${input.changedFileGroups.source_changes.length}`,
+            `- docs_changes: ${input.changedFileGroups.docs_changes.length}`,
+            `- config_changes: ${input.changedFileGroups.config_changes.length}`,
+            `- test_changes: ${input.changedFileGroups.test_changes.length}`,
+            `- release_artifacts: ${input.changedFileGroups.release_artifacts.length}`,
+            `- runtime_generated_files: ${input.changedFileGroups.runtime_generated_files.length}`,
+        ].join("\n")
+        : "";
+    // Phase 7: Android diagnostic summary
+    let androidSection = "";
+    if (input.androidDiagnostic && input.androidDiagnostic.status !== "skip") {
+        const checkLines = (input.androidDiagnostic.checks || [])
+            .map((c) => `- [${c.status}] ${c.check}: ${c.reason}`)
+            .join("\n");
+        androidSection = [
+            "## Android Build Environment",
+            `Status: ${input.androidDiagnostic.status}`,
+            ...(input.androidWarning ? [`Warning: ${input.androidWarning}`] : []),
+            checkLines,
+            "",
+        ].join("\n");
+    }
+    // Phase 4: Pre-existing warnings
+    const preexistingSection = input.preexistingWarnings && input.preexistingWarnings.length > 0
+        ? ["## Pre-existing Warnings", ...input.preexistingWarnings, ""].join("\n")
+        : "";
     return [
         "# PatchWarden Task Result",
         "",
@@ -578,6 +770,12 @@ function buildResultMarkdown(input) {
         "## Files changed",
         changed,
         "",
+        "## Changed file groups",
+        groupLines,
+        "",
+        "## Release artifacts",
+        artifactLines,
+        "",
         "## Verification",
         `- diff_available: ${input.changes.diff_available}`,
         `- diff_truncated: ${input.changes.diff_truncated}`,
@@ -586,10 +784,13 @@ function buildResultMarkdown(input) {
         `- verify_status: ${input.verify.status}`,
         `- verify_commands: ${input.verify.commands.length}/${input.verify.requested_commands.length} executed`,
         `- out_of_scope_changes: ${input.outOfScopeChanges.length}`,
+        `- artifact_status: ${input.artifactStatus || "collected"}`,
         "",
         "## Out-of-scope changes",
         outOfScope,
         "",
+        preexistingSection,
+        androidSection,
         "## Summary",
         input.error || "Agent execution and configured verification completed successfully.",
         "",
@@ -671,13 +872,13 @@ function buildVerifyLog(commands) {
         entry.stderr_tail || "(empty)",
     ].join("\n")).join("\n\n");
 }
-function normalizeVerifyCommands(value, legacyTestCommand, config) {
+function normalizeVerifyCommands(value, legacyTestCommand, config, repoPath) {
     if (value !== undefined && !Array.isArray(value)) {
         throw new Error("Invalid task verify_commands metadata; expected an array.");
     }
     return [...new Set([
-            ...(value || []).map((command) => guardTestCommand(String(command), config)),
-            ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config)] : []),
+            ...(value || []).map((command) => guardTestCommand(String(command), config, repoPath)),
+            ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config, repoPath)] : []),
         ])];
 }
 function summarizeOutput(value) {
@@ -695,8 +896,13 @@ function normalizeTimeout(value, config) {
     }
     return timeout;
 }
-function failBeforeExecution(taskId, taskDir, message) {
-    writeFileSync(join(taskDir, "error.log"), message, "utf-8");
+function failBeforeExecution(taskId, taskDir, message, caughtError) {
+    // Phase 9: Preserve PatchWardenError structured info in error.log
+    const structuredError = caughtError ? errorPayload(caughtError) : { error: message };
+    writeFileSync(join(taskDir, "error.log"), JSON.stringify({
+        summary: message,
+        ...structuredError,
+    }, null, 2), "utf-8");
     const current = readStatus(join(taskDir, "status.json"));
     const now = new Date().toISOString();
     const verify = {

package/dist/runner/simpleProcess.d.ts

@@ -0,0 +1,21 @@
+export interface SimpleProcessOptions {
+    command: string;
+    args: string[];
+    cwd: string;
+    timeoutMs: number;
+    maxStdoutBytes?: number;
+    maxStderrBytes?: number;
+    stdoutPath?: string;
+    stderrPath?: string;
+}
+export interface SimpleProcessResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    spawnError: string | null;
+    timedOut: boolean;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+}
+export declare function runSimpleProcessSync(options: SimpleProcessOptions): SimpleProcessResult;
+export declare function runSimpleProcess(options: SimpleProcessOptions): Promise<SimpleProcessResult>;