patchwarden 1.5.1 → 1.6.1

package/src/tools/{getTaskSummary.ts → tasks/getTaskSummary.ts}

@@ -1,9 +1,13 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getConfig, getTasksDir } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
+import { getConfig, getTasksDir } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
 import { getTaskStatus } from "./getTaskStatus.js";
-import { redactSensitiveValue } from "../security/contentRedaction.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import {
+  readTextFilePrefixSync,
+  readTextFileTailLinesSync,
+} from "../../utils/boundedFile.js";
 
 const TERMINAL_STATUSES = new Set([
   "done",
@@ -134,7 +138,7 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
   const taskDir = resolve(getTasksDir(config), taskId);
   const statusFile = join(taskDir, "status.json");
   guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
-  const status = getTaskStatus(taskId) as any;
+  const status = getTaskStatus(taskId);
   const resultRead = tryReadJson(join(taskDir, "result.json"));
   const verifyRead = tryReadJson(join(taskDir, "verify.json"));
   const result = resultRead.data;
@@ -148,7 +152,8 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
     ?? result.out_of_scope_changes
     ?? status.out_of_scope_changes
   );
-  const verifyStatus = String(verify.status ?? result.verify_status ?? result.verify?.status ?? status.verify_status ?? "not_available");
+  const resultVerify = asRecord(result.verify);
+  const verifyStatus = String(verify.status ?? result.verify_status ?? resultVerify.status ?? status.verify_status ?? "not_available");
   const errors = [status.error, ...asArray(result.errors), ...asArray(result.known_issues)]
     .filter((value): value is string => typeof value === "string" && value.trim() !== "");
   const warnings = asArray(result.warnings).filter((value): value is string => typeof value === "string");
@@ -179,15 +184,15 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
   const acceptanceFile = join(taskDir, "acceptance.json");
   if (existsSync(acceptanceFile)) {
     try {
-      const acceptance = JSON.parse(readFileSync(acceptanceFile, "utf-8"));
+      const acceptance = asRecord(JSON.parse(readTextFilePrefixSync(acceptanceFile, 1024 * 1024).content));
       if (acceptance.status === "accepted") {
         acceptanceStatus = "ready_for_review";
-        acceptanceReviewedAt = acceptance.reviewed_at || null;
-        acceptanceReviewer = acceptance.reviewer || null;
+        acceptanceReviewedAt = typeof acceptance.reviewed_at === "string" ? acceptance.reviewed_at : null;
+        acceptanceReviewer = typeof acceptance.reviewer === "string" ? acceptance.reviewer : null;
       } else if (acceptance.status === "rejected") {
         acceptanceStatus = "failed";
-        acceptanceReviewedAt = acceptance.reviewed_at || null;
-        acceptanceReviewer = acceptance.reviewer || null;
+        acceptanceReviewedAt = typeof acceptance.reviewed_at === "string" ? acceptance.reviewed_at : null;
+        acceptanceReviewer = typeof acceptance.reviewer === "string" ? acceptance.reviewer : null;
         if (acceptance.notes) {
           warnings.push(`Task was rejected by ${acceptance.reviewer || "human"} at ${acceptance.reviewed_at || "unknown time"}: ${acceptance.notes}`);
         }
@@ -216,14 +221,14 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
   const artifactHygiene = asRecord(result.artifact_hygiene ?? changedFilesRead.data.artifact_hygiene ?? {
     counts: status.artifact_hygiene_counts || {},
   });
-  const verifyCommands = asArray(verify.commands ?? result.verify_commands ?? result.verify?.commands);
+  const verifyCommands = asArray(verify.commands ?? result.verify_commands ?? resultVerify.commands);
   const testLogSummary = summarizeTestLog(join(taskDir, "test.log"));
   const verificationSummary = buildVerificationSummary(verifyStatus, verifyCommands, testLogSummary);
 
   // Extract failed command detail from verify records
-  const failedVerify = (verifyCommands as any[]).find((cmd: any) =>
-    ["failed", "timed_out", "canceled"].includes(cmd?.status)
-  );
+  const failedVerify = verifyCommands
+    .map(asRecord)
+    .find((command) => ["failed", "timed_out", "canceled"].includes(String(command.status || "")));
   const failedCommandDetail = failedVerify ? {
     command: String(failedVerify.command || ""),
     exit_code: failedVerify.exit_code ?? null,
@@ -266,7 +271,9 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
       (status.diff_available ?? (changedFiles.length > 0)) &&
       (artifacts["diff.patch"] || artifacts["git.diff"])
     ),
-    diff_truncated: Boolean(status.diff_truncated || result.warnings?.some?.((warning: string) => warning.includes("diff.patch was truncated"))),
+    diff_truncated: Boolean(status.diff_truncated || asArray(result.warnings).some(
+      (warning) => typeof warning === "string" && warning.includes("diff.patch was truncated"),
+    )),
     result_available: artifacts["result.md"],
     result_json_available: artifacts["result.json"],
     verify_available: artifacts["verify.json"],
@@ -300,7 +307,7 @@ export function getTaskSummary(taskId: string, options: GetTaskSummaryOptions =
   } as TaskSummaryOutput;
 }
 
-function buildCompactSummary(output: Record<string, any>, maxItems: number): CompactTaskSummaryOutput {
+function buildCompactSummary(output: Record<string, unknown>, maxItems: number): CompactTaskSummaryOutput {
   const hygiene = asRecord(output.artifact_hygiene);
   const groupNames = [
     "source_changes",
@@ -317,7 +324,9 @@ function buildCompactSummary(output: Record<string, any>, maxItems: number): Com
   const manifestRead = tryReadJson(join(taskDir, "artifact_manifest.json"));
   const manifest = asRecord(manifestRead.data);
   const releaseArtifacts = asArray(manifest.artifacts);
-  const releaseArtifactPaths = releaseArtifacts.map((a: any) => String(a.path || "")).slice(0, maxItems);
+  const releaseArtifactPaths = releaseArtifacts
+    .map((artifact) => String(asRecord(artifact).path || ""))
+    .slice(0, maxItems);
 
   const compact = {
     view: "compact" as const,
@@ -364,42 +373,45 @@ function normalizeMaxItems(value: number | undefined): number {
   return value;
 }
 
-function tryReadJson(path: string): { data: Record<string, any>; error?: string } {
+function tryReadJson(path: string): { data: Record<string, unknown>; error?: string } {
   if (!existsSync(path)) return { data: {} };
   try {
-    return { data: JSON.parse(readFileSync(path, "utf-8")) };
+    return { data: asRecord(JSON.parse(readTextFilePrefixSync(path, 2 * 1024 * 1024).content)) };
   } catch (error) {
     return { data: {}, error: error instanceof Error ? error.message : String(error) };
   }
 }
 
-function asArray(value: unknown): any[] {
+function asArray(value: unknown): unknown[] {
   return Array.isArray(value) ? value : [];
 }
 
-function asRecord(value: unknown): Record<string, any> {
-  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, any> : {};
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
 }
 
 function summarizeTestLog(path: string): string {
   if (!existsSync(path)) return "test.log missing";
-  const text = readFileSync(path, "utf-8");
+  const text = readTextFileTailLinesSync(path, 200, 512 * 1024);
   const exit = text.match(/Exit\s*code:\s*([^\r\n]+)/i)?.[1]?.trim();
   return exit ? `Exit code: ${exit}` : text.trim().slice(0, 500) || "test.log empty";
 }
 
 function readResultFallback(path: string): string {
   if (!existsSync(path)) return "";
-  const text = readFileSync(path, "utf-8");
+  const text = readTextFilePrefixSync(path, 1024 * 1024).content;
   return text.match(/## Summary\s+([\s\S]*?)(?:\n## |\n---|$)/i)?.[1]?.trim().slice(0, 1000) || "";
 }
 
-function buildVerificationSummary(status: string, commands: any[], testLogSummary: string) {
-  const passed = commands.filter((command) => command?.status === "passed").length;
-  const failed = commands.filter((command) => ["failed", "timed_out", "canceled"].includes(command?.status)).length;
-  const skipped = commands.filter((command) => command?.status === "skipped").length;
+function buildVerificationSummary(status: string, commands: unknown[], testLogSummary: string) {
+  const commandRecords = commands.map(asRecord);
+  const passed = commandRecords.filter((command) => command.status === "passed").length;
+  const failed = commandRecords.filter((command) => ["failed", "timed_out", "canceled"].includes(String(command.status || ""))).length;
+  const skipped = commandRecords.filter((command) => command.status === "skipped").length;
   const evidenceText = [
-    ...commands.flatMap((command) => [command?.stdout_tail, command?.stderr_tail]),
+    ...commandRecords.flatMap((command) => [command.stdout_tail, command.stderr_tail]),
     testLogSummary,
   ].filter((value): value is string => typeof value === "string").join("\n");
   const headline = extractTestHeadline(evidenceText)
@@ -430,9 +442,8 @@ function extractTestHeadline(text: string): string {
 function readLogTail(path: string, lines: number): string {
   if (!existsSync(path)) return "(file not found)";
   try {
-    const raw = readFileSync(path, "utf-8");
-    if (raw.length === 0) return "(empty)";
-    return raw.split("\n").slice(-lines).join("\n");
+    const tail = readTextFileTailLinesSync(path, lines);
+    return tail || "(empty)";
   } catch {
     return "(unreadable)";
   }

package/src/tools/tasks/index.ts

@@ -0,0 +1,18 @@
+export * from "./cancelTask.js";
+export * from "./createTask.js";
+export * from "./diagnoseTask.js";
+export * from "./evidencePack.js";
+export * from "./getTaskFile.js";
+export * from "./getTaskProgress.js";
+export * from "./getTaskStatus.js";
+export * from "./getTaskStdoutTail.js";
+export * from "./getTaskSummary.js";
+export * from "./killTask.js";
+export * from "./listTasks.js";
+export * from "./reconcileTasks.js";
+export * from "./retryTask.js";
+export * from "./runTaskLoop.js";
+export * from "./runVerification.js";
+export * from "./taskLineage.js";
+export * from "./taskOutputs.js";
+export * from "./waitForTask.js";

package/src/tools/{listTasks.ts → tasks/listTasks.ts}

@@ -1,8 +1,8 @@
 import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getTasksDir, getPlansDir, getConfig } from "../config.js";
-import { guardPath } from "../security/pathGuard.js";
-import { readTaskRuntime } from "../taskRuntime.js";
+import { getTasksDir, getPlansDir, getConfig } from "../../config.js";
+import { guardPath } from "../../security/pathGuard.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
 import type { TaskPhase, TaskStatus, AcceptanceStatus } from "./createTask.js";
 import {
   derivePendingReason,
@@ -10,7 +10,7 @@ import {
   type PendingReason,
   type WatcherState,
   type WatcherStatusSnapshot,
-} from "../watcherStatus.js";
+} from "../../watcherStatus.js";
 
 export interface TaskEntry {
   task_id: string;

package/src/tools/{reconcileTasks.ts → tasks/reconcileTasks.ts}

@@ -2,17 +2,17 @@ import {
   existsSync,
   readdirSync,
   readFileSync,
-  writeFileSync,
-  renameSync,
-  unlinkSync,
   mkdirSync,
   statSync,
   type Dirent,
 } from "node:fs";
 import { join, resolve, dirname } from "node:path";
-import { getTasksDir, getConfig, type PatchWardenConfig } from "../config.js";
+import { getTasksDir, getConfig, type PatchWardenConfig } from "../../config.js";
 import { diagnoseTask, type DiagnosisType, type DiagnosisConfidence, type SafeAction } from "./diagnoseTask.js";
-import { syncSubgoalOnTaskDone, readTaskGoalMeta } from "../goal/subgoalSync.js";
+import { syncSubgoalOnTaskDone, readTaskGoalMeta } from "../../goal/subgoalSync.js";
+import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
+import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+import { appendBoundedTextFileSync } from "../../utils/boundedFile.js";
 
 // ── v0.7.0: reconcile_tasks types ──────────────────────────────────
 
@@ -206,10 +206,9 @@ export function reconcileTasks(
           report.applied_by = "reconcile_tasks";
           reconciled += 1;
         } else {
-          // Diagnosis type does not map to a safe_fix action — leave unchanged
           report.reasons = [
             ...report.reasons,
-            `safe_fix skipped: diagnosis "${diagnosis.diagnosis}" has no automatic safe_fix action`,
+            `safe_fix skipped: ${fixResult.skip_reason || "task state could not be updated safely"}`,
           ];
           skippedLowConfidence += 1;
         }
@@ -254,8 +253,13 @@ interface SafeFixResult {
   previous_status: string;
   new_status: string;
   applied_at: string;
+  skip_reason: string | null;
 }
 
+type SafeFixMutationOutcome =
+  | { applied: true }
+  | { applied: false; reason: string };
+
 function applySafeFix(
   taskDir: string,
   taskId: string,
@@ -306,6 +310,7 @@ function applySafeFix(
         previous_status: previousStatus,
         new_status: previousStatus,
         applied_at: new Date().toISOString(),
+        skip_reason: `diagnosis "${diagnosis}" has no automatic safe_fix action`,
       };
   }
 
@@ -313,72 +318,71 @@ function applySafeFix(
   const statusFile = join(taskDir, "status.json");
   const backupFile = join(taskDir, "status.json.bak");
 
-  // 1. Write status.json.bak with current contents (overwrite any prior backup)
+  // Revalidate and update under the shared task status lock. Any heartbeat or
+  // ownership-related status change after diagnosis makes this repair stale.
   try {
-    const currentRaw = readFileSync(statusFile, "utf-8");
-    writeFileSync(backupFile, currentRaw, "utf-8");
-  } catch {
-    // If we cannot back up, refuse to apply the fix.
-    return {
-      applied: false,
-      action_taken: "left_unchanged",
-      previous_status: previousStatus,
-      new_status: previousStatus,
-      applied_at: appliedAt,
-    };
-  }
+    const outcome = mutateTaskStatus<SafeFixMutationOutcome>(statusFile, (current) => {
+      if (JSON.stringify(current) !== JSON.stringify(currentStatus)) {
+        return { result: { applied: false as const, reason: "task status changed after diagnosis" } };
+      }
 
-  // 2. Build the new status record with full audit trail
-  const next: Record<string, unknown> = {
-    ...currentStatus,
-    status: newStatus,
-    phase: newStatus,
-    updated_at: appliedAt,
-    last_heartbeat_at: appliedAt,
-    finished_at: appliedAt,
-    // v0.7.0 audit fields
-    previous_status: previousStatus,
-    diagnosis: {
-      type: diagnosis,
-      confidence: "high" as DiagnosisConfidence,
-      applied_by: "reconcile_tasks",
-      applied_at: appliedAt,
-      reasons,
-      evidence: {
-        heartbeat_age_seconds: evidence.heartbeat_age_seconds,
-        stdout_age_seconds: evidence.stdout_age_seconds,
-        child_pid: evidence.child_pid,
-        child_pid_alive: evidence.child_pid_alive,
-        watcher_instance_id: evidence.watcher_instance_id,
-        current_watcher_instance_id: evidence.current_watcher_instance_id,
-      },
-    },
-  };
+      const lockedPreviousStatus = typeof current.status === "string" ? current.status : "unknown";
+      const next: Record<string, unknown> = {
+        ...current,
+        status: newStatus,
+        phase: newStatus,
+        updated_at: appliedAt,
+        last_heartbeat_at: appliedAt,
+        finished_at: appliedAt,
+        previous_status: lockedPreviousStatus,
+        diagnosis: {
+          type: diagnosis,
+          confidence: "high" as DiagnosisConfidence,
+          applied_by: "reconcile_tasks",
+          applied_at: appliedAt,
+          reasons,
+          evidence: {
+            heartbeat_age_seconds: evidence.heartbeat_age_seconds,
+            stdout_age_seconds: evidence.stdout_age_seconds,
+            child_pid: evidence.child_pid,
+            child_pid_alive: evidence.child_pid_alive,
+            watcher_instance_id: evidence.watcher_instance_id,
+            current_watcher_instance_id: evidence.current_watcher_instance_id,
+          },
+        },
+      };
 
-  // For done_by_agent, set acceptance_status=pending (per roadmap 3.6)
-  if (newStatus === "done_by_agent") {
-    next.acceptance_status = "pending";
-    next.legacy_status = "done";
-  }
+      if (newStatus === "done_by_agent") {
+        next.acceptance_status = "pending";
+        next.legacy_status = "done";
+      }
 
-  // 3. Atomic write: write to temp file then rename
-  const tmpFile = join(taskDir, "status.json.tmp");
-  try {
-    writeFileSync(tmpFile, JSON.stringify(next, null, 2), "utf-8");
-    renameSync(tmpFile, statusFile);
+      // The backup is created while the same lock protects the exact record
+      // being replaced, so it cannot capture an unrelated newer state.
+      atomicWriteFileSync(backupFile, readFileSync(statusFile, "utf-8"));
+      return {
+        next,
+        result: { applied: true as const },
+      };
+    });
+    if (!outcome.applied) {
+      return {
+        applied: false,
+        action_taken: "left_unchanged",
+        previous_status: previousStatus,
+        new_status: previousStatus,
+        applied_at: appliedAt,
+        skip_reason: outcome.reason,
+      };
+    }
   } catch {
-    // Best-effort cleanup of temp file
-    try {
-      if (existsSync(tmpFile)) {
-        unlinkSync(tmpFile);
-      }
-    } catch { /* ignore */ }
     return {
       applied: false,
       action_taken: "left_unchanged",
       previous_status: previousStatus,
       new_status: previousStatus,
       applied_at: appliedAt,
+      skip_reason: "task status could not be locked, backed up, and updated",
     };
   }
 
@@ -396,6 +400,7 @@ function applySafeFix(
     previous_status: previousStatus,
     new_status: newStatus,
     applied_at: appliedAt,
+    skip_reason: null,
   };
 }
 
@@ -428,11 +433,8 @@ function writeReconcileLog(
       evidence: report.evidence_summary,
     }));
   }
-  // Append — do not overwrite history
-  const existing = existsSync(logPath) ? readFileSync(logPath, "utf-8") : "";
-  const nextContent = existing + (existing && !existing.endsWith("\n") ? "\n" : "") + lines.join("\n") + "\n";
   try {
-    writeFileSync(logPath, nextContent, "utf-8");
+    appendBoundedTextFileSync(logPath, lines.join("\n") + "\n");
   } catch {
     // If we cannot write the log, the status change still happened —
     // the status.json itself contains the diagnosis audit fields.

package/src/tools/tasks/retryTask.ts

@@ -0,0 +1,69 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { createTask } from "./createTask.js";
+import type { ChangePolicy } from "../taskTemplates.js";
+
+export async function retryTask(taskId: string) {
+  const config = getConfig();
+  const tasksDir = getTasksDir(config);
+  const taskDir = join(tasksDir, taskId);
+  const statusFile = join(taskDir, "status.json");
+
+  guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
+
+  if (!existsSync(statusFile)) {
+    throw new Error(`Task not found: "${taskId}"`);
+  }
+
+  const parsed: unknown = JSON.parse(readFileSync(statusFile, "utf-8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Task "${taskId}" has an invalid status record.`);
+  }
+  const data = parsed as Record<string, unknown>;
+
+  if (typeof data.plan_id !== "string" || !data.plan_id ||
+      typeof data.agent !== "string" || !data.agent) {
+    throw new Error(`Task "${taskId}" is missing plan_id or agent. Cannot retry.`);
+  }
+
+  const priorRetryCount = typeof data.retry_count === "number" &&
+    Number.isSafeInteger(data.retry_count) && data.retry_count >= 0
+    ? data.retry_count
+    : 0;
+  const planSource = data.plan_source === "inline" || data.plan_source === "template"
+    ? data.plan_source
+    : "saved";
+  const changePolicy: ChangePolicy = data.change_policy === "no_changes"
+    ? "no_changes"
+    : "repo_scoped_changes";
+
+  // Create a new task with the same parameters
+  const newTask = await createTask({
+    plan_id: data.plan_id,
+    agent: data.agent,
+    repo_path: typeof data.repo_path === "string" ? data.repo_path : undefined,
+    test_command: typeof data.test_command === "string" ? data.test_command : undefined,
+    verify_commands: Array.isArray(data.verify_commands)
+      ? data.verify_commands.filter((value): value is string => typeof value === "string")
+      : undefined,
+    timeout_seconds: typeof data.timeout_seconds === "number" ? data.timeout_seconds : undefined,
+    retry_metadata: {
+      retry_of: taskId,
+      retry_count: priorRetryCount + 1,
+      plan_source: planSource,
+      template: typeof data.template === "string" ? data.template : null,
+      change_policy: changePolicy,
+    },
+  });
+
+  return {
+    original_task_id: taskId,
+    new_task_id: newTask.task_id,
+    plan_id: newTask.plan_id,
+    agent: newTask.agent,
+    status: newTask.status,
+    message: `New task created from retry of ${taskId}. Original task is unchanged.`,
+  };
+}