patchwarden 1.6.1 → 1.6.2

package/src/assessments/securitySnapshot.ts

@@ -0,0 +1,231 @@
+import { createHash } from "node:crypto";
+import { resolve, win32 } from "node:path";
+import type { PatchWardenConfig } from "../config.js";
+import { getRepoAllowedTestCommands, getRepoDirectAllowedCommands } from "../config.js";
+import { stableJsonStringify } from "../utils/stableJson.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 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[];
+}
+
+function canonicalPath(value: string): string {
+  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: readonly string[] | undefined): string[] {
+  return [...new Set((values || []).map((value) => String(value).trim()))]
+    .filter(Boolean)
+    .sort((left, right) => left.localeCompare(right));
+}
+
+function sortedUniqueTaskPaths(values: readonly string[] | undefined): string[] {
+  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: PatchWardenConfig): Record<string, unknown> {
+  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: AssessmentSecuritySnapshotInput): AssessmentSecuritySnapshot {
+  const { config } = input;
+  const repoPath = canonicalPath(input.repoPath);
+  const components: Record<SecuritySnapshotCategory, unknown> = {
+    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: AssessmentSecuritySnapshot): AssessmentSecuritySnapshot {
+  const canonicalize = (value: unknown): unknown => {
+    if (Array.isArray(value)) return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, canonicalize(entry)]));
+    }
+    return value;
+  };
+  return canonicalize(snapshot) as AssessmentSecuritySnapshot;
+}
+
+export function hashAssessmentSecuritySnapshot(snapshot: AssessmentSecuritySnapshot): string {
+  return createHash("sha256")
+    .update(stableJsonStringify(canonicalizeAssessmentSecuritySnapshot(snapshot)))
+    .digest("hex");
+}
+
+export function getAssessmentSecuritySnapshotComponentHashes(
+  snapshot: AssessmentSecuritySnapshot,
+): Record<SecuritySnapshotCategory, string> {
+  return Object.fromEntries(Object.entries(snapshot.components).map(([name, value]) => [
+    name,
+    createHash("sha256").update(stableJsonStringify(value)).digest("hex"),
+  ])) as Record<SecuritySnapshotCategory, string>;
+}
+
+export function compareAssessmentSecuritySnapshots(
+  expected: AssessmentSecuritySnapshot,
+  actual: AssessmentSecuritySnapshot,
+): AssessmentSecuritySnapshotComparison {
+  const expectedHash = hashAssessmentSecuritySnapshot(expected);
+  const actualHash = hashAssessmentSecuritySnapshot(actual);
+  const expectedComponents = getAssessmentSecuritySnapshotComponentHashes(expected);
+  const actualComponents = getAssessmentSecuritySnapshotComponentHashes(actual);
+  const changed = (Object.keys(actualComponents) as SecuritySnapshotCategory[])
+    .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/src/control/routes/status.ts

@@ -52,6 +52,39 @@ interface Suggestion {
   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 function buildConnectionSummary(
+  mode: "core" | "direct",
+  tunnel: Record<string, unknown>,
+  tools: { tool_profile: string | null; tool_count: number | null; tool_manifest_sha256: string | null },
+): ConnectionSummary {
+  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.",
+  };
+}
+
 interface StatusSnapshotForSuggestions {
   core: RuntimeHealth;
   direct: RuntimeHealth;
@@ -290,6 +323,10 @@ export async function handleStatus(res: ServerResponse): Promise<void> {
       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/src/control/runtime.ts

@@ -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,
@@ -204,16 +205,7 @@ export interface StaleClassification {
   stale_reasons: string[];
 }
 
-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:

package/src/control/server.ts

@@ -68,6 +68,7 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
     (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/src/diagnostics/allowedTestCommandSafety.ts

@@ -0,0 +1,12 @@
+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: string): boolean {
+  return DANGEROUS_ALLOWED_TEST_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}

package/src/direct/directSessionStore.ts

@@ -27,6 +27,11 @@ import {
   type ChangeArtifacts,
 } from "../runner/changeCapture.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;
+
 // ── Types ──────────────────────────────────────────────────────────
 
 export interface DirectSessionOperation {
@@ -423,10 +428,7 @@ function mutateDirectSessionRecord(
       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.`,

package/src/doctor.ts

@@ -26,6 +26,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";
 
 // ── Types ──────────────────────────────────────────────────────────
 
@@ -655,12 +656,9 @@ const checkAllowedTestCommandsSafety: DoctorCheck = {
     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/src/runner/runTask.ts

@@ -1,4 +1,5 @@
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import {
   existsSync,
   readFileSync,
@@ -18,6 +19,7 @@ import {
   type TaskStatusRecord,
 } from "./taskStatusStore.js";
 import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { recordAssessmentValidationFailure } from "../assessments/assessmentDiagnostics.js";
 import { buildAgentInvocation, buildExecutionPrompt } from "./agentInvocation.js";
 import type { TaskPhase, TaskStatus } from "../tools/tasks/createTask.js";
 import {
@@ -117,6 +119,7 @@ interface TaskContext {
   timeoutSeconds: number;
   startedAtMs: number;
   deadlineMs: number;
+  runnerInstanceId: string;
   beforeSnapshot: RepoSnapshot;
   beforeWorkspaceSnapshot: RepoSnapshot;
   externalDirtyBaseline: ExternalDirtyFile[];
@@ -124,6 +127,7 @@ interface TaskContext {
 
 interface ExecutionState {
   agentResult: ManagedProcessResult | null;
+  agentFailureCategory: string | null;
   testResult: TestExecutionResult;
   verifyResults: TestExecutionResult[];
   finalStatus: TaskStatus;
@@ -168,6 +172,7 @@ async function prepareTask(taskId: string): Promise<TaskContext | TaskRunResult>
   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",
@@ -220,7 +225,11 @@ async function prepareTask(taskId: string): Promise<TaskContext | TaskRunResult>
       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);
       }
     } catch (error) {
@@ -233,6 +242,8 @@ async function prepareTask(taskId: string): Promise<TaskContext | TaskRunResult>
   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.");
 
@@ -253,13 +264,14 @@ async function prepareTask(taskId: string): Promise<TaskContext | TaskRunResult>
   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: TaskContext): Promise<ExecutionState> {
   const state: ExecutionState = {
     agentResult: null,
+    agentFailureCategory: null,
     testResult: skippedTest(ctx.testCommand, ctx.repoPath, "Agent did not complete successfully."),
     verifyResults: [],
     finalStatus: "failed",
@@ -284,6 +296,7 @@ async function executeAgent(ctx: TaskContext): Promise<ExecutionState> {
       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,
@@ -297,11 +310,15 @@ async function executeAgent(ctx: TaskContext): Promise<ExecutionState> {
         ? "Task was terminated by kill_task."
         : "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) {
     state.lastCaughtError = error;
@@ -318,7 +335,14 @@ async function runVerification(ctx: TaskContext, state: ExecutionState): Promise
     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;
       }
@@ -331,6 +355,7 @@ async function runVerification(ctx: TaskContext, state: ExecutionState): Promise
           ? "Task was terminated by kill_task during verification."
           : "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) {
         state.finalStatus = "failed_verification";
@@ -542,7 +567,7 @@ function finalizeTask(ctx: TaskContext, state: ExecutionState, evidence: Artifac
   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)) state.finalStatus = "failed";
+  if (!["canceled", "timeout", "done_by_agent", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(state.finalStatus)) state.finalStatus = "failed";
   const finalPhase: TaskPhase = state.finalStatus === "done_by_agent" ? "done_by_agent" : (state.finalStatus as TaskPhase);
   const followup = buildFailureFollowup(state.finalStatus, state.finalError, verifyJson.commands);
 
@@ -600,6 +625,10 @@ function finalizeTask(ctx: TaskContext, state: ExecutionState, evidence: Artifac
     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,
@@ -662,6 +691,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,
@@ -792,6 +825,7 @@ async function runManagedProcess(options: {
   environmentVariableNames?: string[];
   blockedEnvironmentVariableNames?: string[];
   maxLogBytes?: number;
+  runnerInstanceId: string;
 }): Promise<ManagedProcessResult> {
   if (Date.now() >= options.deadlineMs) {
     return { exitCode: null, stdout: "", stderr: "", spawnError: null, terminationReason: "timeout" };
@@ -825,6 +859,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 = "";
@@ -939,7 +976,8 @@ async function runTrustedTestCommand(
   repoPath: string,
   taskDir: string,
   statusFile: string,
-  deadlineMs: number
+  deadlineMs: number,
+  runnerInstanceId: string,
 ): Promise<TestExecutionResult> {
   const config = getConfig();
   const trusted = guardTestCommand(testCommand, config, repoPath);
@@ -962,6 +1000,7 @@ async function runTrustedTestCommand(
     phase: "running_tests",
     currentCommand: trusted,
     deadlineMs,
+    runnerInstanceId,
     stdoutPath: join(taskDir, "test.stdout.log"),
     stderrPath: join(taskDir, "test.stderr.log"),
   });
@@ -1337,3 +1376,17 @@ function appendBounded(current: string, next: string): string {
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
+
+export function classifyAgentFailure(stderr: string): string | null {
+  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/src/runner/taskRuntime.ts

@@ -8,6 +8,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/src/runner/taskStatusStore.ts

@@ -4,6 +4,7 @@ import {
   readJsonObjectFileSync,
   type LockedJsonMutation,
 } from "../utils/lockedJsonFile.js";
+import { isAllowedTaskStatusTransition } from "../tools/tasks/taskStates.js";
 
 export type TaskStatusRecord = Record<string, unknown>;
 
@@ -22,7 +23,21 @@ export function mutateTaskStatus<T>(
   statusFile: string,
   mutation: (current: TaskStatusRecord) => TaskStatusMutation<T>,
 ): T {
-  return mutateLockedJsonFileSync(statusFile, mutation, {
+  return mutateLockedJsonFileSync<TaskStatusRecord, T>(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.",