patchwarden 1.5.0 → 1.6.1

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

@@ -1,125 +0,0 @@
-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

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

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

@@ -1,456 +0,0 @@
-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

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