patchwarden 1.5.1 → 1.6.2

package/dist/tools/{checkReleaseGate.d.ts → release/checkReleaseGate.d.ts}

@@ -1,4 +1,4 @@
-import { type ReleaseStage } from "../release/releaseGate.js";
+import { type ReleaseStage } from "../../release/releaseGate.js";
 export interface CheckReleaseGateInput {
     repo_path: string;
     target_stage: ReleaseStage;

package/dist/tools/{checkReleaseGate.js → release/checkReleaseGate.js}

@@ -1,6 +1,6 @@
-import { getConfig } from "../config.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
-import { runReleaseGateCheck, } from "../release/releaseGate.js";
+import { getConfig } from "../../config.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { runReleaseGateCheck, } from "../../release/releaseGate.js";
 /**
  * MCP tool handler for the release gate.
  *

package/dist/tools/release/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./checkReleaseGate.js";
+export * from "./releaseMode.js";

package/dist/tools/release/index.js

@@ -0,0 +1,2 @@
+export * from "./checkReleaseGate.js";
+export * from "./releaseMode.js";

package/dist/tools/{releaseMode.d.ts → release/releaseMode.d.ts}

@@ -1,5 +1,5 @@
-import { type ReleaseStage } from "../release/releaseGate.js";
-import { type ProjectPolicySummary } from "../policy/projectPolicy.js";
+import { type ReleaseStage } from "../../release/releaseGate.js";
+import { type ProjectPolicySummary } from "../../policy/projectPolicy.js";
 export interface ReleaseCheckInput {
     repo_path: string;
     target_stage?: ReleaseStage;

package/dist/tools/{releaseMode.js → release/releaseMode.js}

@@ -1,11 +1,14 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { join, relative, resolve, sep, isAbsolute } from "node:path";
-import { getConfig } from "../config.js";
-import { checkCiVerified, checkGitHubReleaseVerified, checkPublishedVerified, runReleaseGateCheck, } from "../release/releaseGate.js";
-import { guardTestCommand } from "../security/commandGuard.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
-import { commandAllowedByProjectPolicy, getProjectPolicySummary, isProtectedByProjectPolicy, readPackageJson, resolveVersionFromPolicy, } from "../policy/projectPolicy.js";
+import { getConfig } from "../../config.js";
+import { checkCiVerified, checkGitHubReleaseVerified, checkPublishedVerified, runReleaseGateCheck, } from "../../release/releaseGate.js";
+import { guardTestCommand } from "../../security/commandGuard.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { resolveTrustedCommandLine, buildGitEnvironment, resolveTrustedExecutable } from "../../runner/processSecurity.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
+import { runSimpleProcessSync } from "../../runner/simpleProcess.js";
+import { commandAllowedByProjectPolicy, getProjectPolicySummary, isProtectedByProjectPolicy, readPackageJson, resolveVersionFromPolicy, } from "../../policy/projectPolicy.js";
 const LOCAL_TIMEOUT_MS = 300000;
 const CLEANUP_REPORT_DIR = ".patchwarden/release-cleanup";
 export function getProjectPolicyTool(repoPath) {
@@ -75,12 +78,21 @@ export function releasePrepare(input) {
             continue;
         }
         try {
-            execSync(command, {
+            const invocation = resolveTrustedCommandLine(command, repoPath);
+            const execution = runSimpleProcessSync({
+                command: invocation.command,
+                args: invocation.argsPrefix,
                 cwd: repoPath,
-                encoding: "utf-8",
-                timeout: timeoutMs,
-                stdio: ["ignore", "pipe", "pipe"],
+                timeoutMs,
             });
+            if (execution.spawnError)
+                throw new Error(execution.spawnError);
+            if (execution.timedOut)
+                throw new Error(`Command timed out after ${timeoutMs}ms`);
+            if (execution.exitCode !== 0) {
+                const status = execution.exitCode ?? -1;
+                throw Object.assign(new Error(`Command exited with code ${status}`), { status });
+            }
             results.push({ command, status: "passed", exit_code: 0, reason: null });
         }
         catch (err) {
@@ -204,7 +216,7 @@ export function releaseCleanup(input) {
     const reportDir = join(repoPath, CLEANUP_REPORT_DIR);
     mkdirSync(reportDir, { recursive: true });
     const reportPath = join(reportDir, `${report.generated_at.replace(/[-:.TZ]/g, "").slice(0, 14)}.json`);
-    writeFileSync(reportPath, JSON.stringify(report, null, 2) + "\n", "utf-8");
+    atomicWriteJsonFileSync(reportPath, report);
     return {
         ok: skipped.length === 0 || dryRun,
         mode: "release_cleanup",
@@ -297,10 +309,12 @@ function isTrackedByGit(root, relPath) {
     if (!isGitWorktree(root))
         return false;
     try {
-        execFileSync("git", ["ls-files", "--error-unmatch", "--", relPath], {
+        const env = buildGitEnvironment(root);
+        execFileSync(resolveTrustedExecutable("git", root, { pathValue: env.PATH }), ["ls-files", "--error-unmatch", "--", relPath], {
             cwd: root,
             stdio: "ignore",
             windowsHide: true,
+            env,
         });
         return true;
     }
@@ -312,33 +326,39 @@ function isIgnoredOrUntracked(root, relPath) {
     if (!isGitWorktree(root))
         return true;
     try {
-        execFileSync("git", ["check-ignore", "-q", "--", relPath], {
-            cwd: root,
-            stdio: "ignore",
-            windowsHide: true,
-        });
-        return true;
-    }
-    catch {
+        const env = buildGitEnvironment(root);
+        const git = resolveTrustedExecutable("git", root, { pathValue: env.PATH });
         try {
-            const output = execFileSync("git", ["ls-files", "--others", "--exclude-standard", "--", relPath], {
+            execFileSync(git, ["check-ignore", "-q", "--", relPath], {
                 cwd: root,
-                encoding: "utf-8",
+                stdio: "ignore",
                 windowsHide: true,
+                env,
             });
-            return output.trim().split(/\r?\n/).filter(Boolean).includes(relPath);
+            return true;
         }
         catch {
-            return false;
+            const output = execFileSync(git, ["ls-files", "--others", "--exclude-standard", "--", relPath], {
+                cwd: root,
+                encoding: "utf-8",
+                windowsHide: true,
+                env,
+            });
+            return output.trim().split(/\r?\n/).filter(Boolean).includes(relPath);
         }
     }
+    catch {
+        return false;
+    }
 }
 function isGitWorktree(root) {
     try {
-        return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+        const env = buildGitEnvironment(root);
+        return execFileSync(resolveTrustedExecutable("git", root, { pathValue: env.PATH }), ["rev-parse", "--is-inside-work-tree"], {
             cwd: root,
             encoding: "utf-8",
             windowsHide: true,
+            env,
         }).trim() === "true";
     }
     catch {

package/dist/tools/tasks/cancelTask.d.ts

@@ -0,0 +1,11 @@
+import type { TaskStatus } from "./createTask.js";
+export interface TaskTerminationResponse {
+    task_id: string;
+    previous_status: TaskStatus;
+    new_status: TaskStatus;
+    message: string;
+    cancel_requested?: boolean;
+    force_kill_requested?: boolean;
+}
+export declare function cancelTask(taskId: string): TaskTerminationResponse;
+export declare function requestTaskTermination(taskId: string, force: boolean): TaskTerminationResponse;

package/dist/tools/tasks/cancelTask.js

@@ -0,0 +1,86 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+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);
+}
+export function requestTaskTermination(taskId, force) {
+    const config = getConfig();
+    const taskDir = join(getTasksDir(config), taskId);
+    const statusFile = join(taskDir, "status.json");
+    guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
+    if (!existsSync(statusFile))
+        throw new Error(`Task not found: "${taskId}"`);
+    const now = new Date().toISOString();
+    const outcome = mutateTaskStatus(statusFile, (current) => {
+        const currentStatus = current.status;
+        if (isTerminalTaskStatus(currentStatus)) {
+            return { result: {
+                    response: {
+                        task_id: taskId,
+                        previous_status: currentStatus,
+                        new_status: currentStatus,
+                        message: `Task is already ${currentStatus}. No action taken.`,
+                    },
+                    progress: null,
+                } };
+        }
+        if (currentStatus === "pending") {
+            const reason = force ? "Killed before execution by user request." : "Canceled by user request.";
+            const next = {
+                ...current,
+                status: "canceled",
+                phase: "canceled",
+                canceled_at: now,
+                cancel_reason: reason,
+                updated_at: now,
+            };
+            return { next, result: {
+                    response: {
+                        task_id: taskId,
+                        previous_status: "pending",
+                        new_status: "canceled",
+                        message: "Pending task canceled. It will not be executed by watcher.",
+                    },
+                    progress: { phase: "canceled", note: reason },
+                } };
+        }
+        const phase = force ? "terminating" : "canceling";
+        const next = {
+            ...current,
+            cancel_requested: true,
+            cancel_requested_at: now,
+            force_kill_requested: force,
+            ...(force ? { kill_requested_at: now } : {}),
+            phase,
+            updated_at: now,
+        };
+        return { next, result: {
+                response: {
+                    task_id: taskId,
+                    previous_status: "running",
+                    new_status: "running",
+                    cancel_requested: true,
+                    force_kill_requested: force,
+                    message: force
+                        ? "Kill requested. The runner that owns the child process will terminate it."
+                        : "Cancel requested. The runner will stop the child process safely.",
+                },
+                progress: {
+                    phase,
+                    note: force ? "Immediate termination requested." : "Graceful cancellation requested.",
+                },
+            } };
+    });
+    if (outcome.progress) {
+        writeTaskProgress(taskDir, outcome.progress.phase, {
+            note: outcome.progress.note,
+            heartbeatAt: now,
+        });
+    }
+    return outcome.response;
+}

package/dist/tools/{createTask.d.ts → 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";
+import { type ChangePolicy, type TaskTemplateName } from "../taskTemplates.js";
+import { type PendingReason, type WatcherStatusSnapshot } from "../../watcherStatus.js";
+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;
@@ -32,6 +32,14 @@ export interface CreateTaskInput {
     done_evidence?: string[];
     goal_id?: string;
     subgoal_id?: string;
+    /** Internal provenance supplied by retry_task; not exposed in MCP schemas. */
+    retry_metadata?: {
+        retry_of: string;
+        retry_count: number;
+        plan_source: "saved" | "inline" | "template";
+        template: string | null;
+        change_policy: ChangePolicy;
+    };
 }
 export interface AssessOnlyOutput {
     assessment_id: string;

package/dist/tools/{createTask.js → tasks/createTask.js}

@@ -1,23 +1,27 @@
-import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync } from "node:fs";
+import { mkdirSync, existsSync, statSync, readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { resolve, join } from "node:path";
-import { getTasksDir, getPlansDir, getConfig } from "../config.js";
-import { guardPath, guardWorkspacePath, guardReadPath } from "../security/pathGuard.js";
-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 { runAgentAssessment } from "../assessments/agentAssessor.js";
-import { captureRepoSnapshot } from "../runner/changeCapture.js";
-import { writeTaskProgress } from "../taskProgress.js";
-import { PatchWardenError } from "../errors.js";
-import { savePlan } from "./savePlan.js";
-import { expandTaskTemplate, TASK_TEMPLATE_NAMES, } from "./taskTemplates.js";
-import { PATCHWARDEN_VERSION } from "../version.js";
-import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
-import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
-import { routeAgent } from "../agents/agentRouter.js";
+import { getTasksDir, getPlansDir, getConfig } from "../../config.js";
+import { guardPath, guardWorkspacePath, guardReadPath } from "../../security/pathGuard.js";
+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, 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, 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";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 export async function createTask(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -28,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);
     }
@@ -245,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 } : {}),
@@ -333,18 +344,59 @@ 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";
     const statusFile = join(taskDir, "status.json");
+    const retryMetadata = effectiveInput.retry_metadata;
+    const safeAcceptance = redactSensitiveValue({
+        goal: effectiveInput.goal || null,
+        scope: effectiveInput.scope ?? null,
+        forbidden: effectiveInput.forbidden ?? null,
+        verification: effectiveInput.verification ?? null,
+        done_evidence: effectiveInput.done_evidence ?? null,
+    }).value;
     const statusData = {
+        schema_version: ARTIFACT_SCHEMA_VERSION,
         task_id: taskId,
         plan_id: planId,
-        plan_source: planSource,
-        template: effectiveInput.template || null,
-        change_policy: changePolicy,
+        plan_source: retryMetadata?.plan_source ?? planSource,
+        template: retryMetadata?.template ?? effectiveInput.template ?? null,
+        change_policy: retryMetadata?.change_policy ?? changePolicy,
+        ...(retryMetadata ? {
+            retry_of: retryMetadata.retry_of,
+            retry_count: retryMetadata.retry_count,
+        } : {}),
         agent: effectiveInput.agent,
         workspace_root: resolve(config.workspaceRoot),
         repo_path: resolvedRepoPath,
@@ -361,11 +413,11 @@ export async function createTask(input) {
         current_command: null,
         error: null,
         // v0.7.2: 验收标准绑定到任务创建
-        goal: effectiveInput.goal || null,
-        scope: effectiveInput.scope ?? null,
-        forbidden: effectiveInput.forbidden ?? null,
-        verification: effectiveInput.verification ?? null,
-        done_evidence: effectiveInput.done_evidence ?? null,
+        goal: safeAcceptance.goal,
+        scope: safeAcceptance.scope,
+        forbidden: safeAcceptance.forbidden,
+        verification: safeAcceptance.verification,
+        done_evidence: safeAcceptance.done_evidence,
         acceptance_status: null,
         // v0.8.0: Goal Session 关联
         goal_id: effectiveInput.goal_id ?? null,
@@ -373,7 +425,7 @@ export async function createTask(input) {
         // v1.0.0: Agent routing decision (only present when agent was auto-routed)
         ...(agentSelectionReason ? { agent_selection_reason: agentSelectionReason } : {}),
     };
-    writeFileSync(statusFile, JSON.stringify(statusData, null, 2), "utf-8");
+    atomicWriteJsonFileSync(statusFile, statusData);
     writeTaskProgress(taskDir, "queued", {
         heartbeatAt: statusData.last_heartbeat_at,
         note: `Waiting for watcher. Timeout: ${timeoutSeconds} seconds.`,
@@ -420,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/{diagnoseTask.d.ts → tasks/diagnoseTask.d.ts}

@@ -1,4 +1,4 @@
-import { type PatchWardenConfig } from "../config.js";
+import { type PatchWardenConfig } from "../../config.js";
 export type DiagnosisType = "active_running" | "stale_running" | "possibly_stale_running" | "orphaned_running" | "artifact_collection_stuck" | "done_candidate" | "unknown" | "terminal";
 export type DiagnosisConfidence = "high" | "medium" | "low";
 export type SafeAction = "leave_unchanged" | "mark_failed_stale" | "mark_orphaned" | "mark_done_by_agent" | "collect_artifacts" | "recollect_artifacts" | "needs_fix";

package/dist/tools/{diagnoseTask.js → tasks/diagnoseTask.js}

@@ -1,11 +1,13 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
-import { readTaskRuntime } from "../taskRuntime.js";
-import { isWatcherOwningTask, readWatcherInstanceId } from "../watcherStatus.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+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
@@ -55,8 +57,7 @@ function readTailLines(filePath, lines) {
     if (!existsSync(filePath))
         return null;
     try {
-        const raw = readFileSync(filePath, "utf-8");
-        const tail = raw.split("\n").slice(-lines).join("\n");
+        const tail = readTextFileTailLinesSync(filePath, lines, 512 * 1024);
         return redactSensitiveContent(tail).content;
     }
     catch {
@@ -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 ──