patchwarden 1.5.1 → 1.6.1

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

@@ -1,9 +1,10 @@
-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",
     "done_by_agent",
@@ -30,7 +31,8 @@ export function getTaskSummary(taskId, options = {}) {
         ?? status.new_out_of_scope_changes
         ?? 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) => typeof value === "string" && value.trim() !== "");
     const warnings = asArray(result.warnings).filter((value) => typeof value === "string");
@@ -61,16 +63,16 @@ export function getTaskSummary(taskId, options = {}) {
     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}`);
                 }
@@ -102,11 +104,13 @@ export function getTaskSummary(taskId, options = {}) {
     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.find((cmd) => ["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,
@@ -145,7 +149,7 @@ export function getTaskSummary(taskId, options = {}) {
         test_summary: verificationSummary.headline,
         diff_available: Boolean((status.diff_available ?? (changedFiles.length > 0)) &&
             (artifacts["diff.patch"] || artifacts["git.diff"])),
-        diff_truncated: Boolean(status.diff_truncated || result.warnings?.some?.((warning) => 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"],
@@ -194,7 +198,9 @@ function buildCompactSummary(output, maxItems) {
     const manifestRead = tryReadJson(join(taskDir, "artifact_manifest.json"));
     const manifest = asRecord(manifestRead.data);
     const releaseArtifacts = asArray(manifest.artifacts);
-    const releaseArtifactPaths = releaseArtifacts.map((a) => String(a.path || "")).slice(0, maxItems);
+    const releaseArtifactPaths = releaseArtifacts
+        .map((artifact) => String(asRecord(artifact).path || ""))
+        .slice(0, maxItems);
     const compact = {
         view: "compact",
         task_id: String(output.task_id),
@@ -243,7 +249,7 @@ function tryReadJson(path) {
     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) };
@@ -253,27 +259,30 @@ function asArray(value) {
     return Array.isArray(value) ? value : [];
 }
 function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
 }
 function summarizeTestLog(path) {
     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) {
     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, commands, testLogSummary) {
-    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;
+    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) => typeof value === "string").join("\n");
     const headline = extractTestHeadline(evidenceText)
@@ -304,10 +313,8 @@ function readLogTail(path, lines) {
     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/dist/tools/tasks/index.d.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/dist/tools/tasks/index.js

@@ -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/dist/tools/tasks/killTask.d.ts

@@ -0,0 +1 @@
+export declare function killTask(taskId: string): import("./cancelTask.js").TaskTerminationResponse;

package/dist/tools/{listTasks.d.ts → tasks/listTasks.d.ts}

@@ -1,5 +1,5 @@
 import type { TaskPhase, TaskStatus, AcceptanceStatus } from "./createTask.js";
-import { type PendingReason, type WatcherState, type WatcherStatusSnapshot } from "../watcherStatus.js";
+import { type PendingReason, type WatcherState, type WatcherStatusSnapshot } from "../../watcherStatus.js";
 export interface TaskEntry {
     task_id: string;
     plan_id: string;

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

@@ -1,8 +1,8 @@
 import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { getTasksDir, getPlansDir, getConfig } from "../config.js";
-import { readTaskRuntime } from "../taskRuntime.js";
-import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
+import { getTasksDir, getPlansDir, getConfig } from "../../config.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
+import { derivePendingReason, readWatcherStatus, } from "../../watcherStatus.js";
 export function listTasks(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);

package/dist/tools/{reconcileTasks.d.ts → tasks/reconcileTasks.d.ts}

@@ -1,4 +1,4 @@
-import { type PatchWardenConfig } from "../config.js";
+import { type PatchWardenConfig } from "../../config.js";
 import { type DiagnosisType, type DiagnosisConfidence, type SafeAction } from "./diagnoseTask.js";
 export type ReconcileMode = "report_only" | "safe_fix";
 export interface ReconcileTasksInput {

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

@@ -1,8 +1,11 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, mkdirSync, statSync, } from "node:fs";
+import { existsSync, readdirSync, readFileSync, mkdirSync, statSync, } from "node:fs";
 import { join, resolve, dirname } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
+import { getTasksDir, getConfig } from "../../config.js";
 import { diagnoseTask } 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";
 // ── Defaults ────────────────────────────────────────────────────────
 const DEFAULT_MAX_AGE_MINUTES = 30;
 const RECONCILE_LOG_NAME = "reconcile.log";
@@ -137,10 +140,9 @@ export function reconcileTasks(input = {}, config = getConfig()) {
                     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;
                 }
@@ -208,77 +210,75 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
                 previous_status: previousStatus,
                 new_status: previousStatus,
                 applied_at: new Date().toISOString(),
+                skip_reason: `diagnosis "${diagnosis}" has no automatic safe_fix action`,
             };
     }
     const appliedAt = new Date().toISOString();
     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,
-        };
-    }
-    // 2. Build the new status record with full audit trail
-    const next = {
-        ...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",
-            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";
-    }
-    // 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);
-    }
-    catch {
-        // Best-effort cleanup of temp file
-        try {
-            if (existsSync(tmpFile)) {
-                unlinkSync(tmpFile);
+        const outcome = mutateTaskStatus(statusFile, (current) => {
+            if (JSON.stringify(current) !== JSON.stringify(currentStatus)) {
+                return { result: { applied: false, reason: "task status changed after diagnosis" } };
             }
+            const lockedPreviousStatus = typeof current.status === "string" ? current.status : "unknown";
+            const next = {
+                ...current,
+                status: newStatus,
+                phase: newStatus,
+                updated_at: appliedAt,
+                last_heartbeat_at: appliedAt,
+                finished_at: appliedAt,
+                previous_status: lockedPreviousStatus,
+                diagnosis: {
+                    type: diagnosis,
+                    confidence: "high",
+                    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,
+                    },
+                },
+            };
+            if (newStatus === "done_by_agent") {
+                next.acceptance_status = "pending";
+                next.legacy_status = "done";
+            }
+            // 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 },
+            };
+        });
+        if (!outcome.applied) {
+            return {
+                applied: false,
+                action_taken: "left_unchanged",
+                previous_status: previousStatus,
+                new_status: previousStatus,
+                applied_at: appliedAt,
+                skip_reason: outcome.reason,
+            };
         }
-        catch { /* ignore */ }
+    }
+    catch {
         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",
         };
     }
     // v0.8.0: 当状态变为 done_by_agent 时，同步关联 subgoal 状态（running → done_by_agent）
@@ -294,6 +294,7 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
         previous_status: previousStatus,
         new_status: newStatus,
         applied_at: appliedAt,
+        skip_reason: null,
     };
 }
 // ── reconcile.log writer ───────────────────────────────────────────
@@ -320,11 +321,8 @@ function writeReconcileLog(tasksDir, config, appliedReports) {
             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 —

package/dist/tools/tasks/retryTask.js

@@ -0,0 +1,60 @@
+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";
+export async function retryTask(taskId) {
+    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 = 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;
+    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 = 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) => 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.`,
+    };
+}

package/dist/tools/{runTaskLoop.d.ts → tasks/runTaskLoop.d.ts}

@@ -1,11 +1,11 @@
-import { createWorktree } from "../goal/worktreeManager.js";
-import { createDirectSession } from "./createDirectSession.js";
+import { createWorktree } from "../../goal/worktreeManager.js";
+import { createDirectSession } from "../direct/createDirectSession.js";
 import { createTask } from "./createTask.js";
-import { recommendAgentForTask } from "./recommendAgentForTask.js";
-import { runDirectVerificationBundle } from "./runDirectVerificationBundle.js";
+import { recommendAgentForTask } from "../workspace/recommendAgentForTask.js";
+import { runDirectVerificationBundle } from "../direct/runDirectVerificationBundle.js";
 import { waitForTask } from "./waitForTask.js";
-import { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "./safeViews.js";
-import type { TaskTemplateName } from "./taskTemplates.js";
+import { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
+import type { TaskTemplateName } from "../taskTemplates.js";
 import { createLineageId, writeTaskLineage, type SafeTaskLineage, type TaskLineageWorktree } from "./taskLineage.js";
 export interface RunTaskLoopInput {
     repo_path: string;