patchwarden 1.6.1 → 1.6.2

package/src/runner/watch.ts

@@ -38,6 +38,11 @@ import { mutateTaskStatus } from "./taskStatusStore.js";
 import { logger } from "../logging.js";
 import { redactSensitiveContent } from "../security/contentRedaction.js";
 import { atomicWriteFileSync } from "../utils/atomicFile.js";
+import { reconcileTasks } from "../tools/tasks/reconcileTasks.js";
+import {
+  buildAssessmentValidationFailureDiagnostic,
+  recordAssessmentValidationFailure,
+} from "../assessments/assessmentDiagnostics.js";
 //  Note: `runTask` is imported lazily inside `tick()` via `await import("./runTask.js")`.
 //  This keeps `import { acquireWatcherLock }` side-effect-free for unit tests and
 //  avoids eagerly pulling in the full tools/dispatch graph at module load.
@@ -60,6 +65,11 @@ const WATCHER_LAUNCHER_PID = Number.isInteger(Number(process.env.PATCHWARDEN_WAT
 // Track executed tasks to prevent re-execution
 const executedTasks = new Set<string>();
 let consecutiveTickFailures = 0;
+let activeTaskId: string | null = null;
+let activeTaskPhase: string | null = null;
+let tickRunning = false;
+let tickStartedAt: string | null = null;
+let lastTickCompletedAt: string | null = null;
 
 // ── Single-instance lock ─────────────────────────────────────────
 //  watch.ts is a long-running poller; without a lock, two watchers started
@@ -212,6 +222,8 @@ export function createNonOverlappingRunner(
 // ── Main loop ─────────────────────────────────────────────────────
 
 async function tick() {
+  tickRunning = true;
+  tickStartedAt = new Date().toISOString();
   try {
     writeWatcherHeartbeat("running");
     // Ensure tasks directory exists
@@ -221,6 +233,8 @@ async function tick() {
       return;
     }
 
+    reconcileInterruptedTasks();
+
     const entries = readdirSync(tasksDir, { withFileTypes: true });
     const taskDirs = entries.filter((e) => e.isDirectory());
 
@@ -280,7 +294,9 @@ async function tick() {
           const preExecSnapshot = await captureRepoSnapshot(resolvedRepoPath);
           const validation = validateAssessmentFreshness(statusData.assessment_id, preExecSnapshot);
           if (!validation.valid) {
-            throw new Error(`assessment validation failed: ${validation.failure_reason}`);
+            recordAssessmentValidationFailure(validation);
+            const diagnostic = buildAssessmentValidationFailureDiagnostic(validation);
+            throw new Error(`assessment validation failed: ${JSON.stringify(diagnostic)}`);
           }
         }
       } catch (err) {
@@ -312,13 +328,20 @@ async function tick() {
       // ── Execute ──
       logger.info(`[watcher] Executing: ${taskId}`);
       executedTasks.add(taskId);
+      activeTaskId = taskId;
+      activeTaskPhase = "executing_agent";
 
       try {
         const { runTask } = await import("./runTask.js");
         const result = await runTask(taskId);
+        activeTaskPhase = result.status;
         logger.info(`[watcher] ${taskId} → ${result.status}`);
       } catch (err) {
+        activeTaskPhase = "error";
         logger.error(`[watcher] ${taskId} → error: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        activeTaskId = null;
+        activeTaskPhase = null;
       }
     }
     consecutiveTickFailures = 0;
@@ -334,6 +357,26 @@ async function tick() {
         error: heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError),
       });
     }
+  } finally {
+    tickRunning = false;
+    lastTickCompletedAt = new Date().toISOString();
+  }
+}
+
+function reconcileInterruptedTasks(): void {
+  const result = reconcileTasks({
+    mode: "safe_fix",
+    max_age_minutes: Math.max(config.watcherStaleSeconds / 60, 1 / 60),
+    include_done_candidates: true,
+  }, config);
+  if (result.reconciled > 0) {
+    logger.warn("[watcher] Reconciled tasks left by a previous runner", {
+      reconciled: result.reconciled,
+      task_ids: result.reports
+        .filter((report) => report.action_taken !== "left_unchanged")
+        .map((report) => report.task_id)
+        .slice(0, 20),
+    });
   }
 }
 
@@ -347,9 +390,30 @@ function writeWatcherHeartbeat(status: "running" | "degraded", lastError?: strin
     launcher_pid: WATCHER_LAUNCHER_PID,
     consecutive_failures: consecutiveTickFailures,
     last_error: lastError ? lastError.slice(0, 500) : null,
+    heartbeat_source: "independent_interval",
+    tick_running: tickRunning,
+    tick_started_at: tickStartedAt,
+    last_tick_completed_at: lastTickCompletedAt,
+    active_task_id: activeTaskId,
+    active_task_phase: activeTaskPhase,
   }, null, 2));
 }
 
+function startWatcherHeartbeatLoop(): ReturnType<typeof setInterval> {
+  const intervalMs = Math.min(2000, Math.max(1000, Math.floor(config.watcherStaleSeconds * 1000 / 3)));
+  const timer = setInterval(() => {
+    try {
+      writeWatcherHeartbeat("running");
+    } catch (error) {
+      logger.warn("[watcher] Independent heartbeat write failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return timer;
+}
+
 // ── Start (only when executed as a script) ─────────────────────────
 //  The bootstrap below has process-wide side effects (mkdir, signal handlers,
 //  polling interval, lock acquisition). Guarding it with a main-module check
@@ -378,6 +442,7 @@ if (isMainModule) {
   }
 
   logger.info("[watcher] Started");
+  const heartbeatTimer = startWatcherHeartbeatLoop();
   const scheduledTick = createNonOverlappingRunner(tick, () => {
     logger.warn("[watcher] Previous tick is still running; skipping overlapping poll");
   });
@@ -389,6 +454,7 @@ if (isMainModule) {
   // Graceful shutdown
   function shutdown(): void {
     logger.info("[watcher] Stopped");
+    clearInterval(heartbeatTimer);
     try { releaseWatcherLock(WATCHER_LOCK_FILE); } catch (error) {
       logger.warn("[watcher] Failed to release watcher lock", {
         error: error instanceof Error ? error.message : String(error),

package/src/smoke-test.ts

@@ -1338,7 +1338,7 @@ await test("K8. assessment not found rejected", async () => {
       agent: "codex",
       repo_path: ".",
       execution_mode: "execute",
-      assessment_id: "assessment_20260101_" + "0".repeat(32),
+      assessment_id: "assessment_20260101_000000_" + "0".repeat(32),
     });
     throw new Error("Should have rejected unknown assessment");
   } catch (e: any) {
@@ -1569,7 +1569,7 @@ await test("K16. assessment_short_id cannot execute", async () => {
     });
     throw new Error("Should have rejected short ID");
   } catch (e: any) {
-    if (!e.message?.includes("not found")) throw new Error(`Expected not found for short ID, got: ${e.message}`);
+    if (e.reason !== "assessment_id_invalid") throw new Error(`Expected assessment_id_invalid for short ID, got: ${e.reason || e.message}`);
   }
 });
 

package/src/tools/definitions/toolDefs.ts

@@ -62,7 +62,7 @@ export function getToolDefs(): ToolDef[] {
     {
       name: "health_check",
       description:
-        "Check MCP catalog consistency, watcher freshness/supervisor state, workspace readiness, and configured agents. Use detail=self_diagnostic for expanded read-only evidence.",
+        "Check MCP catalog consistency, watcher freshness/supervisor state, workspace readiness, and configured agents. Agent availability is executable-only unless an explicit provider probe is requested. Use detail=self_diagnostic for expanded read-only evidence.",
       inputSchema: {
         type: "object",
         properties: {
@@ -78,7 +78,7 @@ export function getToolDefs(): ToolDef[] {
     {
       name: "list_agents",
       description:
-        "List configured local agents and check whether each executable currently exists. This does not start an agent or contact its model provider.",
+        "List agents from the active runtime config, verify executable and model-argument wiring, and report the config path used by this process. provider_status remains not_checked because this read-only check does not contact a model provider or test account balance.",
       inputSchema: {
         type: "object",
         properties: {},
@@ -416,7 +416,7 @@ export function getToolDefs(): ToolDef[] {
         properties: {
           status: {
             type: "string",
-            description: "Filter by status: pending, running, done, failed, failed_verification, failed_scope_violation, failed_policy_violation, canceled",
+            description: "Filter by status: pending, running, done, failed, failed_verification, failed_scope_violation, failed_policy_violation, timeout, canceled",
           },
           limit: {
             type: "number",

package/src/tools/diagnostics/auditTask.ts

@@ -140,6 +140,40 @@ function findMdFiles(
     return { files: results, truncated };
 }
 
+export function extractNpmRunScriptNames(content: string): string[] {
+  const names = new Set<string>();
+  const collectCommands = (text: string) => {
+    const pattern = /\bnpm(?:\.cmd)?\s+run\s+([a-zA-Z0-9:_-]+)/gi;
+    let match: RegExpExecArray | null;
+    while ((match = pattern.exec(text)) !== null) {
+      if (match[1]) names.add(match[1]);
+    }
+  };
+
+  // Markdown code blocks are explicit command-bearing regions. Keep their
+  // content separate from prose so token boundaries cannot be concatenated.
+  const withoutFences = content.replace(/(?:```|~~~)[^\r\n]*\r?\n([\s\S]*?)(?:```|~~~)/g, (_whole, body: string) => {
+    collectCommands(body);
+    return "\n";
+  });
+
+  // Inline code is also explicit. Remove it from the prose pass afterward to
+  // avoid double-counting and accidental cross-node matches.
+  const withoutInlineCode = withoutFences.replace(/`([^`\r\n]+)`/g, (_whole, body: string) => {
+    collectCommands(body);
+    return " ";
+  });
+
+  // In ordinary text, accept only a standalone command line (optionally a
+  // list item, shell prompt, or Run:/Command: label). Narrative mentions such
+  // as "this guide discusses npm run deploy" are not executable evidence.
+  const explicitPlainCommand = /^\s*(?:(?:[-*+]\s+|\d+[.)]\s+|>\s*|\$\s*|PS>\s*)|(?:(?:run|command|命令)\s*[:：]\s*))?npm(?:\.cmd)?\s+run\s+[a-zA-Z0-9:_-]+(?:\s+(?:--[^\r\n#]*|#[^\r\n]*))?\s*$/i;
+  for (const line of withoutInlineCode.split(/\r?\n/)) {
+    if (explicitPlainCommand.test(line)) collectCommands(line);
+  }
+  return [...names];
+}
+
 function readAuditEvidence(path: string): { content: string; truncated: boolean } {
     const half = Math.floor(MAX_AUDIT_EVIDENCE_BYTES / 2);
     const prefix = readTextFilePrefixSync(path, half);
@@ -515,7 +549,7 @@ export function auditTask(taskId: string): AuditTaskOutput {
     };
     // ── 1. Task status ──
     const taskStatus = statusData.status || "unknown";
-    const failedStatuses = new Set(["failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"]);
+    const failedStatuses = new Set(["failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled", "timeout"]);
     const doneStatuses = new Set(["done", "done_by_agent"]);
     checks.push({
         name: "task_status",
@@ -729,12 +763,8 @@ export function auditTask(taskId: string): AuditTaskOutput {
             continue;
         }
         // Extract npm run xxx
-        const refs = content.match(/npm(?:\.cmd)?\s+run\s+([a-zA-Z0-9:_-]+)/gi) || [];
-        for (const ref of refs) {
-            const scriptName = ref.replace(/npm\s+run\s+/i, "").replace(/[^a-zA-Z0-9:_-]/g, "");
-            if (scriptName)
-                allNpmRunRefs.add(scriptName);
-        }
+        for (const scriptName of extractNpmRunScriptNames(content))
+            allNpmRunRefs.add(scriptName);
         // Check release claims
         const claims = scanForReleaseClaims(content);
         for (const c of claims)

package/src/tools/diagnostics/healthCheck.ts

@@ -9,6 +9,7 @@ import type { ToolCatalogSnapshot } from "../catalog/toolCatalog.js";
 import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, CHATGPT_SEARCH_TOOL_NAMES, resolveToolProfile } from "../catalog/toolCatalog.js";
 import { readWatcherStatus } from "../../watcherStatus.js";
 import { listTasks } from "../tasks/listTasks.js";
+import { readLastAssessmentValidationFailure } from "../../assessments/assessmentDiagnostics.js";
 
 const SERVER_STARTED_AT = Date.now();
 
@@ -130,8 +131,23 @@ export function healthCheck(catalog?: ToolCatalogSnapshot, input: HealthCheckInp
     workspace_root: workspace,
     tasks_dir: tasks,
     tunnel,
+    config_path: agents.config_path,
+    runtime_build_layout: typeof watcher.supervisor?.runtime_build_layout === "string"
+      ? watcher.supervisor.runtime_build_layout
+      : null,
+    watcher_entry_path: typeof watcher.supervisor?.watcher_entry_path === "string"
+      ? watcher.supervisor.watcher_entry_path
+      : null,
+    validator_module_path: typeof watcher.supervisor?.validator_module_path === "string"
+      ? watcher.supervisor.validator_module_path
+      : null,
     agents: agents.agents,
     agent_status: Object.fromEntries(agents.agents.map((agent) => [agent.name, agent.available ? "ok" : "missing"])),
+    agent_readiness: Object.fromEntries(agents.agents.map((agent) => [agent.name, {
+      executable_available: agent.available,
+      provider_status: agent.provider_status,
+      availability_scope: agent.availability_scope,
+    }])),
     ...(input.detail === "self_diagnostic" ? { self_diagnostic: buildSelfDiagnostic(config) } : {}),
     last_error: tunnel.last_error || (!watcher.available ? watcher.reason : null) || mismatchReport[0] || null,
   };
@@ -140,7 +156,7 @@ export function healthCheck(catalog?: ToolCatalogSnapshot, input: HealthCheckInp
 function buildSelfDiagnostic(config: ReturnType<typeof getConfig>) {
   const recent = listTasks({ limit: 20 });
   const failures = recent.tasks
-    .filter((task) => task.status.startsWith("failed") || task.status === "canceled")
+    .filter((task) => task.status.startsWith("failed") || task.status === "canceled" || task.status === "timeout")
     .slice(0, 10)
     .map((task) => ({
       task_id: task.task_id,
@@ -156,6 +172,7 @@ function buildSelfDiagnostic(config: ReturnType<typeof getConfig>) {
     configured_agents: Object.keys(config.agents),
     recent_tasks_returned: recent.tasks.length,
     recent_failures: failures,
+    last_assessment_validation_failure: readLastAssessmentValidationFailure(),
   };
   const safe = redactSensitiveValue(diagnostic);
   return {
@@ -182,6 +199,11 @@ function readWatcherSupervisorStatus(): Record<string, unknown> {
       restart_attempts: Number.isInteger(Number(raw.restart_attempts)) ? Number(raw.restart_attempts) : 0,
       last_error: safeText(raw.last_error, 500) || null,
       checked_at: safeText(raw.checked_at, 80) || null,
+      project_root: safeText(raw.project_root, 500) || null,
+      config_path: safeText(raw.config_path, 500) || null,
+      watcher_entry_path: safeText(raw.watcher_entry_path, 500) || null,
+      validator_module_path: safeText(raw.validator_module_path, 500) || null,
+      runtime_build_layout: safeText(raw.runtime_build_layout, 80) || null,
     };
   } catch {
     return { observed: true, managed: false, status: "invalid_status_file" };
@@ -242,6 +264,12 @@ function readTunnelStatus(): Record<string, unknown> & { last_error: string | nu
         : [],
       tool_manifest_sha256: safeText(raw.tool_manifest_sha256, 80) || null,
       core_tools_ready: Boolean(raw.core_tools_ready),
+      project_root: safeText(raw.project_root, 500) || null,
+      config_path: safeText(raw.config_path, 500) || null,
+      mcp_entry_path: safeText(raw.mcp_entry_path, 500) || null,
+      watcher_entry_path: safeText(raw.watcher_entry_path, 500) || null,
+      validator_module_path: safeText(raw.validator_module_path, 500) || null,
+      runtime_build_layout: safeText(raw.runtime_build_layout, 80) || null,
     };
     const redacted = redactSensitiveContent(JSON.stringify(allowed));
     return JSON.parse(redacted.content);

package/src/tools/tasks/cancelTask.ts

@@ -5,6 +5,7 @@ import { guardReadPath } from "../../security/pathGuard.js";
 import { writeTaskProgress } from "../../runner/taskProgress.js";
 import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
 import type { TaskStatus } from "./createTask.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 
 export interface TaskTerminationResponse {
   task_id: string;
@@ -38,7 +39,7 @@ export function requestTaskTermination(taskId: string, force: boolean) {
   const now = new Date().toISOString();
   const outcome = mutateTaskStatus<TaskTerminationOutcome>(statusFile, (current) => {
     const currentStatus = current.status as TaskStatus;
-    if (["done", "done_by_agent", "failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"].includes(currentStatus)) {
+    if (isTerminalTaskStatus(currentStatus)) {
       return { result: {
         response: {
           task_id: taskId,

package/src/tools/tasks/createTask.ts

@@ -12,12 +12,15 @@ import {
   createAssessment,
   readAssessment,
   validateAssessmentFreshness,
+  markAssessmentUsed,
   generateAssessmentId,
   createAssessmentDir,
   type AssessmentRecord,
   type AgentAssessmentSummary,
 } from "../../assessments/assessmentStore.js";
 import { runAgentAssessment } from "../../assessments/agentAssessor.js";
+import { recordAssessmentValidationFailure } from "../../assessments/assessmentDiagnostics.js";
+import { ASSESSMENT_SECURITY_SNAPSHOT_VERSION } from "../../assessments/securitySnapshot.js";
 import { captureRepoSnapshot } from "../../runner/changeCapture.js";
 import { writeTaskProgress } from "../../runner/taskProgress.js";
 import { PatchWardenError } from "../../errors.js";
@@ -28,7 +31,7 @@ import {
   type ChangePolicy,
   type TaskTemplateName,
 } from "../taskTemplates.js";
-import { PATCHWARDEN_VERSION, ARTIFACT_SCHEMA_VERSION } from "../../version.js";
+import { PATCHWARDEN_VERSION, ARTIFACT_SCHEMA_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.js";
 import { getLastToolCatalogSnapshot, resolveToolProfile } from "../catalog/toolCatalog.js";
 import {
   derivePendingReason,
@@ -43,7 +46,10 @@ import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 export type TaskStatus =
   | "pending"
   | "running"
+  | "executing_agent"
+  | "verifying"
   | "collecting_artifacts"
+  | "cancel_requested"
   | "done_by_agent"      // v0.7.0: agent self-reported done or status reconciled to done; acceptance_status defaults to "pending"
   | "accepted"           // v0.7.2: audit_task confirmed acceptance
   | "rejected"           // v0.7.2: audit_task confirmed rejection
@@ -56,6 +62,7 @@ export type TaskStatus =
   | "failed_policy_violation"
   | "failed_stale"       // v0.7.0: process dead / heartbeat expired
   | "orphaned"           // v0.7.0: watcher no longer owns the task
+  | "timeout"
   | "canceled";
 
 /**
@@ -83,6 +90,7 @@ export type TaskPhase =
   | "failed_policy_violation"
   | "failed_stale"        // v0.7.0
   | "orphaned"             // v0.7.0
+  | "timeout"
   | "done_by_agent"        // v0.7.0
   | "accepted"             // v0.7.2
   | "rejected"             // v0.7.2
@@ -205,6 +213,15 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
   let effectiveInput = input;
   if (executionMode === "execute" && input.assessment_id) {
     assessmentRecord = readAssessment(input.assessment_id);
+    if (assessmentRecord.used_at) {
+      throw new PatchWardenError(
+        "assessment_used",
+        `Assessment "${input.assessment_id}" has already been used.`,
+        "Run create_task with execution_mode=assess_only again to obtain a new assessment_id.",
+        true,
+        { assessment_id: input.assessment_id, used_at: assessmentRecord.used_at },
+      );
+    }
     // Parameter mismatch check: if ChatGPT passes params that differ from the assessment, reject
     effectiveInput = mergeAssessmentIntoInput(input, assessmentRecord);
   }
@@ -490,6 +507,10 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
       agent: effectiveInput.agent,
       timeout_seconds: timeoutSeconds,
       change_policy: changePolicy,
+      scope: effectiveInput.scope,
+      forbidden: effectiveInput.forbidden,
+      verification: effectiveInput.verification,
+      done_evidence: effectiveInput.done_evidence,
       snapshot,
       ...(preGeneratedAssessmentId ? { assessment_id: preGeneratedAssessmentId } : {}),
       ...(preGeneratedAssessmentDir ? { assessment_dir: preGeneratedAssessmentDir } : {}),
@@ -585,14 +606,42 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
     const snapshot = await captureRepoSnapshot(safeRepoPath);
     const validation = validateAssessmentFreshness(input.assessment_id!, snapshot);
     if (!validation.valid) {
+      recordAssessmentValidationFailure(validation);
       throw new PatchWardenError(
         validation.failure_reason || "assessment_validation_failed",
         `Assessment "${input.assessment_id}" is no longer valid: ${validation.failure_reason}`,
         "Re-run create_task with execution_mode=assess_only to get a fresh assessment_id.",
         true,
-        { assessment_id: input.assessment_id, failure_reason: validation.failure_reason }
+        {
+          assessment_id: input.assessment_id,
+          reason_code: validation.failure_reason,
+          failure_reason: validation.failure_reason,
+          ...(validation.expected_hash ? { expected_hash: validation.expected_hash } : {}),
+          ...(validation.actual_hash ? { actual_hash: validation.actual_hash } : {}),
+          ...(validation.expected_hash ? { assessment_config_sha256: validation.expected_hash } : {}),
+          ...(validation.actual_hash ? { current_config_sha256: validation.actual_hash } : {}),
+          snapshot_version: validation.assessment?.assessment_security_snapshot_version || null,
+          assessment_created_at: validation.assessment?.created_at || null,
+          assessment_expires_at: validation.assessment?.expires_at || null,
+          config_changed: validation.failure_reason === "assessment_stale_config",
+          ...(validation.config_change_categories
+            ? {
+              config_change_categories: validation.config_change_categories,
+              changed_field_names: validation.config_change_categories,
+              changed_config_sections: validation.config_change_categories,
+            }
+            : {}),
+          assessment_fingerprint_version: validation.assessment?.assessment_security_snapshot_version || null,
+          current_fingerprint_version: ASSESSMENT_SECURITY_SNAPSHOT_VERSION,
+          assessment_schema_epoch: validation.assessment?.assessment_schema_epoch || null,
+          current_schema_epoch: TOOL_SCHEMA_EPOCH,
+          validator_module_path: "dist/assessments/assessmentStore.js",
+          validator_build_id: `patchwarden-${PATCHWARDEN_VERSION}:${TOOL_SCHEMA_EPOCH}:${ASSESSMENT_SECURITY_SNAPSHOT_VERSION}`,
+          watcher_instance_id: process.env.PATCHWARDEN_WATCHER_INSTANCE_ID || null,
+        }
       );
     }
+    markAssessmentUsed(input.assessment_id!);
   }
 
   const { taskId, taskDir } = createTaskDirectory(tasksDir, config.workspaceRoot, config.tasksDir);
@@ -700,18 +749,22 @@ function mergeAssessmentIntoInput(
   // Do NOT set template/inline_plan alongside plan_id — createTask requires exactly one plan source.
   const merged: CreateTaskInput = {
     ...input,
-    plan_id: record.plan_id || input.plan_id,
+    plan_id: record.plan_id || undefined,
     template: undefined,
     inline_plan: undefined,
-    goal: record.goal || input.goal,
+    goal: record.goal || undefined,
     agent: record.agent,
     repo_path: record.repo_path,
     test_command: record.test_command || undefined,
-    verify_commands: record.verify_commands || input.verify_commands,
-    timeout_seconds: record.timeout_seconds || input.timeout_seconds,
+    verify_commands: record.verify_commands || [],
+    timeout_seconds: record.timeout_seconds,
+    scope: record.scope || [],
+    forbidden: record.forbidden || [],
+    verification: record.verification || [],
+    done_evidence: record.done_evidence || [],
   };
   // Parameter mismatch check: if caller passed explicit params that differ from assessment
-  if (input.template && record.template && input.template !== record.template) {
+  if (input.template && input.template !== record.template) {
     throw new PatchWardenError(
       "assessment_parameter_mismatch",
       `template mismatch: caller passed "${input.template}" but assessment has "${record.template}".`,
@@ -720,7 +773,7 @@ function mergeAssessmentIntoInput(
       { field: "template", assessment_value: record.template, caller_value: input.template }
     );
   }
-  if (input.goal && record.goal && input.goal !== record.goal) {
+  if (input.goal && input.goal !== record.goal) {
     throw new PatchWardenError(
       "assessment_parameter_mismatch",
       `goal mismatch: caller passed a different goal than the assessment.`,
@@ -738,6 +791,58 @@ function mergeAssessmentIntoInput(
       { field: "repo_path", assessment_value: record.repo_path, caller_value: input.repo_path }
     );
   }
+  if (input.agent && input.agent !== record.agent) {
+    throw new PatchWardenError(
+      "assessment_parameter_mismatch",
+      `agent mismatch: caller passed "${input.agent}" but assessment has "${record.agent}".`,
+      "Do not override assessment-locked parameters. Use the same assessment_id as-is.",
+      true,
+      { field: "agent" },
+    );
+  }
+  if (
+    input.verify_commands
+    && JSON.stringify(input.verify_commands) !== JSON.stringify(record.verify_commands || [])
+  ) {
+    throw new PatchWardenError(
+      "assessment_parameter_mismatch",
+      "verify_commands mismatch: caller passed commands different from the assessment.",
+      "Do not override assessment-locked parameters. Use the same assessment_id as-is.",
+      true,
+      { field: "verify_commands" },
+    );
+  }
+  if (input.test_command && input.test_command !== record.test_command) {
+    throw new PatchWardenError(
+      "assessment_parameter_mismatch",
+      "test_command mismatch: caller passed a command different from the assessment.",
+      "Do not override assessment-locked parameters. Use the same assessment_id as-is.",
+      true,
+      { field: "test_command" },
+    );
+  }
+  if (input.timeout_seconds !== undefined && input.timeout_seconds !== record.timeout_seconds) {
+    throw new PatchWardenError(
+      "assessment_parameter_mismatch",
+      "timeout_seconds mismatch: caller passed a timeout different from the assessment.",
+      "Do not override assessment-locked parameters. Use the same assessment_id as-is.",
+      true,
+      { field: "timeout_seconds" },
+    );
+  }
+  for (const field of ["scope", "forbidden", "verification", "done_evidence"] as const) {
+    const callerValue = input[field];
+    const assessmentValue = record[field] || [];
+    if (callerValue && JSON.stringify(callerValue) !== JSON.stringify(assessmentValue)) {
+      throw new PatchWardenError(
+        "assessment_parameter_mismatch",
+        `${field} mismatch: caller passed values different from the assessment.`,
+        "Do not override assessment-locked parameters. Use the same assessment_id as-is.",
+        true,
+        { field },
+      );
+    }
+  }
   return merged;
 }
 

package/src/tools/tasks/diagnoseTask.ts

@@ -7,6 +7,7 @@ import { redactSensitiveContent } from "../../security/contentRedaction.js";
 import { readTextFileTailLinesSync } from "../../utils/boundedFile.js";
 import { readTaskRuntime } from "../../runner/taskRuntime.js";
 import { isWatcherOwningTask, readWatcherInstanceId } from "../../watcherStatus.js";
+import { isActiveTaskStatus, isTerminalTaskStatus } from "./taskStates.js";
 
 // ── v0.7.0: Task diagnosis types ──────────────────────────────────
 
@@ -153,17 +154,12 @@ export function diagnoseTask(
   const phaseStr = (runtime.phase || (typeof status.phase === "string" ? status.phase : "queued")) as string;
 
   // ── Terminal tasks: no diagnosis needed ──
-  const terminalStatuses = new Set([
-    "done", "done_by_agent", "failed", "failed_verification",
-    "failed_scope_violation", "failed_policy_violation",
-    "failed_stale", "orphaned", "canceled",
-  ]);
-  if (terminalStatuses.has(statusStr)) {
+  if (isTerminalTaskStatus(statusStr)) {
     return buildTerminalDiagnosis(taskId, statusStr, phaseStr);
   }
 
-  // ── Only diagnose running / collecting_artifacts / pending ──
-  if (statusStr !== "running" && statusStr !== "collecting_artifacts" && statusStr !== "pending") {
+  // Diagnose both current status spellings and legacy phase-as-status records.
+  if (!isActiveTaskStatus(statusStr)) {
     return buildUnknownDiagnosis(taskId, statusStr, phaseStr, [`unexpected status "${statusStr}" for diagnosis`]);
   }
 

package/src/tools/tasks/getTaskStatus.ts

@@ -12,6 +12,7 @@ import {
   type PendingReason,
   type WatcherStatusSnapshot,
 } from "../../watcherStatus.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 
 export interface GetTaskStatusOutput {
   task_id: string;
@@ -69,7 +70,11 @@ export function getTaskStatus(taskId: string): GetTaskStatusOutput {
   const raw = readFileSync(statusFile, "utf-8");
   const status = JSON.parse(raw) as GetTaskStatusOutput;
   const runtime = readTaskRuntime(taskDir);
-  const phase = runtime.phase || status.phase || "queued";
+  // A terminal status is authoritative. A stale runtime phase from a crashed
+  // Runner must never make a reconciled task look active again.
+  const phase = isTerminalTaskStatus(String(status.status))
+    ? status.phase || "queued"
+    : runtime.phase || status.phase || "queued";
   const watcher = readWatcherStatus(config);
   const pendingReason = derivePendingReason({ status: status.status, phase }, watcher);
   return {

package/src/tools/tasks/getTaskSummary.ts

@@ -8,16 +8,7 @@ import {
   readTextFilePrefixSync,
   readTextFileTailLinesSync,
 } from "../../utils/boundedFile.js";
-
-const TERMINAL_STATUSES = new Set([
-  "done",
-  "done_by_agent",
-  "failed",
-  "failed_verification",
-  "failed_scope_violation",
-  "failed_policy_violation",
-  "canceled",
-]);
+import { isTerminalTaskStatus } from "./taskStates.js";
 
 export interface TaskSummaryOutput {
   task_id: string;
@@ -143,7 +134,7 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
   const verifyRead = tryReadJson(join(taskDir, "verify.json"));
   const result = resultRead.data;
   const verify = verifyRead.data;
-  const terminal = TERMINAL_STATUSES.has(String(status.status));
+  const terminal = isTerminalTaskStatus(String(status.status));
   // Phase 4: Use new_out_of_scope_changes (task-caused) for acceptance status.
   // Pre-existing external dirty files that didn't change should NOT fail acceptance.
   const outOfScope = asArray(

package/src/tools/tasks/listTasks.ts

@@ -11,6 +11,7 @@ import {
   type WatcherState,
   type WatcherStatusSnapshot,
 } from "../../watcherStatus.js";
+import { isActiveTaskStatus } from "./taskStates.js";
 
 export interface TaskEntry {
   task_id: string;
@@ -97,7 +98,7 @@ export function listTasks(input?: ListTasksInput): ListTasksOutput {
           : null;
         if (taskAcceptance !== filterAcceptance) continue;
       }
-      if (input?.active_only && !["pending", "running", "collecting_artifacts"].includes(String(data.status))) continue;
+      if (input?.active_only && !isActiveTaskStatus(String(data.status))) continue;
       const normalizedRepo = String(data.repo_path || ".").replace(/\\/g, "/");
       const normalizedResolvedRepo = String(data.resolved_repo_path || "").replace(/\\/g, "/");
       if (filterRepo && normalizedRepo !== filterRepo && normalizedResolvedRepo !== filterRepo) continue;