patchwarden 1.6.1 → 1.6.2

package/dist/assessments/securitySnapshot.d.ts

@@ -0,0 +1,50 @@
+import type { PatchWardenConfig } from "../config.js";
+import type { ProjectPolicy } from "../policy/projectPolicy.js";
+/**
+ * Version the security snapshot independently from the server/schema version.
+ * Changing the fields or their canonicalization should invalidate old records.
+ */
+export declare const ASSESSMENT_SECURITY_SNAPSHOT_VERSION = "assessment-security-v2";
+export type SecuritySnapshotCategory = "schema_epoch" | "tool_profile" | "tool_manifest" | "workspace_root" | "repo_boundary" | "agent_launch" | "allowed_commands" | "repo_allowed_test_commands" | "direct_allowed_commands" | "repo_direct_allowed_commands" | "sensitive_path_rules" | "protected_paths" | "project_policy" | "risk_rules" | "confirmation_policy" | "task_parameters" | "release_protection" | "direct_profile" | "assessment_ttl" | "timeout_policy";
+export interface AssessmentSecuritySnapshotInput {
+    config: PatchWardenConfig;
+    schemaEpoch: string;
+    toolProfile: string;
+    toolManifestSha256: string;
+    agent: string;
+    repoPath: string;
+    changePolicy?: string | null;
+    template?: string | null;
+    verifyCommands?: string[];
+    testCommand?: string | null;
+    taskTimeoutSeconds?: number | null;
+    scope?: string[];
+    forbidden?: string[];
+    verification?: string[];
+    doneEvidence?: string[];
+    riskRulesVersion?: string;
+    projectPolicy?: ProjectPolicy | null;
+    projectPolicyValid?: boolean | null;
+    projectPolicyIssues?: Array<{
+        code: string;
+        severity: string;
+        field: string;
+    }>;
+}
+export interface AssessmentSecuritySnapshot {
+    assessment_security_snapshot_version: string;
+    components: Record<SecuritySnapshotCategory, unknown>;
+}
+export interface AssessmentSecuritySnapshotComparison {
+    equal: boolean;
+    expected_hash: string;
+    actual_hash: string;
+    changed_field_names: SecuritySnapshotCategory[];
+}
+/** Build only security-relevant configuration; runtime state is deliberately absent. */
+export declare function buildAssessmentSecuritySnapshot(input: AssessmentSecuritySnapshotInput): AssessmentSecuritySnapshot;
+/** Recursively sort object keys while preserving array order where it matters. */
+export declare function canonicalizeAssessmentSecuritySnapshot(snapshot: AssessmentSecuritySnapshot): AssessmentSecuritySnapshot;
+export declare function hashAssessmentSecuritySnapshot(snapshot: AssessmentSecuritySnapshot): string;
+export declare function getAssessmentSecuritySnapshotComponentHashes(snapshot: AssessmentSecuritySnapshot): Record<SecuritySnapshotCategory, string>;
+export declare function compareAssessmentSecuritySnapshots(expected: AssessmentSecuritySnapshot, actual: AssessmentSecuritySnapshot): AssessmentSecuritySnapshotComparison;

package/dist/assessments/securitySnapshot.js

@@ -0,0 +1,158 @@
+import { createHash } from "node:crypto";
+import { resolve, win32 } from "node:path";
+import { getRepoAllowedTestCommands, getRepoDirectAllowedCommands } from "../config.js";
+import { stableJsonStringify } from "../utils/stableJson.js";
+/**
+ * Version the security snapshot independently from the server/schema version.
+ * Changing the fields or their canonicalization should invalidate old records.
+ */
+export const ASSESSMENT_SECURITY_SNAPSHOT_VERSION = "assessment-security-v2";
+function canonicalPath(value) {
+    const rawValue = String(value);
+    if (/^[a-z]:[\\/]/i.test(rawValue)) {
+        return win32.normalize(rawValue).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+    }
+    const normalized = resolve(rawValue).replace(/\\/g, "/").replace(/\/+$/, "");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function sortedUnique(values) {
+    return [...new Set((values || []).map((value) => String(value).trim()))]
+        .filter(Boolean)
+        .sort((left, right) => left.localeCompare(right));
+}
+function sortedUniqueTaskPaths(values) {
+    return sortedUnique(values?.map((value) => {
+        const normalized = String(value).replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/{2,}/g, "/");
+        return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+    }));
+}
+function sortedAgentConfig(config) {
+    return Object.fromEntries(Object.entries(config.agents)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, agent]) => [name, {
+            command: agent.command,
+            args: [...agent.args],
+            adapter: agent.adapter || null,
+            model: agent.model || null,
+            envAllowlist: sortedUnique(agent.envAllowlist),
+        }]));
+}
+/** Build only security-relevant configuration; runtime state is deliberately absent. */
+export function buildAssessmentSecuritySnapshot(input) {
+    const { config } = input;
+    const repoPath = canonicalPath(input.repoPath);
+    const components = {
+        schema_epoch: input.schemaEpoch,
+        tool_profile: input.toolProfile,
+        tool_manifest: input.toolManifestSha256,
+        workspace_root: canonicalPath(config.workspaceRoot),
+        repo_boundary: {
+            workspace_root: canonicalPath(config.workspaceRoot),
+            repo_path: repoPath,
+            repo_aliases: Object.fromEntries(Object.entries(config.repoAliases || {})
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, value]) => [key, canonicalPath(resolve(config.workspaceRoot, value))])),
+        },
+        agent_launch: {
+            selected_agent: input.agent,
+            configured_agents: sortedAgentConfig(config),
+        },
+        allowed_commands: {
+            configured: sortedUnique(config.allowedTestCommands),
+            project: sortedUnique(input.projectPolicy?.allowed_commands),
+        },
+        repo_allowed_test_commands: sortedUnique(getRepoAllowedTestCommands(config, repoPath)),
+        direct_allowed_commands: sortedUnique(config.directAllowedCommands),
+        repo_direct_allowed_commands: sortedUnique(getRepoDirectAllowedCommands(config, repoPath)),
+        sensitive_path_rules: "sensitive-path-rules-v1",
+        protected_paths: sortedUnique(input.projectPolicy?.protected_paths || [
+            ".env", ".env.*", ".ssh", ".npmrc", ".pypirc", "patchwarden.config.json",
+        ]),
+        project_policy: {
+            valid: input.projectPolicyValid ?? null,
+            effective_policy: input.projectPolicy || null,
+            issues: [...(input.projectPolicyIssues || [])]
+                .map((issue) => ({ code: issue.code, severity: issue.severity, field: issue.field }))
+                .sort((left, right) => stableJsonStringify(left).localeCompare(stableJsonStringify(right))),
+        },
+        risk_rules: {
+            implementation: input.riskRulesVersion || "risk-engine-v1",
+            project_high_risk_commands: sortedUnique(input.projectPolicy?.high_risk_commands),
+        },
+        confirmation_policy: {
+            change_policy: input.changePolicy || "repo_scoped_changes",
+            template: input.template || null,
+        },
+        task_parameters: {
+            test_command: input.testCommand || null,
+            verify_commands: sortedUnique(input.verifyCommands),
+            timeout_seconds: input.taskTimeoutSeconds ?? config.defaultTaskTimeoutSeconds,
+            scope: sortedUniqueTaskPaths(input.scope),
+            forbidden: sortedUniqueTaskPaths(input.forbidden),
+            verification: sortedUnique(input.verification),
+            done_evidence: sortedUniqueTaskPaths(input.doneEvidence),
+        },
+        release_protection: {
+            high_risk_commands: sortedUnique(input.projectPolicy?.high_risk_commands || [
+                "npm publish", "git push", "git tag", "gh release create",
+            ]),
+            release_mode: input.projectPolicy?.release_mode || {
+                version_source: "package.json",
+                required_commands: ["npm run build", "npm test"],
+            },
+            artifact_rules: "artifact-rules-v1",
+        },
+        direct_profile: Boolean(config.enableDirectProfile),
+        assessment_ttl: config.assessmentTtlSeconds,
+        timeout_policy: {
+            default_task_timeout_seconds: config.defaultTaskTimeoutSeconds,
+            max_task_timeout_seconds: config.maxTaskTimeoutSeconds,
+        },
+    };
+    return {
+        assessment_security_snapshot_version: ASSESSMENT_SECURITY_SNAPSHOT_VERSION,
+        components,
+    };
+}
+/** Recursively sort object keys while preserving array order where it matters. */
+export function canonicalizeAssessmentSecuritySnapshot(snapshot) {
+    const canonicalize = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonicalize);
+        if (value !== null && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, entry]) => [key, canonicalize(entry)]));
+        }
+        return value;
+    };
+    return canonicalize(snapshot);
+}
+export function hashAssessmentSecuritySnapshot(snapshot) {
+    return createHash("sha256")
+        .update(stableJsonStringify(canonicalizeAssessmentSecuritySnapshot(snapshot)))
+        .digest("hex");
+}
+export function getAssessmentSecuritySnapshotComponentHashes(snapshot) {
+    return Object.fromEntries(Object.entries(snapshot.components).map(([name, value]) => [
+        name,
+        createHash("sha256").update(stableJsonStringify(value)).digest("hex"),
+    ]));
+}
+export function compareAssessmentSecuritySnapshots(expected, actual) {
+    const expectedHash = hashAssessmentSecuritySnapshot(expected);
+    const actualHash = hashAssessmentSecuritySnapshot(actual);
+    const expectedComponents = getAssessmentSecuritySnapshotComponentHashes(expected);
+    const actualComponents = getAssessmentSecuritySnapshotComponentHashes(actual);
+    const changed = Object.keys(actualComponents)
+        .filter((name) => expectedComponents[name] !== actualComponents[name]);
+    if (expected.assessment_security_snapshot_version !== actual.assessment_security_snapshot_version) {
+        changed.unshift("schema_epoch");
+    }
+    return {
+        equal: expectedHash === actualHash,
+        expected_hash: expectedHash,
+        actual_hash: actualHash,
+        changed_field_names: [...new Set(changed)],
+    };
+}

package/dist/control/routes/status.d.ts

@@ -9,6 +9,20 @@ interface Suggestion {
     action?: string;
     link?: string;
 }
+export interface ConnectionSummary {
+    profile: string;
+    tool_profile: string | null;
+    ready: boolean;
+    tool_count: number | null;
+    tool_manifest_sha256: string | null;
+    tunnel_id_masked: string | null;
+    reconnect_guidance: string;
+}
+export declare function buildConnectionSummary(mode: "core" | "direct", tunnel: Record<string, unknown>, tools: {
+    tool_profile: string | null;
+    tool_count: number | null;
+    tool_manifest_sha256: string | null;
+}): ConnectionSummary;
 interface StatusSnapshotForSuggestions {
     core: RuntimeHealth;
     direct: RuntimeHealth;

package/dist/control/routes/status.js

@@ -13,6 +13,24 @@ import { redactSensitiveValue } from "../../security/contentRedaction.js";
 import { listAgentsSafe, listTasksForStatus, probeRuntimeHealth, readEvents, recordEvent, readToolManifest, readTunnelStatus, readTunnelUrl, readWatcherStatusSafe, resolveWorkspaceRootSafe, } from "../runtime.js";
 import { findTunnelClientExecutable } from "./process.js";
 import { config, configIdentitySha256, controlCenterStatusPath, CORE_BASE_URL, DIRECT_BASE_URL, errorMessage, readJsonFileSafe, sendJson, } from "../shared.js";
+export function buildConnectionSummary(mode, tunnel, tools) {
+    const masked = typeof tunnel.tunnel_id_masked === "string" && tunnel.tunnel_id_masked.includes("***")
+        ? tunnel.tunnel_id_masked
+        : null;
+    return {
+        profile: typeof tunnel.profile === "string"
+            ? tunnel.profile
+            : mode === "direct" ? "patchwarden-direct" : "patchwarden",
+        tool_profile: tools.tool_profile,
+        ready: tunnel.ready === true,
+        tool_count: tools.tool_count,
+        tool_manifest_sha256: tools.tool_manifest_sha256,
+        tunnel_id_masked: masked,
+        reconnect_guidance: mode === "direct"
+            ? "If ChatGPT still uses an older Direct Tunnel, update the connector binding and test health_check in a new chat."
+            : "If ChatGPT still uses an older Core Tunnel, update the connector binding and test health_check in a new chat.",
+    };
+}
 /**
  * Keep current readiness separate from historical evidence. A month-old failed
  * task is useful for audit, but must not make a configured local bridge look
@@ -197,6 +215,10 @@ export async function handleStatus(res) {
             watcher,
             tunnel: { core: tunnelCore, direct: tunnelDirect },
             tools: { core: toolsCore, direct: toolsDirect },
+            connections: {
+                core: buildConnectionSummary("core", tunnelCore, toolsCore),
+                direct: buildConnectionSummary("direct", tunnelDirect, toolsDirect),
+            },
             agents,
             workspace_root: workspaceRoot,
             tasks,

package/dist/control/runtime.js

@@ -19,6 +19,7 @@ import { isValidDirectSessionId as isValidStoredDirectSessionId } from "../direc
 import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
 import { withFileLockSync } from "../utils/lockedJsonFile.js";
 import { logger } from "../logging.js";
+import { TERMINAL_TASK_STATUSES as SHARED_TERMINAL_TASK_STATUSES } from "../tools/tasks/taskStates.js";
 import { config, controlCenterEventsPath, controlCenterStatusPath, errorMessage, getControlCenterLogDir, getRuntimeRoot, host, MAX_EVENT_LINES, port, readJsonFileSafe, } from "./shared.js";
 export function probeHealthStatus(targetUrl) {
     return new Promise((resolve) => {
@@ -158,16 +159,7 @@ export function resolveWorkspaceRootSafe() {
         return null;
     }
 }
-export const TERMINAL_TASK_STATUSES = new Set([
-    "done",
-    "done_by_agent",
-    "failed",
-    "failed_verification",
-    "failed_scope_violation",
-    "failed_policy_violation",
-    "canceled",
-    "timeout",
-]);
+export const TERMINAL_TASK_STATUSES = SHARED_TERMINAL_TASK_STATUSES;
 /**
  * Classify a task as stale based on Phase 2 rules:
  *  - status=running but last_heartbeat_at exceeds threshold

package/dist/control/server.js

@@ -53,6 +53,7 @@ async function handleRequest(req, res) {
         (pathname === "/colors_and_type.css" ||
             pathname === "/desktop.css" ||
             pathname === "/desktop-bridge.js" ||
+            pathname === "/log-parser.js" ||
             pathname === "/i18n.js" ||
             pathname === "/getting-started.js" ||
             pathname === "/settings.js" ||

package/dist/diagnostics/allowedTestCommandSafety.d.ts

@@ -0,0 +1 @@
+export declare function isDangerousAllowedTestCommand(command: string): boolean;

package/dist/diagnostics/allowedTestCommandSafety.js

@@ -0,0 +1,11 @@
+const DANGEROUS_ALLOWED_TEST_COMMAND_PATTERNS = [
+    /(^|\s)rm\s+-rf(?:\s|$)/i,
+    /(^|\s)del\s+\/s(?:\s|$)/i,
+    /(^|\s)format(?:\.exe)?(?:\s|$)/i,
+    /(^|\s)shutdown(?:\.exe)?(?:\s|$)/i,
+    /curl\s+[^\r\n|]*\|/i,
+    /wget\s+[^\r\n|]*\|/i,
+];
+export function isDangerousAllowedTestCommand(command) {
+    return DANGEROUS_ALLOWED_TEST_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}

package/dist/direct/directSessionStore.js

@@ -9,6 +9,10 @@ import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFil
 import { redactSensitiveContent } from "../security/contentRedaction.js";
 import { mutateLockedJsonFileSync, readJsonObjectFileSync, withFileLock, withFileLockSync, } from "../utils/lockedJsonFile.js";
 import { getLastToolCatalogSnapshot } from "../tools/catalog/toolCatalog.js";
+// Session history writes are metadata-only and may queue behind concurrent
+// Direct workers. Keep the wait bounded, while workspace mutation locks remain
+// fail-fast so an active patch is never hidden by retrying.
+const DIRECT_SESSION_RECORD_LOCK_WAIT_MS = 10_000;
 // ── ID generation ──────────────────────────────────────────────────
 export function generateDirectSessionId() {
     const timestamp = new Date()
@@ -222,10 +226,7 @@ function mutateDirectSessionRecord(sessionId, mutation, config = getConfig()) {
         const next = mutation(session);
         return { next, result: next };
     }, {
-        // Session-record appends are short serialized writes. Give Windows
-        // antivirus-delayed lock detachment enough time to finish instead of
-        // dropping concurrent operation or verification evidence.
-        waitMs: 10_000,
+        waitMs: DIRECT_SESSION_RECORD_LOCK_WAIT_MS,
         busyError: () => new PatchWardenError("direct_session_busy", `Direct session "${sessionId}" is currently being updated.`, "Retry after the current Direct operation completes.", true, { session_id: sessionId }),
     });
 }

package/dist/doctor.js

@@ -25,6 +25,7 @@ import { logger } from "./logging.js";
 import { unsafeWorkspaceRootLabel } from "./security/workspaceRootGuard.js";
 import { runSimpleProcessSync } from "./runner/simpleProcess.js";
 import { resolveAgentLaunch } from "./runner/agentInvocation.js";
+import { isDangerousAllowedTestCommand } from "./diagnostics/allowedTestCommandSafety.js";
 // ── Helpers ────────────────────────────────────────────────────────
 function cmd(command, args = []) {
     try {
@@ -552,12 +553,9 @@ const checkAllowedTestCommandsSafety = {
         const results = [];
         const testCmds = context.config.allowedTestCommands || [];
         results.push(checkResult("allowedTestCommands is non-empty", testCmds.length > 0, testCmds.length > 0 ? `${testCmds.length} commands` : "No test commands configured"));
-        const dangerous = ["rm -rf", "del /s", "format", "shutdown", "curl |", "wget |"];
         for (const cmdStr of testCmds) {
-            for (const danger of dangerous) {
-                if (cmdStr.toLowerCase().includes(danger)) {
-                    results.push(warnResult(`allowedTestCommands contains dangerous pattern: "${cmdStr}"`));
-                }
+            if (isDangerousAllowedTestCommand(cmdStr)) {
+                results.push(warnResult(`allowedTestCommands contains dangerous pattern: "${cmdStr}"`));
             }
         }
         return results;

package/dist/runner/runTask.d.ts

@@ -5,4 +5,5 @@ interface TaskRunResult {
     error: string | null;
 }
 export declare function runTask(taskId: string): Promise<TaskRunResult>;
+export declare function classifyAgentFailure(stderr: string): string | null;
 export {};

package/dist/runner/runTask.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
+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";
@@ -8,6 +9,7 @@ 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";
@@ -41,6 +43,7 @@ async function prepareTask(taskId) {
     if (!existsSync(statusFile))
         throw new Error(`Task not found: "${taskId}"`);
     const startedAtMs = Date.now();
+    const runnerInstanceId = randomUUID().replace(/-/g, "");
     const claim = claimPendingTask(statusFile, {
         status: "running",
         phase: "preparing",
@@ -93,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);
             }
         }
@@ -106,6 +113,8 @@ async function prepareTask(taskId) {
     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;
@@ -125,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",
@@ -154,6 +164,7 @@ 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,
@@ -167,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) {
@@ -189,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;
@@ -204,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) {
@@ -403,7 +419,7 @@ function finalizeTask(ctx, state, evidence) {
     }
     atomicWriteJsonFileSync(join(ctx.taskDir, "verify.json"), verifyJson);
     atomicWriteFileSync(join(ctx.taskDir, "verify.log"), buildVerifyLog(verifyJson.commands));
-    if (!["canceled", "done_by_agent", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(state.finalStatus))
+    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);
@@ -458,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,
@@ -507,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,
@@ -642,6 +666,9 @@ 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,
     });
     let stdout = "";
     let stderr = "";
@@ -757,7 +784,7 @@ async function runManagedProcess(options) {
         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();
@@ -779,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"),
     });
@@ -1117,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/taskRuntime.d.ts

@@ -4,6 +4,8 @@ export interface TaskRuntimeData {
     last_heartbeat_at: string;
     current_command: string | null;
     runner_pid?: number;
+    runner_instance_id?: string;
+    child_owned_by_runner_instance_id?: string;
     child_pid?: number;
     /**
      * v0.7.0: ISO timestamp when the child process was spawned.

package/dist/runner/taskStatusStore.js

@@ -1,10 +1,21 @@
 import { PatchWardenError } from "../errors.js";
 import { mutateLockedJsonFileSync, readJsonObjectFileSync, } from "../utils/lockedJsonFile.js";
+import { isAllowedTaskStatusTransition } from "../tools/tasks/taskStates.js";
 export function readTaskStatusFile(statusFile) {
     return readJsonObjectFileSync(statusFile);
 }
 export function mutateTaskStatus(statusFile, mutation) {
-    return mutateLockedJsonFileSync(statusFile, mutation, {
+    return mutateLockedJsonFileSync(statusFile, (current) => {
+        const outcome = mutation(current);
+        if (outcome.next) {
+            const from = String(current.status || "");
+            const to = String(outcome.next.status || from);
+            if (!isAllowedTaskStatusTransition(from, to)) {
+                throw new PatchWardenError("invalid_task_status_transition", `Task status cannot transition from "${from || "unknown"}" to "${to || "unknown"}".`, "Refresh the task status and apply only a forward lifecycle transition.");
+            }
+        }
+        return outcome;
+    }, {
         busyError: () => new PatchWardenError("task_status_busy", "Task status is currently being updated by another PatchWarden process.", "Retry the operation after the current task status update completes.", true),
     });
 }