patchwarden 1.5.1 → 1.6.2

package/dist/test/unit/create-task.test.js

@@ -1,197 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { reloadConfig } from "../../config.js";
-import { createTask } from "../../tools/createTask.js";
-import { savePlan } from "../../tools/savePlan.js";
-import { PatchWardenError } from "../../errors.js";
-// ── Helpers ───────────────────────────────────────────────────────
-let tempDir;
-let prevConfigEnv;
-function writeConfig(workspaceRoot) {
-    const configPath = join(tempDir, "patchwarden.config.json");
-    writeFileSync(configPath, JSON.stringify({
-        workspaceRoot,
-        tasksDir: ".patchwarden/tasks",
-        plansDir: ".patchwarden/plans",
-        assessmentsDir: ".patchwarden/assessments",
-        directSessionsDir: ".patchwarden/direct-sessions",
-        agents: {
-            codex: { command: "codex", args: ["exec", "{prompt}"] },
-        },
-        allowedTestCommands: ["npm test", "npm run build"],
-        defaultTaskTimeoutSeconds: 60,
-        maxTaskTimeoutSeconds: 300,
-        watcherStaleSeconds: 30,
-    }), "utf-8");
-    prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
-    process.env.PATCHWARDEN_CONFIG = configPath;
-    reloadConfig();
-}
-/** Write a fresh watcher heartbeat so readWatcherStatus reports healthy. */
-function writeFreshHeartbeat(workspaceRoot) {
-    const heartbeatPath = join(workspaceRoot, ".patchwarden", "watcher-heartbeat.json");
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    writeFileSync(heartbeatPath, JSON.stringify({
-        status: "running",
-        pid: process.pid,
-        last_heartbeat_at: new Date().toISOString(),
-        instance_id: "test-instance",
-    }), "utf-8");
-}
-describe("createTask", () => {
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-createtask-"));
-    });
-    afterEach(() => {
-        if (prevConfigEnv === undefined)
-            delete process.env.PATCHWARDEN_CONFIG;
-        else
-            process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
-        reloadConfig();
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    // ── 1. inline_plan source ──────────────────────────────────────
-    it("creates a task from inline_plan, writes status.json, and allocates a task directory", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        writeFreshHeartbeat(tempDir);
-        const result = await createTask({
-            inline_plan: "## Goal\nAdd a hello-world print statement to main.ts.",
-            agent: "codex",
-            repo_path: "my-repo",
-        });
-        const out = result;
-        assert.ok(out.task_id.startsWith("task_"), `task_id should start with "task_", got: ${out.task_id}`);
-        assert.equal(out.status, "pending");
-        assert.equal(out.plan_source, "inline");
-        assert.equal(out.agent, "codex");
-        assert.equal(out.execution_blocked, false);
-        assert.ok(existsSync(out.path), "task directory should exist");
-        assert.ok(existsSync(join(out.path, "status.json")), "status.json should exist");
-        const status = JSON.parse(readFileSync(join(out.path, "status.json"), "utf-8"));
-        assert.equal(status.task_id, out.task_id);
-        assert.equal(status.status, "pending");
-        assert.equal(status.phase, "queued");
-        assert.equal(status.agent, "codex");
-        assert.equal(status.plan_source, "inline");
-        assert.equal(status.repo_path, "my-repo");
-    });
-    // ── 2. template source ─────────────────────────────────────────
-    it("creates a task from a built-in template (feature_small)", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        writeFreshHeartbeat(tempDir);
-        const result = await createTask({
-            template: "feature_small",
-            goal: "Add a utility function for string truncation.",
-            agent: "codex",
-            repo_path: "my-repo",
-        });
-        const out = result;
-        assert.ok(out.task_id.startsWith("task_"));
-        assert.equal(out.plan_source, "template");
-        assert.equal(out.template, "feature_small");
-        assert.ok(existsSync(join(out.path, "status.json")));
-        const status = JSON.parse(readFileSync(join(out.path, "status.json"), "utf-8"));
-        assert.equal(status.template, "feature_small");
-        assert.equal(status.plan_source, "template");
-    });
-    // ── 3. plan_id source ──────────────────────────────────────────
-    it("creates a task from a previously saved plan_id", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        writeFreshHeartbeat(tempDir);
-        const saved = savePlan({
-            title: "Pre-saved plan",
-            content: "## Goal\nDo something safe and repo-local.",
-        });
-        const result = await createTask({
-            plan_id: saved.plan_id,
-            agent: "codex",
-            repo_path: "my-repo",
-        });
-        const out = result;
-        assert.equal(out.plan_id, saved.plan_id);
-        assert.equal(out.plan_source, "saved");
-        assert.ok(existsSync(join(out.path, "status.json")));
-        const status = JSON.parse(readFileSync(join(out.path, "status.json"), "utf-8"));
-        assert.equal(status.plan_id, saved.plan_id);
-        assert.equal(status.plan_source, "saved");
-    });
-    // ── 4. assess_only mode ────────────────────────────────────────
-    it("returns a risk assessment instead of creating a task in assess_only mode", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        const result = await createTask({
-            inline_plan: "## Goal\nAdd a print statement to main.ts.",
-            agent: "codex",
-            repo_path: "my-repo",
-            execution_mode: "assess_only",
-        });
-        const out = result;
-        assert.ok(out.assessment_id, "assessment_id should be present");
-        assert.ok(out.assessment_short_id, "assessment_short_id should be present");
-        assert.equal(out.decision, "allow");
-        assert.equal(out.risk_level, "low");
-        assert.ok(out.next_tool_call, "next_tool_call should be present for allow decision");
-        assert.equal(out.next_tool_call.name, "create_task");
-        assert.equal(out.next_tool_call.arguments.execution_mode, "execute");
-        assert.equal(out.next_tool_call.arguments.assessment_id, out.assessment_id);
-        // No task directory should be created in assess_only mode
-        assert.equal("task_id" in out, false, "assess_only output should not contain task_id");
-        const tasksDir = join(tempDir, ".patchwarden", "tasks");
-        if (existsSync(tasksDir)) {
-            const taskEntries = readdirSync(tasksDir).filter((name) => name.startsWith("task_"));
-            assert.equal(taskEntries.length, 0, "no task directory should be created in assess_only mode");
-        }
-    });
-    // ── 5. agent not configured ────────────────────────────────────
-    it("throws PatchWardenError (agent_not_configured) when the agent is not registered", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        await assert.rejects(() => createTask({
-            inline_plan: "## Goal\nDo something.",
-            agent: "ghost-agent",
-            repo_path: "my-repo",
-        }), (err) => {
-            assert.ok(err instanceof PatchWardenError, "should throw PatchWardenError");
-            assert.equal(err.reason, "agent_not_configured");
-            return true;
-        });
-    });
-    // ── 6. repo_path escapes workspace ─────────────────────────────
-    it("throws workspace_path_escape when repo_path is outside workspaceRoot", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        await assert.rejects(() => createTask({
-            inline_plan: "## Goal\nDo something.",
-            agent: "codex",
-            repo_path: "../outside-workspace",
-        }), (err) => {
-            assert.ok(err instanceof PatchWardenError, "should throw PatchWardenError");
-            assert.equal(err.reason, "workspace_path_escape");
-            return true;
-        });
-    });
-    // ── 7. watcher not running ─────────────────────────────────────
-    it("returns execution_blocked: true when watcher is not running", async () => {
-        writeConfig(tempDir);
-        mkdirSync(join(tempDir, "my-repo"), { recursive: true });
-        // No watcher heartbeat file → watcher status is "missing"
-        const result = await createTask({
-            inline_plan: "## Goal\nDo something.",
-            agent: "codex",
-            repo_path: "my-repo",
-        });
-        const out = result;
-        assert.equal(out.execution_blocked, true);
-        assert.equal(out.watcher.available, false);
-        assert.equal(out.watcher.status, "missing");
-        assert.equal(out.next_tool_call.name, "health_check");
-        // Task is still created (queued) despite being blocked
-        assert.ok(existsSync(join(out.path, "status.json")));
-    });
-});

package/dist/test/unit/diagnose-task.test.d.ts

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

package/dist/test/unit/diagnose-task.test.js

@@ -1,457 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, utimesSync, existsSync, } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { diagnoseTask } from "../../tools/diagnoseTask.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,
-    };
-}
-/** A PID that is guaranteed to be alive (the test process itself). */
-const ALIVE_PID = process.pid;
-/** A PID that is guaranteed to not exist (well above typical PID max). */
-const DEAD_PID = 999999;
-function isoSecondsAgo(seconds) {
-    return new Date(Date.now() - seconds * 1000).toISOString();
-}
-/** Set a file's mtime to N seconds ago so diagnose_task sees it as stale or fresh. */
-function ageFile(filePath, secondsAgo) {
-    if (!existsSync(filePath))
-        return;
-    const targetMs = Date.now() - secondsAgo * 1000;
-    const targetSec = targetMs / 1000;
-    utimesSync(filePath, targetSec, targetSec);
-}
-describe("diagnoseTask", () => {
-    let tempDir;
-    let config;
-    let tasksDir;
-    let watcherHeartbeatPath;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-diagnose-"));
-        config = makeConfig(tempDir);
-        tasksDir = join(tempDir, ".patchwarden", "tasks");
-        mkdirSync(tasksDir, { recursive: true });
-        watcherHeartbeatPath = join(dirname(tasksDir), "watcher-heartbeat.json");
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    /**
-     * Build a task fixture with status.json, runtime.json, and optional log
-     * files with controlled mtimes.
-     */
-    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.childStartedSecondsAgo !== undefined) {
-            runtime.child_started_at = isoSecondsAgo(opts.childStartedSecondsAgo);
-        }
-        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");
-        }
-        if (opts.artifactManifest) {
-            writeFileSync(join(taskDir, "artifact_manifest.json"), "{}", "utf-8");
-        }
-        return taskDir;
-    }
-    /** Write a watcher heartbeat with the given instance_id and freshness. */
-    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");
-    }
-    // ── 1. active_running: fresh heartbeat, watcher owns, logs growing ──
-    it("diagnoses active_running when heartbeat fresh, watcher owns, logs growing", () => {
-        buildTask({
-            taskId: "task-active-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 10, // fresh (< 120s)
-            childPid: ALIVE_PID, // alive
-            watcherInstanceId: "watcher-A", // matches watcher
-            taskStartedSecondsAgo: 60,
-            stdoutContent: "Running...\n",
-            stdoutSecondsAgo: 5, // logs growing (< 120s)
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 5,
-        });
-        writeWatcherHeartbeat("watcher-A", 3);
-        const result = diagnoseTask({ task_id: "task-active-001" }, config);
-        assert.equal(result.diagnosis, "active_running");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("leave_unchanged"));
-        assert.equal(result.evidence.watcher_owns_task, true);
-        assert.equal(result.evidence.child_pid_alive, true);
-        assert.equal(result.evidence.pid_reuse_suspected, false);
-    });
-    // ── 2. stale_running: heartbeat stale, PID dead, no watcher ownership, logs stale ──
-    //
-    // This task was started directly (e.g., via run_task MCP tool) and has no
-    // watcher_instance_id in runtime, so isWatcherOwningTask returns
-    // "no_runtime_record" — which does NOT trigger orphaned_running. With
-    // heartbeat/PID/logs all stale, it falls through to stale_running.
-    it("diagnoses stale_running when heartbeat stale, PID dead, no watcher record, logs stale", () => {
-        buildTask({
-            taskId: "task-stale-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 600, // stale (> 300s)
-            childPid: DEAD_PID, // dead
-            // No watcherInstanceId — simulates task started directly via run_task
-            taskStartedSecondsAgo: 700,
-            stdoutContent: "old output\n",
-            stdoutSecondsAgo: 600, // stale (> 300s)
-            stderrContent: "old stderr\n",
-            stderrSecondsAgo: 600,
-        });
-        const result = diagnoseTask({ task_id: "task-stale-001" }, config);
-        assert.equal(result.diagnosis, "stale_running");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("mark_failed_stale"));
-        assert.equal(result.evidence.child_pid_alive, false);
-        assert.equal(result.evidence.watcher_owns_task, false);
-        assert.equal(result.evidence.watcher_ownership_reason, "no_runtime_record");
-    });
-    // ── 3. possibly_stale_running: heartbeat possibly stale + logs stale, PID alive ──
-    //
-    // heartbeat is between 120-300s (possibly stale), logs are > 300s (stale),
-    // and PID is alive but pidReuseSuspected is false because heartbeat is not
-    // stale enough (> 300s required). This falls into possibly_stale_running.
-    it("diagnoses possibly_stale_running when heartbeat possibly stale and logs stale", () => {
-        buildTask({
-            taskId: "task-posstale-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 200, // possibly stale (> 120, <= 300)
-            childPid: ALIVE_PID, // alive
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 300,
-            stdoutContent: "output\n",
-            stdoutSecondsAgo: 400, // stale (> 300s)
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 400,
-        });
-        writeWatcherHeartbeat("watcher-A", 5);
-        const result = diagnoseTask({ task_id: "task-posstale-001" }, config);
-        // heartbeatPossiblyStale=true && logsStale=true → possibly_stale_running
-        assert.equal(result.diagnosis, "possibly_stale_running");
-        assert.equal(result.confidence, "medium");
-        assert.ok(result.safe_actions.includes("leave_unchanged"));
-        assert.equal(result.evidence.pid_reuse_suspected, false);
-    });
-    // ── 4. orphaned_running: watcher does not own task (instance mismatch) ──
-    it("diagnoses orphaned_running when watcher instance_id mismatches", () => {
-        buildTask({
-            taskId: "task-orphan-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 30, // fresh
-            childPid: ALIVE_PID,
-            watcherInstanceId: "watcher-old", // does NOT match current watcher
-            taskStartedSecondsAgo: 60,
-            stdoutContent: "output\n",
-            stdoutSecondsAgo: 10,
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 10,
-        });
-        writeWatcherHeartbeat("watcher-new", 5);
-        const result = diagnoseTask({ task_id: "task-orphan-001" }, config);
-        assert.equal(result.diagnosis, "orphaned_running");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("mark_orphaned"));
-        assert.equal(result.evidence.watcher_owns_task, false);
-        assert.equal(result.evidence.watcher_ownership_reason, "instance_mismatch");
-    });
-    // ── 5. artifact_collection_stuck: in collecting_artifacts and stuck ──
-    it("diagnoses artifact_collection_stuck when in collecting phase and signals stale", () => {
-        buildTask({
-            taskId: "task-stuckart-001",
-            status: "collecting_artifacts",
-            phase: "collecting_artifacts",
-            heartbeatSecondsAgo: 400, // stale
-            childPid: DEAD_PID, // dead
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 500,
-            stdoutContent: "agent done\n",
-            stdoutSecondsAgo: 400,
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 400,
-        });
-        writeWatcherHeartbeat("watcher-A", 5);
-        const result = diagnoseTask({ task_id: "task-stuckart-001" }, config);
-        assert.equal(result.diagnosis, "artifact_collection_stuck");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("recollect_artifacts"));
-        assert.ok(result.safe_actions.includes("mark_failed_stale"));
-        assert.equal(result.evidence.collecting_artifacts_phase, true);
-    });
-    // ── 6. done_candidate: artifacts exist while status still running ──
-    it("diagnoses done_candidate with high confidence when result.md + test.log exist", () => {
-        buildTask({
-            taskId: "task-donecand-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 400,
-            childPid: DEAD_PID,
-            watcherInstanceId: "watcher-old",
-            taskStartedSecondsAgo: 500,
-            stdoutContent: "done\n",
-            stdoutSecondsAgo: 400,
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 400,
-            resultMd: true,
-            testLog: true,
-            gitDiff: true,
-        });
-        // No watcher heartbeat — orphaned
-        const result = diagnoseTask({ task_id: "task-donecand-001" }, config);
-        // done_candidate takes priority over orphaned_running because artifacts exist
-        assert.equal(result.diagnosis, "done_candidate");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("mark_done_by_agent"));
-        assert.equal(result.evidence.has_result_md, true);
-        assert.equal(result.evidence.has_test_log, true);
-    });
-    it("diagnoses done_candidate with medium confidence when only result.md + collecting phase", () => {
-        buildTask({
-            taskId: "task-donecand-002",
-            status: "collecting_artifacts",
-            phase: "collecting_artifacts",
-            heartbeatSecondsAgo: 30, // fresh — not stuck
-            childPid: ALIVE_PID,
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 100,
-            stdoutContent: "done\n",
-            stdoutSecondsAgo: 30,
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 30,
-            resultMd: true,
-            // No test.log/git.diff → medium signal
-        });
-        writeWatcherHeartbeat("watcher-A", 5);
-        const result = diagnoseTask({ task_id: "task-donecand-002" }, config);
-        assert.equal(result.diagnosis, "done_candidate");
-        assert.equal(result.confidence, "medium");
-        assert.ok(result.safe_actions.includes("mark_done_by_agent"));
-        assert.ok(result.safe_actions.includes("collect_artifacts"));
-    });
-    // ── 7. unknown: insufficient evidence ──
-    //
-    // heartbeat is fresh but PID is dead and logs are stale — no single
-    // branch matches with enough confidence, so it falls through to unknown.
-    it("diagnoses unknown when signals conflict (fresh heartbeat but dead PID + stale logs)", () => {
-        buildTask({
-            taskId: "task-unknown-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 10, // fresh — doesn't hit stale paths
-            childPid: DEAD_PID, // dead — but heartbeat says fresh
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 60,
-            stdoutContent: "running\n",
-            stdoutSecondsAgo: 400, // stale — but heartbeat says fresh
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 400,
-        });
-        writeWatcherHeartbeat("watcher-A", 5);
-        const result = diagnoseTask({ task_id: "task-unknown-001" }, config);
-        // Fresh heartbeat means not stale_running / possibly_stale_running.
-        // Dead PID + stale logs means not active_running.
-        // Conflicting signals → unknown.
-        assert.equal(result.diagnosis, "unknown");
-        assert.equal(result.confidence, "low");
-        assert.ok(result.safe_actions.includes("leave_unchanged"));
-    });
-    // ── 8. PID reuse case: PID alive but everything else stale ──
-    //
-    // This is the conservative safety check: even though process.kill(pid, 0)
-    // returns true, we refuse to call the task "active" because heartbeat and
-    // logs are all stale. The PID may have been reused by the OS for an
-    // unrelated process.
-    it("refuses active_running on PID reuse: PID alive but heartbeat + logs stale", () => {
-        buildTask({
-            taskId: "task-pidreuse-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 600, // very stale
-            childPid: ALIVE_PID, // alive — but probably reused!
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 700,
-            stdoutContent: "old output\n",
-            stdoutSecondsAgo: 600, // very stale
-            stderrContent: "old stderr\n",
-            stderrSecondsAgo: 600,
-        });
-        writeWatcherHeartbeat("watcher-A", 5);
-        const result = diagnoseTask({ task_id: "task-pidreuse-001" }, config);
-        // Must NOT be active_running — that would be the unsafe conclusion.
-        assert.notEqual(result.diagnosis, "active_running");
-        assert.equal(result.diagnosis, "possibly_stale_running");
-        assert.equal(result.confidence, "medium");
-        assert.equal(result.evidence.pid_reuse_suspected, true);
-        assert.equal(result.evidence.child_pid_alive, true);
-        assert.ok(result.reasons.some((r) => r.includes("PID reuse")));
-    });
-    // ── 9. terminal: already-terminal statuses return terminal diagnosis ──
-    it("returns terminal diagnosis for done status", () => {
-        buildTask({
-            taskId: "pw-terminal-done",
-            status: "done",
-            phase: "completed",
-            createdSecondsAgo: 1000,
-        });
-        const result = diagnoseTask({ task_id: "pw-terminal-done" }, config);
-        assert.equal(result.diagnosis, "terminal");
-        assert.equal(result.confidence, "high");
-        assert.ok(result.safe_actions.includes("leave_unchanged"));
-    });
-    it("returns terminal diagnosis for failed_stale status (v0.7.0 status)", () => {
-        buildTask({
-            taskId: "pw-terminal-failed-stale",
-            status: "failed_stale",
-            phase: "failed_stale",
-            createdSecondsAgo: 1000,
-        });
-        const result = diagnoseTask({ task_id: "pw-terminal-failed-stale" }, config);
-        assert.equal(result.diagnosis, "terminal");
-    });
-    it("returns terminal diagnosis for orphaned status (v0.7.0 status)", () => {
-        buildTask({
-            taskId: "pw-terminal-orphaned",
-            status: "orphaned",
-            phase: "orphaned",
-            createdSecondsAgo: 1000,
-        });
-        const result = diagnoseTask({ task_id: "pw-terminal-orphaned" }, config);
-        assert.equal(result.diagnosis, "terminal");
-    });
-    it("returns terminal diagnosis for done_by_agent status (v0.7.0 status)", () => {
-        buildTask({
-            taskId: "pw-terminal-done-by-agent",
-            status: "done_by_agent",
-            phase: "done_by_agent",
-            createdSecondsAgo: 1000,
-        });
-        const result = diagnoseTask({ task_id: "pw-terminal-done-by-agent" }, config);
-        assert.equal(result.diagnosis, "terminal");
-    });
-    // ── include_logs flag ──
-    it("includes redacted log tails when include_logs=true", () => {
-        buildTask({
-            taskId: "task-logs-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 10,
-            childPid: ALIVE_PID,
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 60,
-            stdoutContent: "line1\nline2 with Bearer abcdefghijklmnop123456\n",
-            stdoutSecondsAgo: 5,
-            stderrContent: "stderr line\n",
-            stderrSecondsAgo: 5,
-        });
-        writeWatcherHeartbeat("watcher-A", 3);
-        const result = diagnoseTask({ task_id: "task-logs-001", include_logs: true }, config);
-        assert.ok(result.logs !== null);
-        assert.ok(result.logs.stdout_tail !== null);
-        assert.ok(result.logs.stderr_tail !== null);
-        // The bearer token must be redacted
-        assert.ok(!result.logs.stdout_tail.includes("abcdefghijklmnop123456"));
-        assert.ok(result.logs.stdout_tail.includes("[REDACTED]"));
-    });
-    it("omits log tails when include_logs is false (default)", () => {
-        buildTask({
-            taskId: "task-nologs-001",
-            status: "running",
-            phase: "executing_agent",
-            heartbeatSecondsAgo: 10,
-            childPid: ALIVE_PID,
-            watcherInstanceId: "watcher-A",
-            taskStartedSecondsAgo: 60,
-            stdoutContent: "line1\n",
-            stdoutSecondsAgo: 5,
-            stderrContent: "stderr\n",
-            stderrSecondsAgo: 5,
-        });
-        writeWatcherHeartbeat("watcher-A", 3);
-        const result = diagnoseTask({ task_id: "task-nologs-001" }, config);
-        assert.equal(result.logs, null);
-    });
-    // ── Error case: task not found ──
-    it("throws when task does not exist", () => {
-        // guardReadPath throws "File not found" before the existsSync check
-        // produces "Task not found" — both indicate the task doesn't exist.
-        assert.throws(() => diagnoseTask({ task_id: "non-existent-task" }, config), /(Task not found|File not found)/);
-    });
-});

package/dist/test/unit/direct-guards.test.d.ts

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