patchwarden 1.5.0 → 1.6.1

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/{retryTask.d.ts → tasks/retryTask.d.ts}

@@ -1,8 +1,8 @@
-export declare function retryTask(taskId: string): {
+export declare function retryTask(taskId: string): Promise<{
     original_task_id: string;
     new_task_id: string;
     plan_id: string;
     agent: string;
     status: import("./createTask.js").TaskStatus;
     message: string;
-};
+}>;

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;

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

@@ -1,13 +1,13 @@
 import { setTimeout as sleep } from "node:timers/promises";
-import { getConfig } from "../config.js";
-import { createWorktree } from "../goal/worktreeManager.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
-import { createDirectSession } from "./createDirectSession.js";
+import { getConfig } from "../../config.js";
+import { createWorktree } from "../../goal/worktreeManager.js";
+import { guardWorkspacePath } from "../../security/pathGuard.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 { safeAudit, safeAuditDirectSession, safeFinalizeDirectSession, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
 import { createLineageId, writeTaskLineage, } from "./taskLineage.js";
 const DEFAULT_DEPS = {
     createTask,
@@ -130,17 +130,17 @@ export async function runTaskLoopWithDeps(input, deps) {
             timeout_seconds: normalized.task_timeout_seconds,
             execution_mode: "assess_only",
         };
-        const assessment = deps.createTask(assessmentInput);
+        const assessment = asRecord(await deps.createTask(assessmentInput));
         if (assessment.decision === "blocked") {
-            return finalize("blocked", "high_risk_blocked", "Risk assessment blocked task execution.", assessment.reason_codes?.join(", "));
+            return finalize("blocked", "high_risk_blocked", "Risk assessment blocked task execution.", asArray(assessment.reason_codes).map(String).join(", "));
         }
         if (assessment.decision === "needs_confirm") {
             return finalize("blocked", "user_confirmation_required", "Ask the user to confirm the assessment before executing the loop.");
         }
-        const created = deps.createTask({
+        const created = asRecord(await deps.createTask({
             execution_mode: "execute",
             assessment_id: String(assessment.assessment_id || ""),
-        });
+        }));
         const taskId = String(created.task_id || "");
         if (!taskId) {
             return finalize("failed", "policy_blocked", "create_task returned no task_id.", "create_task returned no task_id");
@@ -153,9 +153,9 @@ export async function runTaskLoopWithDeps(input, deps) {
         if (wait.stop_reason) {
             return finalize("blocked", wait.stop_reason, wait.next_action, wait.error);
         }
-        const result = deps.safeResult(taskId, { max_items: 8 });
-        const tests = deps.safeTestSummary(taskId);
-        const audit = deps.safeAudit(taskId, { max_items: 8 });
+        const result = asRecord(deps.safeResult(taskId, { max_items: 8 }));
+        const tests = asRecord(deps.safeTestSummary(taskId));
+        const audit = asRecord(deps.safeAudit(taskId, { max_items: 8 }));
         const round = buildRound(iteration, taskId, role, result, tests, audit);
         lineage.rounds.push(round);
         lineage.updated_at = deps.now().toISOString();
@@ -204,20 +204,32 @@ async function waitUntilTerminal(taskId, timeoutSeconds, deps) {
         error: `Task loop timed out waiting for ${taskId}.`,
     };
 }
-function buildRound(iteration, taskId, role, result, tests, audit) {
-    const failChecks = Array.isArray(audit.fail_checks) ? audit.fail_checks.map((entry) => String(entry.name || entry)) : [];
-    const warnChecks = Array.isArray(audit.warn_checks) ? audit.warn_checks.map((entry) => String(entry.name || entry)) : [];
+function buildRound(iteration, taskId, role, resultValue, testsValue, auditValue) {
+    const result = asRecord(resultValue);
+    const tests = asRecord(testsValue);
+    const audit = asRecord(auditValue);
+    const resultVerification = asRecord(result.verification);
+    const auditAcceptance = asRecord(audit.acceptance);
+    const failChecks = asArray(audit.fail_checks).map((entry) => {
+        const check = asRecord(entry);
+        return String(check.name || entry);
+    });
+    const warnChecks = asArray(audit.warn_checks).map((entry) => {
+        const check = asRecord(entry);
+        return String(check.name || entry);
+    });
+    const recommendedActions = asArray(audit.recommended_next_actions);
     return {
         iteration,
         task_id: taskId,
         role,
         status: String(result.status || "unknown"),
         terminal: Boolean(result.terminal),
-        verification_status: String(tests.status || result.verification?.status || "not_available"),
-        audit_verdict: String(audit.verdict || audit.acceptance?.verdict || "unknown"),
+        verification_status: String(tests.status || resultVerification.status || "not_available"),
+        audit_verdict: String(audit.verdict || auditAcceptance.verdict || "unknown"),
         fail_checks: failChecks,
         warn_checks: warnChecks,
-        next_action: String(result.next_action || audit.recommended_next_actions?.[0] || "review_task"),
+        next_action: String(result.next_action || recommendedActions[0] || "review_task"),
     };
 }
 function isSuccessfulRound(round) {
@@ -228,23 +240,27 @@ function isSuccessfulRound(round) {
         round.warn_checks.length === 0 &&
         round.audit_verdict === "pass");
 }
-function isHardStop(round, result, audit, stopOnHighRisk) {
+function isHardStop(round, resultValue, auditValue, stopOnHighRisk) {
     if (["failed_scope_violation", "failed_policy_violation", "canceled"].includes(round.status))
         return true;
     if (!stopOnHighRisk)
         return false;
     const checkNames = [...round.fail_checks, ...round.warn_checks].join(" ").toLowerCase();
-    const reason = String(result.failure_reason || audit.acceptance?.reason || "").toLowerCase();
+    const result = asRecord(resultValue);
+    const audit = asRecord(auditValue);
+    const reason = String(result.failure_reason || asRecord(audit.acceptance).reason || "").toLowerCase();
     return /scope|secret|sensitive|publish|release|policy|push/.test(`${checkNames} ${reason}`);
 }
-function hardStopReason(round, result) {
+function hardStopReason(round, resultValue) {
+    const result = asRecord(resultValue);
     if (round.status === "failed_scope_violation" || round.status === "failed_policy_violation")
         return "policy_blocked";
     if (String(result.failure_reason || "").toLowerCase().includes("timeout"))
         return "agent_timeout";
     return "high_risk_blocked";
 }
-function buildFixGoal(originalGoal, result, round) {
+function buildFixGoal(originalGoal, resultValue, round) {
+    const result = asRecord(resultValue);
     const failedCommand = result.failed_command ? ` Failed command: ${result.failed_command}.` : "";
     return [
         `Fix the failing verification for this PatchWarden loop without changing unrelated behavior.`,
@@ -293,7 +309,7 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
     }
     let sessionId = "";
     try {
-        const session = deps.createDirectSession({
+        const session = await deps.createDirectSession({
             repo_path: repoPath,
             title: `Direct verification for ${lineageId}`,
         });
@@ -303,8 +319,12 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
             commands: normalized.direct_verify_commands,
             timeout_seconds: normalized.direct_verify_timeout_seconds,
         });
-        const finalized = deps.safeFinalizeDirectSession(sessionId, { max_items: 8 });
-        const audit = deps.safeAuditDirectSession(sessionId, { max_items: 8 });
+        const finalized = asRecord(await deps.safeFinalizeDirectSession(sessionId, { max_items: 8 }));
+        const audit = asRecord(deps.safeAuditDirectSession(sessionId, { max_items: 8 }));
+        const auditEvidence = asRecord(audit.evidence);
+        const auditDecision = audit.decision === "pass" || audit.decision === "warn" || audit.decision === "fail"
+            ? audit.decision
+            : "not_run";
         const evidence = {
             session_id: sessionId,
             status: bundle.status,
@@ -312,8 +332,8 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
             passed_commands: bundle.passed_commands,
             failed_commands: bundle.failed_commands,
             timed_out_commands: bundle.timed_out_commands,
-            audit_decision: audit.decision || "not_run",
-            changed_files_total: Number(finalized.changed_files_total || audit.evidence?.changed_files_total || 0),
+            audit_decision: auditDecision,
+            changed_files_total: Number(finalized.changed_files_total || auditEvidence.changed_files_total || 0),
             next_action: String(audit.next_action || bundle.next_action || "review_direct_session"),
         };
         if (bundle.status !== "passed") {
@@ -325,7 +345,7 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
                 error: "Direct verification failed.",
             };
         }
-        if (audit.decision === "fail") {
+        if (auditDecision === "fail") {
             return {
                 evidence,
                 stop_reason: "direct_audit_failed",
@@ -338,7 +358,7 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
             evidence,
             final_status: "accepted",
             next_action: "accept",
-            warning: audit.decision === "warn" ? "Direct audit completed with warnings." : undefined,
+            warning: auditDecision === "warn" ? "Direct audit completed with warnings." : undefined,
         };
     }
     catch (err) {
@@ -357,6 +377,14 @@ async function runDirectVerification(lineageId, normalized, repoPath, deps) {
         };
     }
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
 function normalizeInput(input) {
     const config = getConfig();
     const repoPath = String(input.repo_path || "").trim();

package/dist/tools/tasks/runVerification.js

@@ -0,0 +1,38 @@
+import { readDirectSession, appendDirectSessionVerificationRun, withDirectSessionMutationLockAsync, } from "../../direct/directSessionStore.js";
+import { guardDirectSessionActive } from "../../direct/directGuards.js";
+import { runDirectVerification } from "../../direct/directVerification.js";
+export async function runVerification(input) {
+    return withDirectSessionMutationLockAsync(input.session_id, async () => {
+        // 1. Read session and guard active
+        const session = readDirectSession(input.session_id);
+        guardDirectSessionActive(session);
+        // 2. Call runDirectVerification with command, resolvedRepoPath,
+        //    sessionId, and timeoutSeconds
+        const timeoutSeconds = input.timeout_seconds ?? 120;
+        const result = await runDirectVerification({
+            command: input.command,
+            resolvedRepoPath: session.resolved_repo_path,
+            sessionId: input.session_id,
+            timeoutSeconds,
+        });
+        // 3. Append verification run to session
+        appendDirectSessionVerificationRun(input.session_id, result.run);
+        // 4. Return result
+        return {
+            command: result.run.command,
+            exit_code: result.run.exit_code,
+            passed: result.run.passed,
+            timed_out: result.run.timed_out,
+            redacted: Boolean(result.run.redacted),
+            redaction_categories: result.run.redaction_categories || [],
+            started_at: result.run.started_at,
+            finished_at: result.run.finished_at,
+            stdout_tail: result.run.stdout_tail,
+            stderr_tail: result.run.stderr_tail,
+            log_path: result.run.log_path,
+            next_action: result.run.passed
+                ? "Call finalize_direct_session to complete the session."
+                : "Review the verification output and apply_patch to fix issues.",
+        };
+    });
+}

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

@@ -1,10 +1,11 @@
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { redactSensitiveValue } from "../security/contentRedaction.js";
-import { PatchWardenError } from "../errors.js";
+import { getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import { PatchWardenError } from "../../errors.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 export function createLineageId(now = new Date()) {
     const stamp = now.toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
     return `lineage_${stamp}_${randomBytes(4).toString("hex")}`;
@@ -14,8 +15,8 @@ export function writeTaskLineage(record) {
     const lineageDir = resolve(config.workspaceRoot, ".patchwarden", "lineages", record.lineage_id);
     mkdirSync(lineageDir, { recursive: true });
     const safeRecord = redactSensitiveValue(record).value;
-    writeFileSync(join(lineageDir, "lineage.json"), JSON.stringify(safeRecord, null, 2) + "\n", "utf-8");
-    writeFileSync(join(lineageDir, "SUMMARY.md"), buildSummaryMarkdown(safeRecord), "utf-8");
+    atomicWriteJsonFileSync(join(lineageDir, "lineage.json"), safeRecord);
+    atomicWriteFileSync(join(lineageDir, "SUMMARY.md"), buildSummaryMarkdown(safeRecord));
     return toSafeTaskLineage(safeRecord);
 }
 export function getTaskLineage(lineageId, options = {}) {