patchwarden 1.6.1 → 1.6.2

package/dist/runner/watch.js

@@ -28,6 +28,8 @@ 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.
@@ -47,6 +49,11 @@ const WATCHER_LAUNCHER_PID = Number.isInteger(Number(process.env.PATCHWARDEN_WAT
 // Track executed tasks to prevent re-execution
 const executedTasks = new Set();
 let consecutiveTickFailures = 0;
+let activeTaskId = null;
+let activeTaskPhase = null;
+let tickRunning = false;
+let tickStartedAt = null;
+let lastTickCompletedAt = null;
 // ── Single-instance lock ─────────────────────────────────────────
 //  watch.ts is a long-running poller; without a lock, two watchers started
 //  against the same workspace would race on the same pending tasks. The lock
@@ -184,6 +191,8 @@ export function createNonOverlappingRunner(operation, onSkipped = () => undefine
 }
 // ── Main loop ─────────────────────────────────────────────────────
 async function tick() {
+    tickRunning = true;
+    tickStartedAt = new Date().toISOString();
     try {
         writeWatcherHeartbeat("running");
         // Ensure tasks directory exists
@@ -192,6 +201,7 @@ async function tick() {
             writeWatcherHeartbeat("running");
             return;
         }
+        reconcileInterruptedTasks();
         const entries = readdirSync(tasksDir, { withFileTypes: true });
         const taskDirs = entries.filter((e) => e.isDirectory());
         for (const entry of taskDirs) {
@@ -245,7 +255,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)}`);
                     }
                 }
             }
@@ -276,14 +288,22 @@ 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;
         writeWatcherHeartbeat("running");
@@ -301,6 +321,26 @@ async function tick() {
             });
         }
     }
+    finally {
+        tickRunning = false;
+        lastTickCompletedAt = new Date().toISOString();
+    }
+}
+function reconcileInterruptedTasks() {
+    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),
+        });
+    }
 }
 function writeWatcherHeartbeat(status, lastError) {
     atomicWriteFileSync(WATCHER_HEARTBEAT_FILE, JSON.stringify({
@@ -312,8 +352,29 @@ function writeWatcherHeartbeat(status, lastError) {
         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() {
+    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
@@ -338,6 +399,7 @@ if (isMainModule) {
         throw err;
     }
     logger.info("[watcher] Started");
+    const heartbeatTimer = startWatcherHeartbeatLoop();
     const scheduledTick = createNonOverlappingRunner(tick, () => {
         logger.warn("[watcher] Previous tick is still running; skipping overlapping poll");
     });
@@ -347,6 +409,7 @@ if (isMainModule) {
     // Graceful shutdown
     function shutdown() {
         logger.info("[watcher] Stopped");
+        clearInterval(heartbeatTimer);
         try {
             releaseWatcherLock(WATCHER_LOCK_FILE);
         }

package/dist/smoke-test.js

@@ -1269,7 +1269,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");
     }
@@ -1509,8 +1509,8 @@ await test("K16. assessment_short_id cannot execute", async () => {
         throw new Error("Should have rejected short ID");
     }
     catch (e) {
-        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}`);
     }
 });
 await test("K17. blocked assessment cannot execute", async () => {

package/dist/tools/definitions/toolDefs.js

@@ -44,7 +44,7 @@ export function getToolDefs() {
         },
         {
             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.",
+            description: "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: {
@@ -59,7 +59,7 @@ export function getToolDefs() {
         },
         {
             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.",
+            description: "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: {},
@@ -388,7 +388,7 @@ export function getToolDefs() {
                 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/dist/tools/diagnostics/auditTask.d.ts

@@ -33,6 +33,7 @@ export interface AuditTaskOutput {
     recommended_next_actions: string[];
 }
 import type { ChangedFile } from "../../runner/changeCapture.js";
+export declare function extractNpmRunScriptNames(content: string): string[];
 /**
  * Check 1: forbidden_scope_violation (fail level).
  * Returns null when no forbidden patterns are configured (skip).

package/dist/tools/diagnostics/auditTask.js

@@ -73,6 +73,38 @@ function findMdFiles(dir, maxDepth = 3, maxFiles = MAX_AUDIT_DOC_FILES) {
     truncated ||= pending.length > 0 || results.length >= maxFiles || visitedDirectories >= maxDirectories;
     return { files: results, truncated };
 }
+export function extractNpmRunScriptNames(content) {
+    const names = new Set();
+    const collectCommands = (text) => {
+        const pattern = /\bnpm(?:\.cmd)?\s+run\s+([a-zA-Z0-9:_-]+)/gi;
+        let match;
+        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) => {
+        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) => {
+        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) {
     const half = Math.floor(MAX_AUDIT_EVIDENCE_BYTES / 2);
     const prefix = readTextFilePrefixSync(path, half);
@@ -466,7 +498,7 @@ export function auditTask(taskId) {
     };
     // ── 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",
@@ -677,12 +709,8 @@ export function auditTask(taskId) {
             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/dist/tools/diagnostics/healthCheck.d.ts

@@ -19,6 +19,7 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
             pending_reason: import("../../watcherStatus.js").PendingReason;
             error: string | null;
         }[];
+        last_assessment_validation_failure: import("../../assessments/assessmentDiagnostics.js").AssessmentValidationFailureDiagnostic | null;
     } | undefined;
     connector_visibility: {
         status: string;
@@ -65,10 +66,21 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
     tunnel: Record<string, unknown> & {
         last_error: string | null;
     };
+    config_path: string;
+    runtime_build_layout: string | null;
+    watcher_entry_path: string | null;
+    validator_module_path: string | null;
     agents: import("../workspace/listAgents.js").AgentAvailability[];
     agent_status: {
         [k: string]: string;
     };
+    agent_readiness: {
+        [k: string]: {
+            executable_available: boolean;
+            provider_status: "not_checked";
+            availability_scope: "executable_only";
+        };
+    };
     search_tool_count?: 5 | undefined;
     direct_tool_count?: number | undefined;
     status: string;

package/dist/tools/diagnostics/healthCheck.js

@@ -8,6 +8,7 @@ import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.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();
 export function healthCheck(catalog, input = {}) {
     const config = getConfig();
@@ -120,8 +121,23 @@ export function healthCheck(catalog, input = {}) {
         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,
     };
@@ -129,7 +145,7 @@ export function healthCheck(catalog, input = {}) {
 function buildSelfDiagnostic(config) {
     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,
@@ -145,6 +161,7 @@ function buildSelfDiagnostic(config) {
         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 {
@@ -171,6 +188,11 @@ function readWatcherSupervisorStatus() {
             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 {
@@ -239,6 +261,12 @@ function readTunnelStatus() {
                 : [],
             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/dist/tools/tasks/cancelTask.js

@@ -4,6 +4,7 @@ import { getTasksDir, getConfig } from "../../config.js";
 import { guardReadPath } from "../../security/pathGuard.js";
 import { writeTaskProgress } from "../../runner/taskProgress.js";
 import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 export function cancelTask(taskId) {
     return requestTaskTermination(taskId, false);
 }
@@ -17,7 +18,7 @@ export function requestTaskTermination(taskId, force) {
     const now = new Date().toISOString();
     const outcome = mutateTaskStatus(statusFile, (current) => {
         const currentStatus = current.status;
-        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/dist/tools/tasks/createTask.d.ts

@@ -1,6 +1,6 @@
 import { type ChangePolicy, type TaskTemplateName } from "../taskTemplates.js";
 import { type PendingReason, type WatcherStatusSnapshot } from "../../watcherStatus.js";
-export type TaskStatus = "pending" | "running" | "collecting_artifacts" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "done" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "canceled";
+export type TaskStatus = "pending" | "running" | "executing_agent" | "verifying" | "collecting_artifacts" | "cancel_requested" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "done" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "timeout" | "canceled";
 /**
  * v0.7.2 acceptance status — only meaningful for done_by_agent.
  * - "pending": done_by_agent reached but not yet audited/accepted
@@ -11,7 +11,7 @@ export type TaskStatus = "pending" | "running" | "collecting_artifacts" | "done_
  * - null: status has no acceptance semantics (running, failed, etc.)
  */
 export type AcceptanceStatus = "pending" | "accepted" | "rejected" | "needs_fix" | "blocked" | null;
-export type TaskPhase = "queued" | "preparing" | "executing_agent" | "running_tests" | "collecting_artifacts" | "canceling" | "terminating" | "completed" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "canceled";
+export type TaskPhase = "queued" | "preparing" | "executing_agent" | "running_tests" | "collecting_artifacts" | "canceling" | "terminating" | "completed" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "timeout" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "canceled";
 export interface CreateTaskInput {
     plan_id?: string;
     inline_plan?: string;

package/dist/tools/tasks/createTask.js

@@ -7,14 +7,16 @@ import { guardTestCommand } from "../../security/commandGuard.js";
 import { guardRuntimeSelfModification } from "../../security/runtimeGuard.js";
 import { guardPlanContent } from "../../security/planGuard.js";
 import { assessRisk } from "../../security/riskEngine.js";
-import { createAssessment, readAssessment, validateAssessmentFreshness, generateAssessmentId, createAssessmentDir, } from "../../assessments/assessmentStore.js";
+import { createAssessment, readAssessment, validateAssessmentFreshness, markAssessmentUsed, generateAssessmentId, createAssessmentDir, } 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";
 import { savePlan } from "../goals/savePlan.js";
 import { expandTaskTemplate, TASK_TEMPLATE_NAMES, } 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, readWatcherStatus, } from "../../watcherStatus.js";
 import { routeAgent } from "../../agents/agentRouter.js";
@@ -30,6 +32,9 @@ export async function createTask(input) {
     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);
     }
@@ -247,6 +252,10 @@ export async function createTask(input) {
             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 } : {}),
@@ -335,8 +344,36 @@ export async function createTask(input) {
         const snapshot = await captureRepoSnapshot(safeRepoPath);
         const validation = validateAssessmentFreshness(input.assessment_id, snapshot);
         if (!validation.valid) {
-            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 });
+            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,
+                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);
     const status = "pending";
@@ -435,26 +472,50 @@ function mergeAssessmentIntoInput(input, record) {
     // Do NOT set template/inline_plan alongside plan_id — createTask requires exactly one plan source.
     const merged = {
         ...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}".`, "Do not override assessment-locked parameters. Use the same assessment_id as-is.", true, { 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.`, "Do not override assessment-locked parameters. Use the same assessment_id as-is.", true, { field: "goal" });
     }
     if (input.repo_path && record.repo_path && input.repo_path !== record.repo_path) {
         throw new PatchWardenError("assessment_parameter_mismatch", `repo_path mismatch: caller passed "${input.repo_path}" but assessment has "${record.repo_path}".`, "Do not override assessment-locked parameters. Use the same assessment_id as-is.", true, { 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"]) {
+        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;
 }
 function createTaskDirectory(tasksDir, workspaceRoot, configuredTasksDir) {

package/dist/tools/tasks/diagnoseTask.js

@@ -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";
 // ── Thresholds (seconds) ──────────────────────────────────────────
 //
 // These are intentionally conservative. A task is only "stale" when multiple
@@ -81,16 +82,11 @@ export function diagnoseTask(input, config = getConfig()) {
     const statusStr = typeof status.status === "string" ? status.status : "unknown";
     const phaseStr = (runtime.phase || (typeof status.phase === "string" ? status.phase : "queued"));
     // ── 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`]);
     }
     // ── Gather evidence ──

package/dist/tools/tasks/getTaskStatus.js

@@ -5,6 +5,7 @@ import { guardReadPath } from "../../security/pathGuard.js";
 import { guardSensitivePath } from "../../security/sensitiveGuard.js";
 import { readTaskRuntime } from "../../runner/taskRuntime.js";
 import { derivePendingReason, readWatcherStatus, } from "../../watcherStatus.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 export function getTaskStatus(taskId) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -18,7 +19,11 @@ export function getTaskStatus(taskId) {
     const raw = readFileSync(statusFile, "utf-8");
     const status = JSON.parse(raw);
     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/dist/tools/tasks/getTaskSummary.js

@@ -5,15 +5,7 @@ import { guardReadPath } from "../../security/pathGuard.js";
 import { getTaskStatus } from "./getTaskStatus.js";
 import { redactSensitiveValue } from "../../security/contentRedaction.js";
 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 function getTaskSummary(taskId, options = {}) {
     const config = getConfig();
     const taskDir = resolve(getTasksDir(config), taskId);
@@ -24,7 +16,7 @@ export function getTaskSummary(taskId, options = {}) {
     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(result.new_out_of_scope_changes

package/dist/tools/tasks/listTasks.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { getTasksDir, getPlansDir, getConfig } from "../../config.js";
 import { readTaskRuntime } from "../../runner/taskRuntime.js";
 import { derivePendingReason, readWatcherStatus, } from "../../watcherStatus.js";
+import { isActiveTaskStatus } from "./taskStates.js";
 export function listTasks(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -48,7 +49,7 @@ export function listTasks(input) {
                 if (taskAcceptance !== filterAcceptance)
                     continue;
             }
-            if (input?.active_only && !["pending", "running", "collecting_artifacts"].includes(String(data.status)))
+            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, "/");