patchwarden 1.5.1 → 1.6.2

package/src/tools/{checkReleaseGate.ts → release/checkReleaseGate.ts}

@@ -1,9 +1,9 @@
-import { getConfig } from "../config.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
+import { getConfig } from "../../config.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
 import {
   runReleaseGateCheck,
   type ReleaseStage,
-} from "../release/releaseGate.js";
+} from "../../release/releaseGate.js";
 
 export interface CheckReleaseGateInput {
   repo_path: string;

package/src/tools/release/index.ts

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

package/src/tools/{releaseMode.ts → release/releaseMode.ts}

@@ -1,7 +1,7 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join, relative, resolve, sep, isAbsolute } from "node:path";
-import { getConfig } from "../config.js";
+import { getConfig } from "../../config.js";
 import {
   checkCiVerified,
   checkGitHubReleaseVerified,
@@ -9,9 +9,12 @@ import {
   runReleaseGateCheck,
   type ReleaseStage,
   type ReleaseStageStatus,
-} from "../release/releaseGate.js";
-import { guardTestCommand } from "../security/commandGuard.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
+} 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,
@@ -19,7 +22,7 @@ import {
   readPackageJson,
   resolveVersionFromPolicy,
   type ProjectPolicySummary,
-} from "../policy/projectPolicy.js";
+} from "../../policy/projectPolicy.js";
 
 export interface ReleaseCheckInput {
   repo_path: string;
@@ -146,12 +149,19 @@ export function releasePrepare(input: ReleasePrepareInput): ReleaseModeResult {
       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) {
       const code = err && typeof err === "object" && "status" in err
@@ -280,7 +290,7 @@ export function releaseCleanup(input: ReleaseCleanupInput): ReleaseModeResult {
   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,
@@ -379,10 +389,12 @@ function walkFrom(base: string, dir: string, visit: (path: string, relPath: stri
 function isTrackedByGit(root: string, relPath: string): boolean {
   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;
   } catch {
@@ -393,32 +405,38 @@ function isTrackedByGit(root: string, relPath: string): boolean {
 function isIgnoredOrUntracked(root: string, relPath: string): boolean {
   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,
+        stdio: "ignore",
+        windowsHide: true,
+        env,
+      });
+      return true;
+    } catch {
+      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;
     }
+  } catch {
+    return false;
   }
 }
 
 function isGitWorktree(root: string): boolean {
   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 {
     return false;

package/src/tools/tasks/cancelTask.ts

@@ -0,0 +1,110 @@
+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 type { TaskStatus } from "./createTask.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
+
+export interface TaskTerminationResponse {
+  task_id: string;
+  previous_status: TaskStatus;
+  new_status: TaskStatus;
+  message: string;
+  cancel_requested?: boolean;
+  force_kill_requested?: boolean;
+}
+
+interface TaskTerminationOutcome {
+  response: TaskTerminationResponse;
+  progress: {
+    phase: "canceled" | "canceling" | "terminating";
+    note: string;
+  } | null;
+}
+
+export function cancelTask(taskId: string) {
+  return requestTaskTermination(taskId, false);
+}
+
+export function requestTaskTermination(taskId: string, force: boolean) {
+  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<TaskTerminationOutcome>(statusFile, (current) => {
+    const currentStatus = current.status as TaskStatus;
+    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" as const,
+          new_status: "canceled" as const,
+          message: "Pending task canceled. It will not be executed by watcher.",
+        },
+        progress: { phase: "canceled" as const, note: reason },
+      } };
+    }
+
+    const phase = force ? "terminating" as const : "canceling" as const;
+    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" as const,
+        new_status: "running" as const,
+        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/src/tools/{createTask.ts → tasks/createTask.ts}

@@ -2,46 +2,54 @@ import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync } from "no
 import { randomBytes } from "node:crypto";
 import { resolve, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-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 { 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,
   type AssessmentRecord,
   type AgentAssessmentSummary,
-} 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";
+} 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,
   type ChangePolicy,
   type TaskTemplateName,
-} from "./taskTemplates.js";
-import { PATCHWARDEN_VERSION } from "../version.js";
-import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
+} 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,
   type PendingReason,
   type WatcherStatusSnapshot,
-} from "../watcherStatus.js";
-import { routeAgent, type AgentRouteResult } from "../agents/agentRouter.js";
+} from "../../watcherStatus.js";
+import { routeAgent, type AgentRouteResult } from "../../agents/agentRouter.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+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
@@ -54,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";
 
 /**
@@ -81,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
@@ -110,6 +120,14 @@ export interface CreateTaskInput {
   // v0.8.0: Goal Session 关联
   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 {
@@ -195,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);
   }
@@ -480,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 } : {}),
@@ -575,26 +606,67 @@ 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);
 
   const status: TaskStatus = "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,
@@ -611,11 +683,11 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
     current_command: null as string | null,
     error: null as string | 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 as AcceptanceStatus,
     // v0.8.0: Goal Session 关联
     goal_id: effectiveInput.goal_id ?? null,
@@ -624,7 +696,7 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
     ...(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.`,
@@ -677,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}".`,
@@ -697,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.`,
@@ -715,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/{diagnoseTask.ts → tasks/diagnoseTask.ts}

@@ -1,11 +1,13 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getTasksDir, getConfig, type PatchWardenConfig } 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, type PatchWardenConfig } 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";
 
 // ── v0.7.0: Task diagnosis types ──────────────────────────────────
 
@@ -118,8 +120,7 @@ function fileAgeSeconds(filePath: string, nowMs: number): { age: number; size: n
 function readTailLines(filePath: string, lines: number): string | null {
   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 {
     return null;
@@ -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`]);
   }