patchwarden 1.6.1 → 1.6.2

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

@@ -5,6 +5,7 @@ export interface ReconcileTasksInput {
     max_age_minutes?: number;
     mode?: ReconcileMode;
     include_done_candidates?: boolean;
+    task_ids?: string[];
 }
 export interface ReconcileTaskReport {
     task_id: string;
@@ -15,7 +16,7 @@ export interface ReconcileTaskReport {
     reasons: string[];
     safe_actions: SafeAction[];
     age_seconds: number | null;
-    action_taken: "left_unchanged" | "marked_failed_stale" | "marked_orphaned" | "marked_done_by_agent";
+    action_taken: "left_unchanged" | "marked_failed_stale" | "marked_orphaned" | "marked_done_by_agent" | "marked_canceled" | "marked_timed_out";
     previous_status: string | null;
     new_status: string | null;
     applied_at: string | null;

package/dist/tools/tasks/reconcileTasks.js

@@ -4,8 +4,10 @@ import { getTasksDir, getConfig } from "../../config.js";
 import { diagnoseTask } from "./diagnoseTask.js";
 import { syncSubgoalOnTaskDone, readTaskGoalMeta } from "../../goal/subgoalSync.js";
 import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
-import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+import { writeTaskRuntime } from "../../runner/taskRuntime.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 import { appendBoundedTextFileSync } from "../../utils/boundedFile.js";
+import { isActiveTaskStatus } from "./taskStates.js";
 // ── Defaults ────────────────────────────────────────────────────────
 const DEFAULT_MAX_AGE_MINUTES = 30;
 const RECONCILE_LOG_NAME = "reconcile.log";
@@ -16,6 +18,9 @@ export function reconcileTasks(input = {}, config = getConfig()) {
         ? Math.min(input.max_age_minutes, 24 * 60)
         : DEFAULT_MAX_AGE_MINUTES;
     const includeDoneCandidates = input.include_done_candidates !== false; // default true
+    const requestedTaskIds = input.task_ids?.length
+        ? new Set(input.task_ids.filter((taskId) => /^task[-_][a-zA-Z0-9_-]+$/.test(taskId)))
+        : null;
     const maxAgeSeconds = maxAgeMinutes * 60;
     const tasksDir = getTasksDir(config);
     const reports = [];
@@ -55,8 +60,10 @@ export function reconcileTasks(input = {}, config = getConfig()) {
     }
     const taskDirs = entries.filter((e) => e.isDirectory());
     for (const entry of taskDirs) {
-        scanned += 1;
         const taskId = entry.name;
+        if (requestedTaskIds && !requestedTaskIds.has(taskId))
+            continue;
+        scanned += 1;
         const taskDir = resolve(tasksDir, taskId);
         const statusFile = join(taskDir, "status.json");
         if (!existsSync(statusFile))
@@ -69,17 +76,16 @@ export function reconcileTasks(input = {}, config = getConfig()) {
             continue; // corrupted status, skip
         }
         const statusStr = typeof statusData.status === "string" ? statusData.status : "unknown";
-        // Filter: only running / collecting_artifacts / (optionally) done_by_agent candidates
-        const isCandidate = statusStr === "running" ||
-            statusStr === "collecting_artifacts" ||
+        // Scan every persisted non-terminal lifecycle spelling, including legacy
+        // phase-as-status records left by older Watchers.
+        const isCandidate = isActiveTaskStatus(statusStr) ||
             (includeDoneCandidates && statusStr === "done_by_agent");
         if (!isCandidate)
             continue;
-        // Filter by age — use the oldest reliable timestamp on the task
+        // Use the oldest reliable timestamp for ordinary stale detection. Explicit
+        // cancel, persisted deadline, and Watcher-instance mismatch bypass this
+        // age gate so a restart cannot extend the task's total budget.
         const ageSeconds = taskAgeSeconds(taskDir, statusData, nowMs);
-        if (ageSeconds !== null && ageSeconds < maxAgeSeconds)
-            continue;
-        candidates += 1;
         // Diagnose the task
         let diagnosis;
         try {
@@ -88,6 +94,14 @@ export function reconcileTasks(input = {}, config = getConfig()) {
         catch {
             continue; // diagnosis failed — skip
         }
+        const cancellationRequested = statusData.cancel_requested === true || statusStr === "cancel_requested";
+        const deadlineExceeded = taskDeadlineExceeded(statusData, nowMs);
+        const urgentRecovery = cancellationRequested
+            || deadlineExceeded
+            || diagnosis.diagnosis === "orphaned_running";
+        if (ageSeconds !== null && ageSeconds < maxAgeSeconds && !urgentRecovery)
+            continue;
+        candidates += 1;
         const report = {
             task_id: taskId,
             status: diagnosis.status,
@@ -120,7 +134,9 @@ export function reconcileTasks(input = {}, config = getConfig()) {
         //   4. The diagnosis type maps to a reconcilable action.
         //
         // Anything else is left_unchanged and recorded for audit.
-        if (mode === "safe_fix" && diagnosis.confidence === "high") {
+        const deterministicRecovery = !diagnosis.evidence.watcher_owns_task
+            && (cancellationRequested || deadlineExceeded);
+        if (mode === "safe_fix" && (diagnosis.confidence === "high" || deterministicRecovery)) {
             if (diagnosis.evidence.watcher_owns_task) {
                 // Hard rule: do not touch tasks the live watcher still owns.
                 skippedActiveWatcher += 1;
@@ -184,35 +200,45 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
     const previousStatus = typeof currentStatus.status === "string" ? currentStatus.status : "unknown";
     let newStatus = null;
     let actionTaken = "left_unchanged";
-    switch (diagnosis) {
-        case "stale_running":
-            newStatus = "failed_stale";
-            actionTaken = "marked_failed_stale";
-            break;
-        case "orphaned_running":
-            newStatus = "orphaned";
-            actionTaken = "marked_orphaned";
-            break;
-        case "done_candidate":
-            newStatus = "done_by_agent";
-            actionTaken = "marked_done_by_agent";
-            break;
-        case "artifact_collection_stuck":
-            // Treat as failed_stale — artifact collection should not hang.
-            newStatus = "failed_stale";
-            actionTaken = "marked_failed_stale";
-            break;
-        default:
-            // active_running, possibly_stale_running, unknown, terminal — not eligible
-            return {
-                applied: false,
-                action_taken: "left_unchanged",
-                previous_status: previousStatus,
-                new_status: previousStatus,
-                applied_at: new Date().toISOString(),
-                skip_reason: `diagnosis "${diagnosis}" has no automatic safe_fix action`,
-            };
+    const cancellationRequested = currentStatus.cancel_requested === true || previousStatus === "cancel_requested";
+    if (!evidence.watcher_owns_task && cancellationRequested) {
+        newStatus = "canceled";
+        actionTaken = "marked_canceled";
+    }
+    else if (!evidence.watcher_owns_task && taskDeadlineExceeded(currentStatus)) {
+        newStatus = "timeout";
+        actionTaken = "marked_timed_out";
     }
+    else
+        switch (diagnosis) {
+            case "stale_running":
+                newStatus = "failed_stale";
+                actionTaken = "marked_failed_stale";
+                break;
+            case "orphaned_running":
+                newStatus = "orphaned";
+                actionTaken = "marked_orphaned";
+                break;
+            case "done_candidate":
+                newStatus = "done_by_agent";
+                actionTaken = "marked_done_by_agent";
+                break;
+            case "artifact_collection_stuck":
+                // Treat as failed_stale — artifact collection should not hang.
+                newStatus = "failed_stale";
+                actionTaken = "marked_failed_stale";
+                break;
+            default:
+                // active_running, possibly_stale_running, unknown, terminal — not eligible
+                return {
+                    applied: false,
+                    action_taken: "left_unchanged",
+                    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");
@@ -247,14 +273,42 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
                         current_watcher_instance_id: evidence.current_watcher_instance_id,
                     },
                 },
+                process_cleanup_required: !evidence.watcher_owns_task,
+                process_cleanup_reason: !evidence.watcher_owns_task
+                    ? "The previous runner is no longer owned by this Watcher; child-process termination could not be confirmed and no untrusted PID was killed."
+                    : null,
             };
+            if (newStatus === "canceled") {
+                next.canceled_at = appliedAt;
+                next.cancel_reason = "Cancellation converged after the original task runner stopped responding.";
+                next.termination_reason = "canceled";
+                next.error_code = "runner_lost_during_cancel";
+            }
+            else if (actionTaken === "marked_timed_out") {
+                next.error = `Task exceeded its configured timeout of ${Number(current.timeout_seconds)} seconds after the original runner stopped responding.`;
+                next.termination_reason = "timeout";
+                next.error_code = "task_timeout";
+            }
+            else if (diagnosis === "artifact_collection_stuck") {
+                next.error = "Artifact collection was interrupted and could not be safely resumed after the original runner stopped responding.";
+                next.error_code = "artifact_collection_interrupted";
+            }
+            else if (diagnosis === "orphaned_running") {
+                next.error = "The original task runner was lost and its child process ownership could not be re-established.";
+                next.error_code = "agent_lost";
+            }
+            else if (diagnosis === "stale_running") {
+                next.error = "The task runner heartbeat expired and no current Runner ownership could be proven.";
+                next.error_code = "agent_lost";
+            }
             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"));
+            if (!existsSync(backupFile))
+                atomicWriteFileSync(backupFile, readFileSync(statusFile, "utf-8"));
             return {
                 next,
                 result: { applied: true },
@@ -281,6 +335,20 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
             skip_reason: "task status could not be locked, backed up, and updated",
         };
     }
+    if (newStatus !== "done_by_agent") {
+        writeRecoveryArtifacts(taskDir, taskId, currentStatus, newStatus, actionTaken, appliedAt);
+    }
+    // Keep the persisted runtime view terminal as well. get_task_status merges
+    // runtime.json over status.json, so leaving an old executing phase here
+    // would make a successfully reconciled task appear active again.
+    writeTaskRuntime(taskDir, {
+        phase: newStatus,
+        current_command: null,
+        last_heartbeat_at: appliedAt,
+        child_pid: undefined,
+        child_started_at: undefined,
+        child_owned_by_runner_instance_id: undefined,
+    });
     // v0.8.0: 当状态变为 done_by_agent 时，同步关联 subgoal 状态（running → done_by_agent）
     if (newStatus === "done_by_agent") {
         const goalMeta = readTaskGoalMeta(taskDir);
@@ -297,6 +365,84 @@ function applySafeFix(taskDir, taskId, currentStatus, diagnosis, reasons, eviden
         skip_reason: null,
     };
 }
+function writeRecoveryArtifacts(taskDir, taskId, status, newStatus, actionTaken, recoveredAt) {
+    const timeoutSeconds = Number(status.timeout_seconds);
+    const summary = actionTaken === "marked_timed_out"
+        ? `Task exceeded its configured timeout of ${timeoutSeconds} seconds after the original runner stopped responding.`
+        : actionTaken === "marked_canceled"
+            ? "Cancellation converged after the original task runner stopped responding."
+            : `Task was reconciled to ${newStatus} after the original runner stopped responding.`;
+    const errorCode = actionTaken === "marked_timed_out"
+        ? "task_timeout"
+        : actionTaken === "marked_canceled"
+            ? "runner_lost_during_cancel"
+            : newStatus === "orphaned"
+                ? "agent_lost"
+                : newStatus === "failed_stale" && String(status.phase || status.status) === "collecting_artifacts"
+                    ? "artifact_collection_interrupted"
+                    : "agent_lost";
+    const requestedCommands = Array.isArray(status.verify_commands)
+        ? status.verify_commands.map(String)
+        : [];
+    const artifacts = {
+        "verify.json": {
+            status: "failed",
+            requested_commands: requestedCommands,
+            commands: [],
+            failure_reason: "runner_recovery",
+            error_code: errorCode,
+        },
+        "result.json": {
+            task_id: taskId,
+            status: newStatus,
+            agent: status.agent || "",
+            repo_path: status.repo_path || "",
+            resolved_repo_path: status.resolved_repo_path || "",
+            summary,
+            artifact_status: "partial",
+            changed_files: [],
+            diff_available: false,
+            verify_status: "failed",
+            failure_reason: "runner_recovery",
+            error_code: errorCode,
+            termination_reason: actionTaken === "marked_timed_out"
+                ? "timeout"
+                : actionTaken === "marked_canceled"
+                    ? "canceled"
+                    : "runner_stale",
+            recovered_at: recoveredAt,
+            warnings: ["The original runner stopped before complete change and verification evidence could be collected."],
+        },
+    };
+    for (const [name, value] of Object.entries(artifacts)) {
+        const path = join(taskDir, name);
+        if (!existsSync(path))
+            atomicWriteJsonFileSync(path, value);
+    }
+    const textArtifacts = {
+        "result.md": `# PatchWarden Task Result\n\n## Status\n${newStatus}\n\n## Summary\n${summary}\n\n## Artifact Status\npartial\n`,
+        "test.log": `(not run)\nExit code: not run\n${summary}\n`,
+        "git.diff": `(unavailable: ${summary})\n`,
+        "diff.patch": `(unavailable: ${summary})\n`,
+    };
+    for (const [name, content] of Object.entries(textArtifacts)) {
+        const path = join(taskDir, name);
+        if (!existsSync(path))
+            atomicWriteFileSync(path, content);
+    }
+}
+function taskDeadlineExceeded(status, nowMs = Date.now()) {
+    const timeoutSeconds = Number(status.timeout_seconds);
+    const startedAt = typeof status.started_at === "string"
+        ? Date.parse(status.started_at)
+        : typeof status.created_at === "string"
+            ? Date.parse(status.created_at)
+            : NaN;
+    return Number.isFinite(startedAt)
+        && Number.isFinite(timeoutSeconds)
+        && timeoutSeconds > 0
+        && nowMs >= startedAt + timeoutSeconds * 1000;
+}
 // ── reconcile.log writer ───────────────────────────────────────────
 function writeReconcileLog(tasksDir, config, appliedReports) {
     // The reconcile.log lives at the .patchwarden/ root (parent of tasksDir),

package/dist/tools/tasks/runTaskLoop.js

@@ -8,6 +8,7 @@ import { recommendAgentForTask } from "../workspace/recommendAgentForTask.js";
 import { runDirectVerificationBundle } from "../direct/runDirectVerificationBundle.js";
 import { waitForTask } from "./waitForTask.js";
 import { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
+import { isTerminalTaskStatus } from "./taskStates.js";
 import { createLineageId, writeTaskLineage, } from "./taskLineage.js";
 const DEFAULT_DEPS = {
     createTask,
@@ -26,15 +27,6 @@ const DEFAULT_DEPS = {
     now: () => new Date(),
     sleep,
 };
-const TERMINAL_STATUSES = new Set([
-    "done",
-    "done_by_agent",
-    "failed",
-    "failed_verification",
-    "failed_scope_violation",
-    "failed_policy_violation",
-    "canceled",
-]);
 export async function runTaskLoop(input) {
     return runTaskLoopWithDeps(input, DEFAULT_DEPS);
 }
@@ -186,7 +178,7 @@ async function waitUntilTerminal(taskId, timeoutSeconds, deps) {
     const deadline = Date.now() + timeoutSeconds * 1000;
     while (Date.now() < deadline) {
         const waited = await deps.waitForTask(taskId, 30);
-        if (waited.terminal || TERMINAL_STATUSES.has(String(waited.status))) {
+        if (waited.terminal || isTerminalTaskStatus(String(waited.status))) {
             return { next_action: waited.next_action || "safe_audit" };
         }
         if (waited.next_tool_call?.name === "health_check" || waited.continuation_required === false) {
@@ -241,7 +233,7 @@ function isSuccessfulRound(round) {
         round.audit_verdict === "pass");
 }
 function isHardStop(round, resultValue, auditValue, stopOnHighRisk) {
-    if (["failed_scope_violation", "failed_policy_violation", "canceled"].includes(round.status))
+    if (["failed_scope_violation", "failed_policy_violation", "canceled", "timeout"].includes(round.status))
         return true;
     if (!stopOnHighRisk)
         return false;
@@ -255,6 +247,8 @@ function hardStopReason(round, resultValue) {
     const result = asRecord(resultValue);
     if (round.status === "failed_scope_violation" || round.status === "failed_policy_violation")
         return "policy_blocked";
+    if (round.status === "timeout")
+        return "agent_timeout";
     if (String(result.failure_reason || "").toLowerCase().includes("timeout"))
         return "agent_timeout";
     return "high_risk_blocked";

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

@@ -14,7 +14,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     lines?: number;
     redact?: boolean;
 }): {
-    file: "test" | "stdout" | "stderr" | "verify";
+    file: "stdout" | "stderr" | "test" | "verify";
     lines: number;
     total_bytes: number;
     task_id: string;
@@ -37,7 +37,7 @@ export declare function getTaskLogTail(taskId: string, file: "stdout" | "stderr"
     truncated?: undefined;
 } | {
     task_id: string;
-    file: "test" | "stdout" | "stderr" | "verify";
+    file: "stdout" | "stderr" | "test" | "verify";
     filename: string;
     content: string;
     available: boolean;

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

@@ -0,0 +1,6 @@
+export declare const ACTIVE_TASK_STATUSES: Set<string>;
+export declare const TERMINAL_TASK_STATUSES: Set<string>;
+export declare function isTerminalTaskStatus(status: string): boolean;
+export declare function isActiveTaskStatus(status: string): boolean;
+/** Terminal states are immutable; active states may only advance or terminate. */
+export declare function isAllowedTaskStatusTransition(from: string, to: string): boolean;

package/dist/tools/tasks/taskStates.js

@@ -0,0 +1,52 @@
+export const ACTIVE_TASK_STATUSES = new Set([
+    "pending",
+    "running",
+    "executing_agent",
+    "verifying",
+    "collecting_artifacts",
+    "cancel_requested",
+]);
+export const TERMINAL_TASK_STATUSES = new Set([
+    "done",
+    "done_by_agent",
+    "accepted",
+    "rejected",
+    "needs_fix",
+    "blocked",
+    "failed",
+    "failed_verification",
+    "failed_scope_violation",
+    "failed_policy_violation",
+    "failed_stale",
+    "orphaned",
+    "timeout",
+    "canceled",
+]);
+export function isTerminalTaskStatus(status) {
+    return TERMINAL_TASK_STATUSES.has(status);
+}
+export function isActiveTaskStatus(status) {
+    return ACTIVE_TASK_STATUSES.has(status);
+}
+/** Terminal states are immutable; active states may only advance or terminate. */
+export function isAllowedTaskStatusTransition(from, to) {
+    if (from === to)
+        return true;
+    if (isTerminalTaskStatus(from))
+        return false;
+    if (!isActiveTaskStatus(from) || !isActiveTaskStatus(to) && !isTerminalTaskStatus(to))
+        return false;
+    if (from === "pending") {
+        return to === "running" || isTerminalTaskStatus(to);
+    }
+    if (to === "pending")
+        return false;
+    const forwardActive = {
+        running: new Set(["executing_agent", "verifying", "collecting_artifacts", "cancel_requested"]),
+        executing_agent: new Set(["verifying", "collecting_artifacts", "cancel_requested"]),
+        verifying: new Set(["collecting_artifacts", "cancel_requested"]),
+        collecting_artifacts: new Set(["cancel_requested"]),
+        cancel_requested: new Set(),
+    };
+    return isTerminalTaskStatus(to) || Boolean(forwardActive[from]?.has(to));
+}

package/dist/tools/tasks/waitForTask.js

@@ -1,15 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { getTaskStatus } from "./getTaskStatus.js";
 import { getTaskSummary } from "./getTaskSummary.js";
-const TERMINAL_STATUSES = new Set([
-    "done",
-    "done_by_agent",
-    "failed",
-    "failed_verification",
-    "failed_scope_violation",
-    "failed_policy_violation",
-    "canceled",
-]);
+import { isTerminalTaskStatus } from "./taskStates.js";
 export async function waitForTask(taskId, waitSeconds = 25) {
     if (!Number.isInteger(waitSeconds) || waitSeconds < 1 || waitSeconds > 30) {
         throw new Error("wait_seconds must be an integer from 1 to 30.");
@@ -17,11 +9,11 @@ export async function waitForTask(taskId, waitSeconds = 25) {
     const started = Date.now();
     const deadline = started + waitSeconds * 1000;
     let status = getTaskStatus(taskId);
-    while (!TERMINAL_STATUSES.has(status.status) && Date.now() < deadline) {
+    while (!isTerminalTaskStatus(status.status) && Date.now() < deadline) {
         await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
         status = getTaskStatus(taskId);
     }
-    const terminal = TERMINAL_STATUSES.has(status.status);
+    const terminal = isTerminalTaskStatus(status.status);
     const executionBlocked = !terminal && status.execution_blocked;
     const elapsed = Math.round((Date.now() - started) / 1000);
     const progressSummary = {

package/dist/tools/workspace/listAgents.d.ts

@@ -10,8 +10,14 @@ export interface AgentAvailability {
     capabilities: {
         model_override: boolean;
     };
+    availability_scope: "executable_only";
+    provider_status: "not_checked";
+    invocation_ready?: boolean;
+    model_argument_present?: boolean;
 }
 export declare function listAgents(): {
     agents: AgentAvailability[];
     total: number;
+    config_path: string;
+    workspace_root: string;
 };

package/dist/tools/workspace/listAgents.js

@@ -1,14 +1,20 @@
 import { existsSync, statSync } from "node:fs";
-import { basename, delimiter, extname, isAbsolute, join } from "node:path";
+import { basename, delimiter, extname, isAbsolute, join, resolve } from "node:path";
 import { getConfig } from "../../config.js";
 import { sanitizeTrustedPath } from "../../runner/processSecurity.js";
 export function listAgents() {
     const config = getConfig();
     const checkedAt = new Date().toISOString();
+    const configPath = process.env.PATCHWARDEN_CONFIG
+        ? resolve(process.env.PATCHWARDEN_CONFIG)
+        : resolve(process.cwd(), "patchwarden.config.json");
     const agents = Object.entries(config.agents)
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([name, agent]) => {
         const available = commandExists(agent.command, config.workspaceRoot);
+        const modelArgumentPresent = typeof agent.model === "string"
+            ? agent.args.some((arg, index) => arg === "--model" && agent.args[index + 1] === agent.model)
+            : true;
         return {
             name,
             configured: true,
@@ -19,9 +25,13 @@ export function listAgents() {
             adapter: typeof agent.adapter === "string" ? agent.adapter : ["codex", "opencode"].includes(name) ? name : null,
             model: typeof agent.model === "string" ? agent.model : null,
             capabilities: { model_override: typeof agent.adapter === "string" || ["codex", "opencode"].includes(name) },
+            availability_scope: "executable_only",
+            provider_status: "not_checked",
+            invocation_ready: available && modelArgumentPresent,
+            model_argument_present: modelArgumentPresent,
         };
     });
-    return { agents, total: agents.length };
+    return { agents, total: agents.length, config_path: configPath, workspace_root: config.workspaceRoot };
 }
 function commandExists(command, workspaceRoot) {
     if (isAbsolute(command) || command.includes("/") || command.includes("\\")) {

package/dist/utils/atomicFile.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, fsyncSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
 const transientWindowsRenameErrors = new Set(["EACCES", "EBUSY", "EPERM"]);
 const renameRetryDeadlineMs = 1_000;
 const renameRetryDelayMs = 10;
@@ -13,6 +13,25 @@ export function atomicWriteFileSync(path, content, options = {}) {
             flag: "wx",
             ...(options.mode === undefined ? {} : { mode: options.mode }),
         });
+        const descriptor = openSync(temporaryPath, "r");
+        try {
+            try {
+                fsyncSync(descriptor);
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code || "")
+                    : "";
+                // Some Windows filesystems and restricted runtimes reject fsync even
+                // after a successful complete write. Keep the same-directory atomic
+                // rename guarantee there; unexpected I/O errors still fail closed.
+                if (!new Set(["EPERM", "EINVAL", "ENOSYS", "ENOTSUP"]).has(code))
+                    throw error;
+            }
+        }
+        finally {
+            closeSync(descriptor);
+        }
         replaceFileSync(temporaryPath, path);
     }
     catch (error) {

package/dist/version.d.ts

@@ -1,3 +1,3 @@
-export declare const PATCHWARDEN_VERSION = "1.6.1";
+export declare const PATCHWARDEN_VERSION = "1.6.2";
 export declare const TOOL_SCHEMA_EPOCH = "2026-07-19-v15";
 export declare const ARTIFACT_SCHEMA_VERSION = "2026-07-19-v15";

package/dist/version.js

@@ -1,3 +1,3 @@
-export const PATCHWARDEN_VERSION = "1.6.1";
+export const PATCHWARDEN_VERSION = "1.6.2";
 export const TOOL_SCHEMA_EPOCH = "2026-07-19-v15";
 export const ARTIFACT_SCHEMA_VERSION = TOOL_SCHEMA_EPOCH;

package/docs/CODE_WIKI.md

@@ -1,7 +1,7 @@
 # PatchWarden Code Wiki
 
 > 本文档是对 PatchWarden 仓库的结构化代码导览，覆盖项目整体架构、主要模块职责、关键类与函数说明、依赖关系、运行方式，以及现有缺陷分析。
-> 源码版本：**v1.6.1** · Schema Epoch：`2026-07-19-v15` · 复核日期：2026-07-20 · License：MIT
+> 源码版本：**v1.6.2** · Schema Epoch：`2026-07-19-v15` · 复核日期：2026-07-25 · License：MIT
 
 ## 目录
 
@@ -254,7 +254,7 @@ PatchWarden/
 │   └── release/                  # 发布打包
 ├── docs/                         # 文档
 ├── examples/                     # 配置与 Tunnel 示例
-├── package.json                  # v1.6.1，单一直接运行时依赖
+├── package.json                  # v1.6.2，单一直接运行时依赖
 ├── tsconfig.json
 └── PatchWarden.cmd               # Windows 统一控制入口
 ```
@@ -278,7 +278,7 @@ PatchWarden/
 | --- | --- |
 | [src/config.ts](../src/config.ts) | 加载并校验 `patchwarden.config.json`，提供 `loadConfig`/`getConfig`/`getTasksDir`/`getPlansDir`/`resolveWorkspaceRoot`/`getRepoAllowedTestCommands`/`getRepoDirectAllowedCommands` 等路径解析；严格校验 `workspaceRoot`、`agents`、`allowedTestCommands`、`watcherStaleSeconds`、`toolProfile`、`tunnelProxy`、Direct 数值范围等字段；含 `normalizeRepoKey` 与 `comparablePath` 工具 |
 | [src/errors.ts](../src/errors.ts) | 定义 `PatchWardenError`（含 `reason`/`suggestion`/`blocked`/`details`）与 `errorPayload` 序列化 |
-| [src/version.ts](../src/version.ts) | 导出 `PATCHWARDEN_VERSION = "1.6.1"` 与 `TOOL_SCHEMA_EPOCH = "2026-07-19-v15"` |
+| [src/version.ts](../src/version.ts) | 导出 `PATCHWARDEN_VERSION = "1.6.2"` 与 `TOOL_SCHEMA_EPOCH = "2026-07-19-v15"` |
 | [src/logging.ts](../src/logging.ts) | `Logger` 类输出 stderr JSON 日志，记录 `audit`/`info`/`warn`/`error`；`logToolInvocation` 仅写参数 digest，不写原参数，并通过跨进程锁有界追加到 5 MiB；`installGlobalHandlers` 捕获未处理异常但不吞错 |
 
 ### 4.3 安全模块（src/security/）
@@ -1555,7 +1555,7 @@ npm.cmd run desktop:package   # 打包：先 stage 主仓 dist/，再 electron-b
 | 主包 `@types/node` | `^26.1.0` | `^18.19.0`（与 Node.js 18 最低运行时对齐） |
 | `chatgpt_direct` 工具数 | 15 | 14 |
 
-> 注：根目录 `README.md` 仍写"v1.6.0"，需在下一次 README 维护时同步到 v1.6.1。
+> 根目录中英文 README 的下载链接、安装器哈希和公开版本事实已同步到 v1.6.1。
 
 #### ✅ 11.7.2 v1.5.1/v1.6.0/v1.6.1 新功能导览 — 已修复