patchwarden 1.5.1 → 1.6.2

package/dist/runner/runTask.js

@@ -1,17 +1,23 @@
 import { spawn, spawnSync } from "node:child_process";
-import { createWriteStream, existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { getTasksDir, getPlansDir, getConfig, resolveWorkspaceRoot } from "../config.js";
 import { guardPath, guardWorkspacePath } from "../security/pathGuard.js";
 import { guardTestCommand, } from "../security/commandGuard.js";
-import { writeTaskProgress } from "../taskProgress.js";
-import { writeTaskRuntime } from "../taskRuntime.js";
+import { writeTaskProgress } from "./taskProgress.js";
+import { writeTaskRuntime } from "./taskRuntime.js";
+import { claimPendingTask, readTaskStatusFile, updateTaskStatusFile, } from "./taskStatusStore.js";
 import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { recordAssessmentValidationFailure } from "../assessments/assessmentDiagnostics.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";
+import { ARTIFACT_SCHEMA_VERSION } from "../version.js";
+import { diagnoseAndroidBuild } from "../tools/workspace/androidDoctor.js";
 import { runPostTaskCleanup } from "./postTaskCleanup.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { allowedEnvironmentValues, buildChildEnvironment, redactProcessOutput, resolvePackageManagerInvocation, resolveTrustedExecutable, SecureProcessLogCapture, } from "./processSecurity.js";
 const HEARTBEAT_INTERVAL_MS = 2000;
 const GRACEFUL_KILL_MS = 2000;
 const MAX_CAPTURE_CHARS = 100_000;
@@ -36,7 +42,25 @@ async function prepareTask(taskId) {
     const statusFile = join(taskDir, "status.json");
     if (!existsSync(statusFile))
         throw new Error(`Task not found: "${taskId}"`);
-    const initialStatus = readStatus(statusFile);
+    const startedAtMs = Date.now();
+    const runnerInstanceId = randomUUID().replace(/-/g, "");
+    const claim = claimPendingTask(statusFile, {
+        status: "running",
+        phase: "preparing",
+        started_at: new Date(startedAtMs).toISOString(),
+        last_heartbeat_at: new Date(startedAtMs).toISOString(),
+        current_command: null,
+        error: null,
+    });
+    if (!claim.claimed) {
+        const currentStatus = String(claim.status.status || "failed");
+        return {
+            task_id: taskId,
+            status: currentStatus,
+            error: `Task is ${currentStatus}; only pending tasks can be claimed for execution.`,
+        };
+    }
+    const initialStatus = claim.status;
     const planId = String(initialStatus.plan_id || "");
     const agentName = String(initialStatus.agent || "");
     const rawRepoPath = String(initialStatus.resolved_repo_path || initialStatus.repo_path || wsRoot);
@@ -50,7 +74,6 @@ async function prepareTask(taskId) {
     catch (error) {
         return failBeforeExecution(taskId, taskDir, errorMessage(error), error);
     }
-    const startedAtMs = Date.now();
     const deadlineMs = startedAtMs + timeoutSeconds * 1000;
     let repoPath;
     try {
@@ -73,7 +96,11 @@ async function prepareTask(taskId) {
             const preExecSnapshot = await 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.`;
+                recordAssessmentValidationFailure(validation);
+                const changedFields = validation.config_change_categories?.length
+                    ? ` Changed fields: ${validation.config_change_categories.join(", ")}.`
+                    : "";
+                const message = `assessment validation failed: ${validation.failure_reason}.${changedFields} Re-run create_task with execution_mode=assess_only to get a fresh assessment_id.`;
                 return failBeforeExecution(taskId, taskDir, message);
             }
         }
@@ -82,18 +109,12 @@ async function prepareTask(taskId) {
             return failBeforeExecution(taskId, taskDir, message, error);
         }
     }
-    updateStatus(taskDir, {
-        status: "running",
-        phase: "preparing",
-        started_at: new Date(startedAtMs).toISOString(),
-        last_heartbeat_at: new Date().toISOString(),
-        timeout_seconds: timeoutSeconds,
-        current_command: null,
-        error: null,
-    });
+    updateStatus(taskDir, { timeout_seconds: timeoutSeconds });
     writeTaskRuntime(taskDir, {
         task_started_at: new Date(startedAtMs).toISOString(),
         watcher_instance_id: process.env.PATCHWARDEN_WATCHER_INSTANCE_ID || undefined,
+        runner_pid: process.pid,
+        runner_instance_id: runnerInstanceId,
     });
     setTaskPhase(taskDir, "preparing", null, "Capturing pre-task repository state.");
     let beforeSnapshot;
@@ -113,12 +134,13 @@ async function prepareTask(taskId) {
     return {
         taskId, taskDir, statusFile, repoPath, wsRoot, config, plansDir, initialStatus,
         planId, agentName, testCommand, changePolicy, verifyCommands, timeoutSeconds,
-        startedAtMs, deadlineMs, beforeSnapshot, beforeWorkspaceSnapshot, externalDirtyBaseline,
+        startedAtMs, deadlineMs, runnerInstanceId, beforeSnapshot, beforeWorkspaceSnapshot, externalDirtyBaseline,
     };
 }
 async function executeAgent(ctx) {
     const state = {
         agentResult: null,
+        agentFailureCategory: null,
         testResult: skippedTest(ctx.testCommand, ctx.repoPath, "Agent did not complete successfully."),
         verifyResults: [],
         finalStatus: "failed",
@@ -142,8 +164,11 @@ async function executeAgent(ctx) {
             phase: "executing_agent",
             currentCommand: invocation.commandLabel,
             deadlineMs: ctx.deadlineMs,
+            runnerInstanceId: ctx.runnerInstanceId,
             stdoutPath: join(ctx.taskDir, "stdout.log"),
             stderrPath: join(ctx.taskDir, "stderr.log"),
+            environmentVariableNames: invocation.environmentVariableNames,
+            blockedEnvironmentVariableNames: invocation.blockedEnvironmentVariableNames,
         });
         const agentResult = state.agentResult;
         if (agentResult.terminationReason === "canceled" || agentResult.terminationReason === "killed") {
@@ -153,13 +178,17 @@ async function executeAgent(ctx) {
                 : "Task was canceled by user request.";
         }
         else if (agentResult.terminationReason === "timeout") {
+            state.finalStatus = "timeout";
             state.finalError = `Task timed out after ${ctx.timeoutSeconds} seconds during agent execution.`;
         }
         else if (agentResult.spawnError) {
             state.finalError = `Agent spawn failed: ${agentResult.spawnError}`;
         }
         else if (agentResult.exitCode !== 0) {
-            state.finalError = `Agent exited with code ${agentResult.exitCode}.`;
+            state.agentFailureCategory = classifyAgentFailure(agentResult.stderr);
+            state.finalError = state.agentFailureCategory
+                ? `Agent provider failure (${state.agentFailureCategory}); process exited with code ${agentResult.exitCode}.`
+                : `Agent exited with code ${agentResult.exitCode}.`;
         }
     }
     catch (error) {
@@ -175,7 +204,7 @@ async function runVerification(ctx, state) {
         if (ctx.verifyCommands.length > 0) {
             for (const command of ctx.verifyCommands) {
                 setTaskPhase(ctx.taskDir, "running_tests", command);
-                const verification = await runTrustedTestCommand(command, ctx.repoPath, ctx.taskDir, ctx.statusFile, ctx.deadlineMs);
+                const verification = await runTrustedTestCommand(command, ctx.repoPath, ctx.taskDir, ctx.statusFile, ctx.deadlineMs, ctx.runnerInstanceId);
                 state.verifyResults.push(verification);
                 if (verification.terminationReason || Date.now() >= ctx.deadlineMs)
                     break;
@@ -190,6 +219,7 @@ async function runVerification(ctx, state) {
                     : "Task was canceled during verification.";
             }
             else if (interrupted?.terminationReason === "timeout" || Date.now() >= ctx.deadlineMs) {
+                state.finalStatus = "timeout";
                 state.finalError = `Task timed out after ${ctx.timeoutSeconds} seconds during verification.`;
             }
             else if (failedVerification) {
@@ -229,7 +259,7 @@ async function collectArtifacts(ctx, state) {
                 skipped: [{ path: ".", reason: "post_task_cleanup", skip_reason: errorMessage(error) }],
                 source_files_touched: 0,
             };
-            writeFileSync(join(ctx.taskDir, "post-task-cleanup.json"), JSON.stringify(cleanupReport, null, 2), "utf-8");
+            atomicWriteJsonFileSync(join(ctx.taskDir, "post-task-cleanup.json"), cleanupReport);
             updateStatus(ctx.taskDir, { cleanup: cleanupReport });
         }
     }
@@ -239,24 +269,16 @@ async function collectArtifacts(ctx, state) {
     let artifactStatus = "collected";
     let artifactCollectionError = null;
     let timeoutHandle;
+    const artifactController = new AbortController();
     try {
-        const collectionResult = await Promise.race([
-            Promise.resolve().then(async () => {
-                const afterSnapshot = await captureRepoSnapshot(ctx.repoPath);
-                writeSnapshot(ctx.taskDir, "git-after.json", afterSnapshot);
-                return await buildChangeArtifacts(ctx.repoPath, ctx.beforeSnapshot, afterSnapshot);
-            }),
-            new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => reject(new Error("Artifact collection timed out")), ARTIFACT_COLLECTION_TIMEOUT_MS);
-            }),
-        ]);
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        changes = collectionResult;
+        timeoutHandle = setTimeout(() => {
+            artifactController.abort(new Error("Artifact collection timed out"));
+        }, ARTIFACT_COLLECTION_TIMEOUT_MS);
+        const afterSnapshot = await captureRepoSnapshot(ctx.repoPath, artifactController.signal);
+        writeSnapshot(ctx.taskDir, "git-after.json", afterSnapshot);
+        changes = await buildChangeArtifacts(ctx.repoPath, ctx.beforeSnapshot, afterSnapshot, artifactController.signal);
     }
     catch (error) {
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
         state.lastCaughtError = error;
         artifactCollectionError = errorMessage(error);
         artifactStatus = artifactCollectionError.includes("timed out") ? "timeout" : "failed";
@@ -275,7 +297,7 @@ async function collectArtifacts(ctx, state) {
             unavailable_reason: `Change capture failed: ${artifactCollectionError}`,
             artifact_hygiene: emptyArtifactHygiene(),
         };
-        writeFileSync(join(ctx.taskDir, "partial_result.md"), [
+        atomicWriteFileSync(join(ctx.taskDir, "partial_result.md"), [
             "# PatchWarden Partial Result",
             "",
             `Task: ${ctx.taskId}`,
@@ -295,7 +317,7 @@ async function collectArtifacts(ctx, state) {
             "## 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");
+        ].join("\n"));
         if (state.finalStatus === "done_by_agent") {
             state.finalError = `Change capture failed: ${artifactCollectionError}`;
             state.finalStatus = "failed";
@@ -304,6 +326,10 @@ async function collectArtifacts(ctx, state) {
             state.finalError ||= `Change capture failed: ${artifactCollectionError}`;
         }
     }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
     const artifactCollectionFinishedAt = new Date().toISOString();
     let outOfScopeChanges = [];
     const preexistingExternalDirty = ctx.externalDirtyBaseline;
@@ -326,18 +352,18 @@ async function collectArtifacts(ctx, state) {
         ? [`Pre-existing external dirty files (not caused by this task): ${preexistingExternalDirty.length} file(s)`]
         : [];
     applyScopeViolationVerdict(ctx, state, changes, newOutOfScopeChanges, preexistingExternalDirty);
-    writeFileSync(join(ctx.taskDir, "git.diff"), changes.diff, "utf-8");
-    writeFileSync(join(ctx.taskDir, "diff.patch"), changes.diff, "utf-8");
-    writeFileSync(join(ctx.taskDir, "changed-files.json"), JSON.stringify(changes, null, 2), "utf-8");
+    atomicWriteFileSync(join(ctx.taskDir, "git.diff"), changes.diff);
+    atomicWriteFileSync(join(ctx.taskDir, "diff.patch"), changes.diff);
+    atomicWriteJsonFileSync(join(ctx.taskDir, "changed-files.json"), { schema_version: ARTIFACT_SCHEMA_VERSION, ...changes });
     const artifactManifest = await buildArtifactManifest(changes.changed_files, ctx.repoPath, ctx.taskId);
-    writeFileSync(join(ctx.taskDir, "artifact_manifest.json"), JSON.stringify(artifactManifest, null, 2), "utf-8");
+    atomicWriteJsonFileSync(join(ctx.taskDir, "artifact_manifest.json"), artifactManifest);
     const changedFileGroups = groupChangedFiles(changes.changed_files);
-    writeFileSync(join(ctx.taskDir, "file-stats.json"), JSON.stringify({
+    atomicWriteJsonFileSync(join(ctx.taskDir, "file-stats.json"), {
         task_id: ctx.taskId,
         additions: changes.additions,
         deletions: changes.deletions,
         files: changes.file_stats,
-    }, null, 2), "utf-8");
+    });
     return {
         changes, artifactStatus, artifactCollectionError, artifactCollectionStartedAt, artifactCollectionFinishedAt,
         outOfScopeChanges, newOutOfScopeChanges, preexistingExternalDirty, preexistingWarnings, cleanupReport,
@@ -348,15 +374,15 @@ function applyScopeViolationVerdict(ctx, state, changes, newOutOfScopeChanges, p
     if (newOutOfScopeChanges.length > 0) {
         state.finalStatus = "failed_scope_violation";
         state.finalError = `Detected ${newOutOfScopeChanges.length} new change(s) outside resolved_repo_path during task execution.`;
-        writeFileSync(join(ctx.taskDir, "rollback-plan.json"), JSON.stringify({
+        atomicWriteJsonFileSync(join(ctx.taskDir, "rollback-plan.json"), {
             task_id: ctx.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: newOutOfScopeChanges,
             preexisting_external_dirty_files: preexistingExternalDirty,
-        }, null, 2), "utf-8");
-        writeFileSync(join(ctx.taskDir, "rollback_scope_violation_plan.md"), [
+        });
+        atomicWriteFileSync(join(ctx.taskDir, "rollback_scope_violation_plan.md"), [
             "# Scope Violation Rollback Plan",
             "",
             `Task: ${ctx.taskId}`,
@@ -366,7 +392,11 @@ function applyScopeViolationVerdict(ctx, state, changes, newOutOfScopeChanges, p
             "## New out-of-scope files (caused by this task)",
             ...newOutOfScopeChanges.map((file) => `- ${file.change}: ${file.path}`),
             "",
-        ].join("\n"), "utf-8");
+        ].join("\n"));
+    }
+    else if (changes.diff_redacted) {
+        state.finalStatus = "failed_policy_violation";
+        state.finalError = "Credential-like content was detected in the task diff. PatchWarden redacted the evidence; remove the sensitive content before retrying.";
     }
     else if (ctx.changePolicy === "no_changes" && changes.changed_files.length > 0) {
         state.finalStatus = "failed_policy_violation";
@@ -375,7 +405,7 @@ function applyScopeViolationVerdict(ctx, state, changes, newOutOfScopeChanges, p
 }
 function finalizeTask(ctx, state, evidence) {
     const { changes, artifactStatus, artifactCollectionError, artifactCollectionStartedAt, artifactCollectionFinishedAt, outOfScopeChanges, newOutOfScopeChanges, preexistingExternalDirty, preexistingWarnings, cleanupReport, artifactManifest, changedFileGroups } = evidence;
-    writeFileSync(join(ctx.taskDir, "test.log"), buildTestLog(state.testResult), "utf-8");
+    atomicWriteFileSync(join(ctx.taskDir, "test.log"), buildTestLog(state.testResult));
     const verifyJson = buildVerifyJson(ctx.verifyCommands, state.verifyResults, ctx.repoPath);
     if (newOutOfScopeChanges.length > 0) {
         verifyJson.status = "failed";
@@ -383,11 +413,13 @@ function finalizeTask(ctx, state, evidence) {
     }
     else if (state.finalStatus === "failed_policy_violation") {
         verifyJson.status = "failed";
-        verifyJson.failure_reason = "change_policy_violation";
+        verifyJson.failure_reason = changes.diff_redacted
+            ? "sensitive_content_violation"
+            : "change_policy_violation";
     }
-    writeFileSync(join(ctx.taskDir, "verify.json"), JSON.stringify(verifyJson, null, 2), "utf-8");
-    writeFileSync(join(ctx.taskDir, "verify.log"), buildVerifyLog(verifyJson.commands), "utf-8");
-    if (!["canceled", "done_by_agent", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(state.finalStatus))
+    atomicWriteJsonFileSync(join(ctx.taskDir, "verify.json"), verifyJson);
+    atomicWriteFileSync(join(ctx.taskDir, "verify.log"), buildVerifyLog(verifyJson.commands));
+    if (!["canceled", "timeout", "done_by_agent", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(state.finalStatus))
         state.finalStatus = "failed";
     const finalPhase = state.finalStatus === "done_by_agent" ? "done_by_agent" : state.finalStatus;
     const followup = buildFailureFollowup(state.finalStatus, state.finalError, verifyJson.commands);
@@ -422,17 +454,17 @@ function finalizeTask(ctx, state, evidence) {
         androidWarning,
         preexistingWarnings,
     });
-    writeFileSync(join(ctx.taskDir, "result.md"), resultMd, "utf-8");
+    atomicWriteFileSync(join(ctx.taskDir, "result.md"), resultMd);
     const resultJson = buildResultJson({
         ctx, state, evidence, verifyJson, followup, androidDiagnostic, androidWarning,
     });
-    writeFileSync(join(ctx.taskDir, "result.json"), JSON.stringify(resultJson, null, 2), "utf-8");
+    atomicWriteJsonFileSync(join(ctx.taskDir, "result.json"), resultJson);
     if (state.finalError) {
         const structuredError = errorPayload(state.lastCaughtError);
-        writeFileSync(join(ctx.taskDir, "error.log"), JSON.stringify({
+        atomicWriteJsonFileSync(join(ctx.taskDir, "error.log"), {
             summary: state.finalError,
             ...structuredError,
-        }, null, 2), "utf-8");
+        });
     }
     const finishedAt = new Date().toISOString();
     updateStatus(ctx.taskDir, {
@@ -442,6 +474,10 @@ function finalizeTask(ctx, state, evidence) {
         last_heartbeat_at: finishedAt,
         finished_at: finishedAt,
         error: state.finalError,
+        termination_reason: state.finalStatus === "timeout"
+            ? "timeout"
+            : state.finalStatus === "canceled" ? "canceled" : null,
+        agent_failure_category: state.agentFailureCategory,
         changed_files: changes.changed_files.map(({ path, change }) => ({ path, change })),
         artifact_hygiene_counts: changes.artifact_hygiene.counts,
         artifact_status: artifactStatus,
@@ -456,6 +492,8 @@ function finalizeTask(ctx, state, evidence) {
         verify_commands: ctx.verifyCommands,
         diff_available: changes.diff_available,
         diff_truncated: changes.diff_truncated,
+        diff_redacted: changes.diff_redacted === true,
+        diff_redaction_categories: changes.diff_redaction_categories ?? [],
         workspace_dirty_before: changes.workspace_dirty_before,
         workspace_dirty_after: changes.workspace_dirty_after,
         workspace_dirty: changes.workspace_dirty_after,
@@ -478,6 +516,7 @@ function buildResultJson(input) {
     const { ctx, state, evidence, verifyJson, followup, androidDiagnostic, androidWarning } = input;
     const { changes, artifactStatus, artifactCollectionError, artifactCollectionStartedAt, artifactCollectionFinishedAt, outOfScopeChanges, newOutOfScopeChanges, preexistingExternalDirty, cleanupReport, artifactManifest, changedFileGroups } = evidence;
     return {
+        schema_version: ARTIFACT_SCHEMA_VERSION,
         task_id: ctx.taskId,
         status: state.finalStatus,
         agent: ctx.agentName,
@@ -488,6 +527,10 @@ function buildResultJson(input) {
         template: ctx.initialStatus.template || null,
         change_policy: ctx.changePolicy,
         summary: state.finalError || "Agent execution and configured verification completed successfully.",
+        termination_reason: state.finalStatus === "timeout"
+            ? "timeout"
+            : state.finalStatus === "canceled" ? "canceled" : null,
+        agent_failure_category: state.agentFailureCategory,
         changed_files: changes.changed_files,
         changed_file_groups: {
             source_changes: changedFileGroups.source_changes.length,
@@ -527,6 +570,9 @@ function buildResultJson(input) {
         warnings: [
             ...ctx.beforeSnapshot.warnings,
             ...(changes.diff_truncated ? ["diff.patch was truncated; changed-files.json retains file evidence."] : []),
+            ...(changes.diff_redacted ? [
+                `Credential-like diff content was redacted (${(changes.diff_redaction_categories ?? []).join(", ") || "sensitive_content"}).`,
+            ] : []),
             ...evidence.preexistingWarnings,
             ...(androidWarning ? [androidWarning] : []),
         ],
@@ -594,13 +640,22 @@ async function runManagedProcess(options) {
     if (Date.now() >= options.deadlineMs) {
         return { exitCode: null, stdout: "", stderr: "", spawnError: null, terminationReason: "timeout" };
     }
+    const exactRedactionValues = allowedEnvironmentValues(options.environmentVariableNames);
+    const logCapture = new SecureProcessLogCapture([options.stdoutPath, options.stderrPath], options.maxLogBytes);
     let child;
     try {
-        child = spawn(options.command, options.args, {
+        const env = buildChildEnvironment({
+            cwd: options.cwd,
+            allowedNames: options.environmentVariableNames,
+            blockedNames: options.blockedEnvironmentVariableNames,
+        });
+        const command = resolveTrustedExecutable(options.command, options.cwd, { pathValue: env.PATH });
+        child = spawn(command, options.args, {
             cwd: options.cwd,
             stdio: ["ignore", "pipe", "pipe"],
             detached: process.platform !== "win32",
             windowsHide: true,
+            env,
         });
     }
     catch (error) {
@@ -611,9 +666,10 @@ async function runManagedProcess(options) {
     writeTaskRuntime(options.taskDir, {
         child_pid: child.pid,
         child_started_at: new Date().toISOString(),
+        runner_pid: process.pid,
+        runner_instance_id: options.runnerInstanceId,
+        child_owned_by_runner_instance_id: options.runnerInstanceId,
     });
-    const stdoutStream = openStream(options.stdoutPath);
-    const stderrStream = openStream(options.stderrPath);
     let stdout = "";
     let stderr = "";
     let spawnError = null;
@@ -680,12 +736,12 @@ async function runManagedProcess(options) {
     child.stdout?.on("data", (chunk) => {
         const text = chunk.toString("utf-8");
         stdout = appendBounded(stdout, text);
-        stdoutStream?.write(text);
+        logCapture.append(options.stdoutPath, chunk);
     });
     child.stderr?.on("data", (chunk) => {
         const text = chunk.toString("utf-8");
         stderr = appendBounded(stderr, text);
-        stderrStream?.write(text);
+        logCapture.append(options.stderrPath, chunk);
     });
     heartbeat();
     const heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL_MS);
@@ -702,12 +758,6 @@ async function runManagedProcess(options) {
         };
         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);
@@ -716,8 +766,7 @@ async function runManagedProcess(options) {
     clearInterval(heartbeatTimer);
     if (forceTimer)
         clearTimeout(forceTimer);
-    stdoutStream?.destroy();
-    stderrStream?.destroy();
+    logCapture.flush(exactRedactionValues);
     writeTaskRuntime(options.taskDir, {
         phase: options.phase,
         last_heartbeat_at: new Date().toISOString(),
@@ -725,9 +774,17 @@ async function runManagedProcess(options) {
         runner_pid: process.pid,
         child_pid: undefined,
     });
-    return { exitCode, stdout, stderr, spawnError, terminationReason };
+    const safeStdout = redactProcessOutput(stdout, exactRedactionValues);
+    const safeStderr = redactProcessOutput(stderr, exactRedactionValues);
+    return {
+        exitCode,
+        stdout: safeStdout.length > MAX_CAPTURE_CHARS ? safeStdout.slice(-MAX_CAPTURE_CHARS) : safeStdout,
+        stderr: safeStderr.length > MAX_CAPTURE_CHARS ? safeStderr.slice(-MAX_CAPTURE_CHARS) : safeStderr,
+        spawnError,
+        terminationReason,
+    };
 }
-async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile, deadlineMs) {
+async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile, deadlineMs, runnerInstanceId) {
     const config = getConfig();
     const trusted = guardTestCommand(testCommand, config, repoPath);
     const startedAtMs = Date.now();
@@ -736,9 +793,9 @@ async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile,
     let command = parts[0];
     let args = parts.slice(1);
     if (process.platform === "win32" && /^(npm|npm\.cmd|pnpm|pnpm\.cmd)$/i.test(command)) {
-        const shim = /^pnpm/i.test(command) ? "pnpm.cmd" : "npm.cmd";
-        command = process.env.ComSpec || "cmd.exe";
-        args = ["/d", "/s", "/c", shim, ...args];
+        const packageManager = resolvePackageManagerInvocation(command, repoPath);
+        command = packageManager.command;
+        args = [...packageManager.argsPrefix, ...args];
     }
     const result = await runManagedProcess({
         command,
@@ -749,6 +806,7 @@ async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile,
         phase: "running_tests",
         currentCommand: trusted,
         deadlineMs,
+        runnerInstanceId,
         stdoutPath: join(taskDir, "test.stdout.log"),
         stderrPath: join(taskDir, "test.stderr.log"),
     });
@@ -963,10 +1021,10 @@ function normalizeTimeout(value, config) {
 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({
+    atomicWriteJsonFileSync(join(taskDir, "error.log"), {
         summary: message,
         ...structuredError,
-    }, null, 2), "utf-8");
+    });
     const current = readStatus(join(taskDir, "status.json"));
     const now = new Date().toISOString();
     const verify = {
@@ -974,17 +1032,17 @@ function failBeforeExecution(taskId, taskDir, message, caughtError) {
         requested_commands: Array.isArray(current.verify_commands) ? current.verify_commands : [],
         commands: [],
     };
-    writeFileSync(join(taskDir, "verify.json"), JSON.stringify(verify, null, 2), "utf-8");
-    writeFileSync(join(taskDir, "verify.log"), `Verification did not run: ${message}\n`, "utf-8");
-    writeFileSync(join(taskDir, "test.log"), `(not run)\nExit code: not run\n${message}\n`, "utf-8");
-    writeFileSync(join(taskDir, "git.diff"), "(task failed before change capture)\n", "utf-8");
-    writeFileSync(join(taskDir, "diff.patch"), "(task failed before change capture)\n", "utf-8");
-    writeFileSync(join(taskDir, "file-stats.json"), JSON.stringify({
+    atomicWriteJsonFileSync(join(taskDir, "verify.json"), verify);
+    atomicWriteFileSync(join(taskDir, "verify.log"), `Verification did not run: ${message}\n`);
+    atomicWriteFileSync(join(taskDir, "test.log"), `(not run)\nExit code: not run\n${message}\n`);
+    atomicWriteFileSync(join(taskDir, "git.diff"), "(task failed before change capture)\n");
+    atomicWriteFileSync(join(taskDir, "diff.patch"), "(task failed before change capture)\n");
+    atomicWriteJsonFileSync(join(taskDir, "file-stats.json"), {
         task_id: taskId,
         additions: 0,
         deletions: 0,
         files: [],
-    }, null, 2), "utf-8");
+    });
     const result = {
         task_id: taskId,
         status: "failed",
@@ -1010,8 +1068,8 @@ function failBeforeExecution(taskId, taskDir, message, caughtError) {
         safe_followup_prompt: "Inspect result.json and error.log, correct the task metadata or configuration, and retry without widening repository scope.",
         next_steps: ["Fix task metadata or configuration and retry the task."],
     };
-    writeFileSync(join(taskDir, "result.json"), JSON.stringify(result, null, 2), "utf-8");
-    writeFileSync(join(taskDir, "result.md"), `# PatchWarden Task Result\n\n## Status\nfailed\n\n## Summary\n${message}\n`, "utf-8");
+    atomicWriteJsonFileSync(join(taskDir, "result.json"), result);
+    atomicWriteFileSync(join(taskDir, "result.md"), `# PatchWarden Task Result\n\n## Status\nfailed\n\n## Summary\n${message}\n`);
     updateStatus(taskDir, {
         status: "failed",
         phase: "failed",
@@ -1037,12 +1095,10 @@ function setTaskPhase(taskDir, phase, currentCommand, note) {
 }
 function updateStatus(taskDir, patch) {
     const statusFile = join(taskDir, "status.json");
-    const current = readStatus(statusFile);
-    const next = { ...current, ...patch, updated_at: new Date().toISOString() };
-    writeFileSync(statusFile, JSON.stringify(next, null, 2), "utf-8");
+    updateTaskStatusFile(statusFile, patch);
 }
 function readStatus(statusFile) {
-    return JSON.parse(readFileSync(statusFile, "utf-8"));
+    return readTaskStatusFile(statusFile);
 }
 function gracefulKill(child) {
     try {
@@ -1058,10 +1114,13 @@ function forceKill(child) {
         return;
     try {
         if (process.platform === "win32") {
-            const result = spawnSync("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+            const systemRoot = process.env.SystemRoot || process.env.WINDIR || "C:\\Windows";
+            const taskkill = resolveTrustedExecutable(`${systemRoot}\\System32\\taskkill.exe`, process.cwd());
+            const result = spawnSync(taskkill, ["/PID", String(child.pid), "/T", "/F"], {
                 stdio: "ignore",
                 timeout: 5000,
                 windowsHide: true,
+                env: buildChildEnvironment({ cwd: process.cwd() }),
             });
             if (result.status !== 0)
                 child.kill("SIGKILL");
@@ -1077,9 +1136,6 @@ function forceKill(child) {
         catch { } // cleanup failure is safe to ignore
     }
 }
-function openStream(path) {
-    return path ? createWriteStream(path, { flags: "a" }) : null;
-}
 function appendBounded(current, next) {
     const combined = current + next;
     return combined.length <= MAX_CAPTURE_CHARS
@@ -1089,3 +1145,16 @@ function appendBounded(current, next) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+export function classifyAgentFailure(stderr) {
+    const normalized = stderr.toLowerCase();
+    if (normalized.includes("insufficient balance") || normalized.includes("insufficient credits")) {
+        return "provider_insufficient_balance";
+    }
+    if (normalized.includes("unauthorized") || normalized.includes("authentication failed") || normalized.includes("invalid api key")) {
+        return "provider_authentication_failed";
+    }
+    if (normalized.includes("model not found") || normalized.includes("model access") || normalized.includes("permission denied")) {
+        return "provider_model_unavailable";
+    }
+    return null;
+}

package/dist/runner/simpleProcess.d.ts

@@ -7,6 +7,9 @@ export interface SimpleProcessOptions {
     maxStderrBytes?: number;
     stdoutPath?: string;
     stderrPath?: string;
+    environmentVariableNames?: string[];
+    blockedEnvironmentVariableNames?: string[];
+    maxLogBytes?: number;
 }
 export interface SimpleProcessResult {
     exitCode: number | null;