patchwarden 0.6.4 → 1.5.0

package/dist/test/unit/project-policy-release-mode.test.js

@@ -0,0 +1,125 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { reloadConfig } from "../../config.js";
+import { getProjectPolicySummary } from "../../policy/projectPolicy.js";
+import { releaseCleanup, releasePrepare, releaseVerify } from "../../tools/releaseMode.js";
+let tempDir;
+let repoPath;
+let prevConfigEnv;
+function writeConfig(allowedTestCommands = ["npm test", "npm run build"]) {
+    const configPath = join(tempDir, "patchwarden.config.json");
+    writeFileSync(configPath, JSON.stringify({
+        workspaceRoot: tempDir,
+        plansDir: ".patchwarden/plans",
+        tasksDir: ".patchwarden/tasks",
+        assessmentsDir: ".patchwarden/assessments",
+        allowedTestCommands,
+        agents: {},
+        defaultTaskTimeoutSeconds: 30,
+        maxTaskTimeoutSeconds: 120,
+    }), "utf-8");
+    prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = configPath;
+    reloadConfig(configPath);
+}
+function writePackage(version = "1.3.0") {
+    writeFileSync(join(repoPath, "package.json"), JSON.stringify({
+        name: "patchwarden-test",
+        version,
+        repository: { type: "git", url: "git+https://github.com/example/patchwarden-test.git" },
+    }), "utf-8");
+}
+describe("project policy and release mode", () => {
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-policy-"));
+        repoPath = join(tempDir, "repo");
+        mkdirSync(repoPath, { recursive: true });
+        writePackage();
+        writeConfig();
+    });
+    afterEach(() => {
+        if (prevConfigEnv === undefined) {
+            delete process.env.PATCHWARDEN_CONFIG;
+        }
+        else {
+            process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+        }
+        reloadConfig();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("returns safe defaults when project-policy.json is missing", () => {
+        const summary = getProjectPolicySummary(repoPath);
+        assert.equal(summary.exists, false);
+        assert.equal(summary.valid, true);
+        assert.equal(summary.effective_policy.release_mode.version_source, "package.json");
+        assert.equal(summary.release_readiness.version, "1.3.0");
+    });
+    it("parses BOM-prefixed policy JSON and reports allowlist issues without granting permission", () => {
+        mkdirSync(join(repoPath, ".patchwarden"), { recursive: true });
+        writeFileSync(join(repoPath, ".patchwarden", "project-policy.json"), "\uFEFF" + JSON.stringify({
+            allowed_commands: ["npm run build", "npm publish"],
+            release_mode: {
+                version_source: "package.json",
+                required_commands: ["npm run build", "not-allowed"],
+            },
+        }), "utf-8");
+        const summary = getProjectPolicySummary(repoPath);
+        assert.equal(summary.exists, true);
+        assert.equal(summary.valid, false);
+        assert.ok(summary.issues.some((issue) => issue.code === "high_risk_command"));
+        assert.ok(summary.issues.some((issue) => issue.code === "command_not_allowlisted"));
+    });
+    it("rejects unsafe path patterns and sensitive protected paths block cleanup", () => {
+        mkdirSync(join(repoPath, ".patchwarden"), { recursive: true });
+        writeFileSync(join(repoPath, ".patchwarden", "project-policy.json"), JSON.stringify({
+            auto_cleanup: { enabled: true, patterns: ["../escape", ".git", "release_packages"], exclude: [] },
+            protected_paths: [".env", "release_packages"],
+        }), "utf-8");
+        mkdirSync(join(repoPath, "release_packages"), { recursive: true });
+        const summary = getProjectPolicySummary(repoPath);
+        assert.equal(summary.valid, false);
+        assert.ok(summary.issues.some((issue) => issue.code === "unsafe_path_pattern"));
+        const cleanup = releaseCleanup({ repo_path: repoPath, dry_run: true });
+        const skipped = cleanup.summary.skipped;
+        assert.ok(skipped.some((entry) => entry.path === "release_packages" && entry.reason === "protected_or_sensitive"));
+    });
+    it("release_cleanup defaults to dry run and writes BOM-free JSON summary", () => {
+        mkdirSync(join(repoPath, "release_packages"), { recursive: true });
+        const result = releaseCleanup({ repo_path: repoPath });
+        assert.equal(result.mode, "release_cleanup");
+        assert.equal(result.summary.dry_run, true);
+        assert.equal(existsSync(join(repoPath, "release_packages")), true);
+        const reportPath = join(repoPath, String(result.summary.report_path));
+        const raw = readFileSync(reportPath, "utf-8");
+        assert.notEqual(raw.charCodeAt(0), 0xfeff);
+        assert.doesNotThrow(() => JSON.parse(raw));
+    });
+    it("release_cleanup honors auto_cleanup.enabled=false before deleting", () => {
+        mkdirSync(join(repoPath, ".patchwarden"), { recursive: true });
+        writeFileSync(join(repoPath, ".patchwarden", "project-policy.json"), JSON.stringify({
+            auto_cleanup: { enabled: false, patterns: ["release_packages"], exclude: [] },
+        }), "utf-8");
+        mkdirSync(join(repoPath, "release_packages"), { recursive: true });
+        const result = releaseCleanup({ repo_path: repoPath, dry_run: false });
+        assert.equal(result.summary.cleanup_disabled_by_policy, true);
+        assert.deepEqual(result.summary.removed, []);
+        assert.equal(existsSync(join(repoPath, "release_packages")), true);
+    });
+    it("release_verify fails when required metadata cannot be inferred", async () => {
+        writeFileSync(join(repoPath, "package.json"), JSON.stringify({ name: "", version: "" }), "utf-8");
+        const result = await releaseVerify({ repo_path: repoPath });
+        assert.equal(result.ok, false);
+        const stages = result.summary.stages;
+        assert.equal(stages.published_verified, "failed");
+        assert.equal(stages.github_release_verified, "failed");
+        assert.equal(stages.ci_verified, "failed");
+    });
+    it("release_prepare blocks commands not accepted by the existing command guard", () => {
+        const result = releasePrepare({ repo_path: repoPath, required_commands: ["npm run build", "npm run secret"] });
+        const commands = result.summary.commands;
+        assert.equal(commands.find((entry) => entry.command === "npm run secret")?.status, "blocked");
+    });
+});

package/dist/test/unit/reconcile-tasks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/reconcile-tasks.test.js

@@ -0,0 +1,456 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, utimesSync, readFileSync, existsSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { reconcileTasks } from "../../tools/reconcileTasks.js";
+// ── Test fixtures ──────────────────────────────────────────────────
+function makeConfig(workspaceRoot) {
+    return {
+        workspaceRoot,
+        plansDir: ".patchwarden/plans",
+        tasksDir: ".patchwarden/tasks",
+        assessmentsDir: ".patchwarden/assessments",
+        assessmentTtlSeconds: 3600,
+        agents: { codex: { command: "codex", args: ["exec", "{prompt}"] } },
+        allowedTestCommands: ["npm test"],
+        repoAllowedTestCommands: {},
+        maxReadFileBytes: 200_000,
+        defaultTaskTimeoutSeconds: 900,
+        maxTaskTimeoutSeconds: 3600,
+        watcherStaleSeconds: 30,
+        directSessionsDir: ".patchwarden/direct-sessions",
+        directSessionTtlSeconds: 3600,
+        directMaxPatchBytes: 200_000,
+        directMaxFileBytes: 500_000,
+    };
+}
+const ALIVE_PID = process.pid;
+const DEAD_PID = 999999;
+function isoSecondsAgo(seconds) {
+    return new Date(Date.now() - seconds * 1000).toISOString();
+}
+function ageFile(filePath, secondsAgo) {
+    if (!existsSync(filePath))
+        return;
+    const targetSec = (Date.now() - secondsAgo * 1000) / 1000;
+    utimesSync(filePath, targetSec, targetSec);
+}
+describe("reconcileTasks", () => {
+    let tempDir;
+    let config;
+    let tasksDir;
+    let watcherHeartbeatPath;
+    let reconcileLogPath;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-reconcile-"));
+        config = makeConfig(tempDir);
+        tasksDir = join(tempDir, ".patchwarden", "tasks");
+        mkdirSync(tasksDir, { recursive: true });
+        watcherHeartbeatPath = join(dirname(tasksDir), "watcher-heartbeat.json");
+        reconcileLogPath = join(dirname(tasksDir), "reconcile.log");
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    function buildTask(opts) {
+        const taskId = opts.taskId;
+        const taskDir = join(tasksDir, taskId);
+        mkdirSync(taskDir, { recursive: true });
+        const statusSecondsAgo = opts.createdSecondsAgo ?? 600;
+        const status = {
+            task_id: taskId,
+            status: opts.status ?? "running",
+            phase: opts.phase ?? "executing_agent",
+            created_at: isoSecondsAgo(statusSecondsAgo),
+            updated_at: isoSecondsAgo(statusSecondsAgo),
+        };
+        if (opts.heartbeatSecondsAgo !== undefined) {
+            status.last_heartbeat_at = isoSecondsAgo(opts.heartbeatSecondsAgo);
+        }
+        writeFileSync(join(taskDir, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+        const runtime = {
+            phase: opts.phase ?? "executing_agent",
+        };
+        if (opts.heartbeatSecondsAgo !== undefined) {
+            runtime.last_heartbeat_at = isoSecondsAgo(opts.heartbeatSecondsAgo);
+        }
+        if (opts.childPid !== undefined) {
+            runtime.child_pid = opts.childPid;
+        }
+        if (opts.watcherInstanceId !== undefined) {
+            runtime.watcher_instance_id = opts.watcherInstanceId;
+        }
+        if (opts.taskStartedSecondsAgo !== undefined) {
+            runtime.task_started_at = isoSecondsAgo(opts.taskStartedSecondsAgo);
+        }
+        runtime.current_command = null;
+        writeFileSync(join(taskDir, "runtime.json"), JSON.stringify(runtime, null, 2), "utf-8");
+        if (opts.stdoutContent !== undefined) {
+            const stdoutPath = join(taskDir, "stdout.log");
+            writeFileSync(stdoutPath, opts.stdoutContent, "utf-8");
+            if (opts.stdoutSecondsAgo !== undefined)
+                ageFile(stdoutPath, opts.stdoutSecondsAgo);
+        }
+        if (opts.stderrContent !== undefined) {
+            const stderrPath = join(taskDir, "stderr.log");
+            writeFileSync(stderrPath, opts.stderrContent, "utf-8");
+            if (opts.stderrSecondsAgo !== undefined)
+                ageFile(stderrPath, opts.stderrSecondsAgo);
+        }
+        if (opts.resultMd) {
+            writeFileSync(join(taskDir, "result.md"), "# Result\nTask completed.", "utf-8");
+        }
+        if (opts.testLog) {
+            writeFileSync(join(taskDir, "test.log"), "TAP version 13\n1..1\nok 1 test", "utf-8");
+        }
+        if (opts.gitDiff) {
+            writeFileSync(join(taskDir, "git.diff"), "diff --git a/foo b/foo\n", "utf-8");
+        }
+        return taskDir;
+    }
+    function writeWatcherHeartbeat(instanceId, secondsAgo = 5) {
+        const heartbeat = {
+            last_heartbeat_at: isoSecondsAgo(secondsAgo),
+            pid: process.pid,
+            instance_id: instanceId,
+            launcher_pid: process.ppid ?? null,
+        };
+        writeFileSync(watcherHeartbeatPath, JSON.stringify(heartbeat, null, 2), "utf-8");
+    }
+    function readTaskStatus(taskId) {
+        const statusFile = join(tasksDir, taskId, "status.json");
+        return JSON.parse(readFileSync(statusFile, "utf-8"));
+    }
+    // ── 1. report_only: never modifies task state ──
+    it("report_only mode never modifies status.json", () => {
+        buildTask({
+            taskId: "task-rpo-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600, // stale
+            childPid: DEAD_PID, // dead
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        const result = reconcileTasks({ mode: "report_only" }, config);
+        assert.equal(result.mode, "report_only");
+        assert.equal(result.scanned, 1);
+        assert.equal(result.candidates, 1);
+        assert.equal(result.reconciled, 0); // no changes
+        assert.equal(result.reports.length, 1);
+        const report = result.reports[0];
+        assert.equal(report.task_id, "task-rpo-001");
+        assert.equal(report.action_taken, "left_unchanged");
+        assert.equal(report.previous_status, null);
+        assert.equal(report.new_status, null);
+        // status.json must be unchanged
+        const status = readTaskStatus("task-rpo-001");
+        assert.equal(status.status, "running");
+        // No backup file should exist
+        assert.ok(!existsSync(join(tasksDir, "task-rpo-001", "status.json.bak")));
+        // No reconcile.log should be written
+        assert.ok(!existsSync(reconcileLogPath));
+        assert.equal(result.reconcile_log_path, null);
+    });
+    // ── 2. safe_fix: only high-confidence diagnoses get applied ──
+    it("safe_fix applies mark_failed_stale for high-confidence stale_running", () => {
+        buildTask({
+            taskId: "task-sf-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        // No watcher heartbeat → task has no watcher_instance_id → no_runtime_record
+        // → stale_running with high confidence
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        assert.equal(result.mode, "safe_fix");
+        assert.equal(result.reconciled, 1);
+        assert.equal(result.skipped_low_confidence, 0);
+        assert.equal(result.skipped_active_watcher, 0);
+        const report = result.reports[0];
+        assert.equal(report.action_taken, "marked_failed_stale");
+        assert.equal(report.previous_status, "running");
+        assert.equal(report.new_status, "failed_stale");
+        assert.equal(report.applied_by, "reconcile_tasks");
+        assert.ok(report.applied_at !== null);
+        // status.json should reflect the new status
+        const status = readTaskStatus("task-sf-001");
+        assert.equal(status.status, "failed_stale");
+        assert.equal(status.previous_status, "running");
+        assert.equal(status.legacy_status, undefined); // only set for done_by_agent
+        // Audit fields should be present
+        const diagnosis = status.diagnosis;
+        assert.equal(diagnosis.type, "stale_running");
+        assert.equal(diagnosis.confidence, "high");
+        assert.equal(diagnosis.applied_by, "reconcile_tasks");
+        assert.ok(diagnosis.applied_at !== null);
+        assert.ok(Array.isArray(diagnosis.reasons));
+    });
+    // ── 3. safe_fix: skips medium-confidence diagnoses ──
+    it("safe_fix skips medium-confidence possibly_stale_running tasks", () => {
+        buildTask({
+            taskId: "task-sf-skip-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 200, // possibly stale
+            childPid: ALIVE_PID, // alive
+            watcherInstanceId: "watcher-A",
+            createdSecondsAgo: 2000,
+            stdoutContent: "output\n",
+            stdoutSecondsAgo: 400, // stale
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 400,
+        });
+        writeWatcherHeartbeat("watcher-A", 5);
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        assert.equal(result.reconciled, 0);
+        assert.equal(result.skipped_low_confidence, 1);
+        assert.equal(result.skipped_active_watcher, 0);
+        const report = result.reports[0];
+        assert.equal(report.action_taken, "left_unchanged");
+        // status.json unchanged
+        const status = readTaskStatus("task-sf-skip-001");
+        assert.equal(status.status, "running");
+        assert.ok(!existsSync(join(tasksDir, "task-sf-skip-001", "status.json.bak")));
+    });
+    // ── 4. safe_fix: skips tasks still owned by an active watcher ──
+    it("safe_fix skips tasks owned by an active watcher", () => {
+        buildTask({
+            taskId: "task-sf-owned-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600, // stale
+            childPid: DEAD_PID, // dead
+            watcherInstanceId: "watcher-A", // matches current watcher
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        writeWatcherHeartbeat("watcher-A", 5);
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        assert.equal(result.reconciled, 0);
+        assert.equal(result.skipped_active_watcher, 1);
+        const report = result.reports[0];
+        assert.equal(report.action_taken, "left_unchanged");
+        assert.ok(report.reasons.some((r) => r.includes("active watcher")));
+        // status.json unchanged
+        const status = readTaskStatus("task-sf-owned-001");
+        assert.equal(status.status, "running");
+        assert.ok(!existsSync(join(tasksDir, "task-sf-owned-001", "status.json.bak")));
+    });
+    // ── 5. safe_fix: writes status.json.bak backup ──
+    it("safe_fix writes status.json.bak with original content before changing", () => {
+        buildTask({
+            taskId: "task-sf-bak-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        const originalStatusRaw = readFileSync(join(tasksDir, "task-sf-bak-001", "status.json"), "utf-8");
+        reconcileTasks({ mode: "safe_fix" }, config);
+        const backupPath = join(tasksDir, "task-sf-bak-001", "status.json.bak");
+        assert.ok(existsSync(backupPath), "status.json.bak should exist after safe_fix");
+        const backupContent = readFileSync(backupPath, "utf-8");
+        assert.equal(backupContent, originalStatusRaw, "backup must match original status.json content");
+    });
+    // ── 6. safe_fix: writes reconcile.log with append semantics ──
+    it("safe_fix writes reconcile.log at .patchwarden root", () => {
+        buildTask({
+            taskId: "task-sf-log-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        assert.ok(result.reconcile_log_path !== null);
+        assert.ok(existsSync(reconcileLogPath), "reconcile.log should exist");
+        const logContent = readFileSync(reconcileLogPath, "utf-8");
+        const logLines = logContent.trim().split("\n");
+        assert.ok(logLines.length >= 1);
+        const logEntry = JSON.parse(logLines[0]);
+        assert.equal(logEntry.task_id, "task-sf-log-001");
+        assert.equal(logEntry.previous_status, "running");
+        assert.equal(logEntry.new_status, "failed_stale");
+        assert.equal(logEntry.diagnosis, "stale_running");
+        assert.equal(logEntry.confidence, "high");
+        assert.equal(logEntry.applied_by, "reconcile_tasks");
+    });
+    // ── 7. safe_fix: appends to existing reconcile.log (does not overwrite) ──
+    it("safe_fix appends to existing reconcile.log without overwriting", () => {
+        // Pre-existing log content
+        mkdirSync(dirname(reconcileLogPath), { recursive: true });
+        writeFileSync(reconcileLogPath, JSON.stringify({
+            timestamp: isoSecondsAgo(3600),
+            task_id: "prior-task",
+            previous_status: "running",
+            new_status: "failed_stale",
+        }) + "\n", "utf-8");
+        buildTask({
+            taskId: "task-sf-append-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        reconcileTasks({ mode: "safe_fix" }, config);
+        const logContent = readFileSync(reconcileLogPath, "utf-8");
+        const logLines = logContent.trim().split("\n");
+        assert.ok(logLines.length >= 2, "log should contain prior + new entries");
+        const firstEntry = JSON.parse(logLines[0]);
+        assert.equal(firstEntry.task_id, "prior-task");
+        const newEntry = logLines
+            .map((l) => JSON.parse(l))
+            .find((e) => e.task_id === "task-sf-append-001");
+        assert.ok(newEntry, "new task entry should be appended");
+        assert.equal(newEntry.new_status, "failed_stale");
+    });
+    // ── 8. safe_fix: done_candidate → done_by_agent with acceptance_status=pending ──
+    it("safe_fix marks done_by_agent and sets acceptance_status=pending + legacy_status=done", () => {
+        buildTask({
+            taskId: "task-sf-donecand-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "done\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+            resultMd: true,
+            testLog: true,
+            gitDiff: true,
+        });
+        // No watcher heartbeat → orphaned_running, but done_candidate takes priority
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        assert.equal(result.reconciled, 1);
+        const report = result.reports[0];
+        assert.equal(report.action_taken, "marked_done_by_agent");
+        assert.equal(report.new_status, "done_by_agent");
+        const status = readTaskStatus("task-sf-donecand-001");
+        assert.equal(status.status, "done_by_agent");
+        assert.equal(status.acceptance_status, "pending");
+        assert.equal(status.legacy_status, "done");
+        assert.equal(status.previous_status, "running");
+    });
+    // ── 9. safe_fix: orphaned_running → orphaned ──
+    it("safe_fix marks orphaned when watcher instance mismatches", () => {
+        buildTask({
+            taskId: "task-sf-orphan-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 30, // fresh
+            childPid: ALIVE_PID,
+            watcherInstanceId: "watcher-old", // mismatch
+            createdSecondsAgo: 2000,
+            stdoutContent: "output\n",
+            stdoutSecondsAgo: 10,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 10,
+        });
+        writeWatcherHeartbeat("watcher-new", 5);
+        const result = reconcileTasks({ mode: "safe_fix" }, config);
+        // High confidence orphaned_running, not owned by current watcher
+        assert.equal(result.reconciled, 1);
+        const report = result.reports[0];
+        assert.equal(report.action_taken, "marked_orphaned");
+        assert.equal(report.new_status, "orphaned");
+        const status = readTaskStatus("task-sf-orphan-001");
+        assert.equal(status.status, "orphaned");
+        assert.equal(status.previous_status, "running");
+    });
+    // ── 10. Age filter: tasks younger than max_age_minutes are skipped ──
+    it("skips tasks younger than max_age_minutes", () => {
+        buildTask({
+            taskId: "task-young-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 10, // fresh — active
+            childPid: ALIVE_PID,
+            watcherInstanceId: "watcher-A",
+            createdSecondsAgo: 60, // only 1 minute old
+            stdoutContent: "running\n",
+            stdoutSecondsAgo: 5,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 5,
+        });
+        writeWatcherHeartbeat("watcher-A", 3);
+        const result = reconcileTasks({ mode: "report_only", max_age_minutes: 30 }, config);
+        assert.equal(result.scanned, 1);
+        assert.equal(result.candidates, 0); // too young
+        assert.equal(result.reports.length, 0);
+    });
+    // ── 11. Non-running tasks are not candidates ──
+    it("does not consider terminal tasks as candidates", () => {
+        buildTask({
+            taskId: "task-done-001",
+            status: "done",
+            phase: "completed",
+            createdSecondsAgo: 1000,
+        });
+        buildTask({
+            taskId: "task-failed-001",
+            status: "failed",
+            phase: "failed",
+            createdSecondsAgo: 1000,
+        });
+        const result = reconcileTasks({ mode: "report_only" }, config);
+        assert.equal(result.scanned, 2);
+        assert.equal(result.candidates, 0);
+    });
+    // ── 12. Empty tasks dir returns zero-scanned result ──
+    it("returns empty result when tasks dir is empty", () => {
+        const result = reconcileTasks({ mode: "report_only" }, config);
+        assert.equal(result.scanned, 0);
+        assert.equal(result.candidates, 0);
+        assert.equal(result.reports.length, 0);
+        assert.equal(result.reconcile_log_path, null);
+    });
+    // ── 13. No temp file left behind after successful atomic write ──
+    it("does not leave status.json.tmp behind after safe_fix", () => {
+        buildTask({
+            taskId: "task-sf-notmp-001",
+            status: "running",
+            phase: "executing_agent",
+            heartbeatSecondsAgo: 600,
+            childPid: DEAD_PID,
+            createdSecondsAgo: 2000,
+            stdoutContent: "old output\n",
+            stdoutSecondsAgo: 600,
+            stderrContent: "stderr\n",
+            stderrSecondsAgo: 600,
+        });
+        reconcileTasks({ mode: "safe_fix" }, config);
+        const tmpPath = join(tasksDir, "task-sf-notmp-001", "status.json.tmp");
+        assert.ok(!existsSync(tmpPath), "status.json.tmp should not exist after rename");
+    });
+});

package/dist/test/unit/release-gate.test.d.ts

@@ -0,0 +1 @@
+export {};