agent-dealer 0.3.0 → 1.0.1

package/bundle/server/dist/coordinator/worker-loop.test.js

@@ -0,0 +1,329 @@
+// packages/server/src/coordinator/worker-loop.test.ts
+//
+// End-to-end kernel behaviour with fake effect handlers — the ticket's acceptance
+// scenarios: crash before effect, crash after effect / duplicate completion, lease expiry,
+// restart recovery, and duplicate dispatch.
+import { test, before, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-loop-"));
+process.env.MAX_COORDINATOR_CONCURRENCY = "4";
+process.env.COORDINATOR_HEARTBEAT_MS = "20";
+process.env.COORDINATOR_FAIL_BACKOFF_MS = "0";
+const { migrate, getDb } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue, getIssue } = await import("../repository/issues.js");
+const { getActiveWorkflowInstance, listWorkflowEventsForIssue } = await import("../repository/workflow-events.js");
+const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
+const { listWorkerSessionsForIssue, createWorkerSession, startSession } = await import("../repository/worker-sessions.js");
+const { listWorkItemsForIssue, claimWorkItem, getWorkItem, bindWorkItemSession } = await import("../repository/work-items.js");
+const { startWorkflow, applyCompletion, resolveHumanActionAndAdvanceAsync } = await import("./commands.js");
+const { registerEffectHandler, resetEffectHandlers } = await import("./effect-registry.js");
+const { runCoordinatorTick, drainCoordinator, activeAttemptCount, startCoordinatorLoop, stopCoordinatorLoop } = await import("./worker-loop.js");
+const { recoverCoordinator } = await import("./recovery.js");
+const { ReviewerResult } = await import("./reviewer-result.js");
+const { setMergePrForTests, clearFinalizeInflightForTests } = await import("./auto-merge.js");
+const { stubManagedCloneForTests } = await import("../adapters/managed-repo.js");
+before(() => migrate());
+// claimWorkItem / recovery scan the whole table (one loop in production); start each
+// case from an empty queue so a prior test's un-processed item is never claimed here.
+beforeEach(() => {
+    getDb().exec("DELETE FROM work_items");
+    clearFinalizeInflightForTests();
+    setMergePrForTests(async () => ({ ok: true }));
+    stubManagedCloneForTests("acme/app");
+});
+afterEach(() => resetEffectHandlers());
+function newIssue(maxReviewRounds = 3) {
+    return createIssue({
+        title: "Loop me",
+        acceptanceCriteria: "It works",
+        repo: "acme/app",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds,
+        maxInfraAttempts: 3,
+        source: "manual"
+    }).id;
+}
+const cleanHandoff = (headSha = "head1") => ({
+    kind: "clean_handoff",
+    branch: "issue-1",
+    headSha,
+    baseSha: "base1",
+    prNumber: 7,
+    prUrl: "https://gh/pr/7"
+});
+const approvedVerdict = {
+    kind: "verdict",
+    result: ReviewerResult.parse({
+        verdict: "approved",
+        baseSha: "base1",
+        headSha: "head1",
+        acceptanceCriteriaAssessment: "ok",
+        evidenceAssessment: "ok",
+        findings: [],
+        risks: []
+    })
+};
+/** Runs ticks until nothing is claimable and all in-flight work has drained. */
+async function pump(max = 20) {
+    for (let i = 0; i < max; i++) {
+        const started = await runCoordinatorTick({ leaseOwner: "pump" });
+        await drainCoordinator();
+        if (started === 0)
+            return;
+    }
+}
+test("happy path: developer → reviewer(approved) → final_review, resolved complete → done", async () => {
+    const issueId = newIssue();
+    registerEffectHandler("developer", async () => cleanHandoff());
+    registerEffectHandler("reviewer", async () => approvedVerdict);
+    startWorkflow(issueId);
+    await pump();
+    assert.equal(getIssue(issueId).status, "final_review");
+    const action = listHumanActionsForIssue(issueId).find((a) => a.actionType === "final_review");
+    await resolveHumanActionAndAdvanceAsync(action.id, "yusuke", "complete");
+    assert.equal(getIssue(issueId).status, "done");
+    assert.equal(getActiveWorkflowInstance(issueId), null);
+    const roles = listWorkerSessionsForIssue(issueId).map((s) => s.role);
+    assert.deepEqual(roles, ["developer", "reviewer"]);
+    assert.ok(listWorkerSessionsForIssue(issueId).every((s) => s.status === "done"));
+});
+test("changes_requested drives an automatic repair round with no human involvement", async () => {
+    const issueId = newIssue(3);
+    let devCalls = 0;
+    registerEffectHandler("developer", async () => {
+        devCalls++;
+        return cleanHandoff(`head${devCalls}`);
+    });
+    registerEffectHandler("reviewer", async () => devCalls === 1
+        ? {
+            kind: "verdict",
+            result: ReviewerResult.parse({
+                verdict: "changes_requested",
+                baseSha: "b",
+                headSha: "head1",
+                acceptanceCriteriaAssessment: "partial",
+                evidenceAssessment: "ok",
+                findings: [{ fingerprint: "f1", severity: "blocking", title: "T", rationale: "R" }],
+                risks: []
+            })
+        }
+        : approvedVerdict);
+    startWorkflow(issueId);
+    await pump();
+    assert.equal(devCalls, 2);
+    assert.equal(getIssue(issueId).status, "final_review");
+    assert.equal(getIssue(issueId).currentRound, 2);
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.actionType !== "final_review").length, 0);
+});
+test("crash before effect: a leased item with no completion is recovered and advances once", async () => {
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    const devItem = listWorkItemsForIssue(issueId)[0];
+    // Simulate the crash: claim the item and never complete it, bypassing the loop.
+    claimWorkItem("dead-worker", { leaseMs: 60_000 });
+    assert.equal(getWorkItem(devItem.id).status, "leased");
+    // Recovery requeues the orphaned lease once it has expired…
+    await recoverCoordinator({ now: Date.now() + 120_000 });
+    assert.equal(getWorkItem(devItem.id).status, "pending");
+    // …now a working handler picks it up and the issue advances exactly once.
+    registerEffectHandler("developer", async () => cleanHandoff());
+    registerEffectHandler("reviewer", async () => approvedVerdict);
+    await pump();
+    assert.equal(getIssue(issueId).status, "final_review");
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "developer").length, 1, "the recovered item was reused, not duplicated");
+});
+test("NOT-116: startup too early to reclaim → later poll tick reclaims without a second restart", async () => {
+    // Mid-run restart: leases still valid at boot, so recoverCoordinator() at startup is a
+    // no-op. Heartbeats are gone; once the lease expires the *next poll tick* must reclaim
+    // — not wait for another process restart.
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    const devItem = listWorkItemsForIssue(issueId)[0];
+    const claimed = claimWorkItem("loop-old-pid", { leaseMs: 60_000 });
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: null
+    });
+    startSession(session.id);
+    assert.equal(bindWorkItemSession(devItem.id, session.id, claimed.leaseToken), true);
+    assert.equal(getWorkItem(devItem.id).status, "leased");
+    assert.equal(listWorkerSessionsForIssue(issueId)[0].status, "running");
+    // Restart recovery while the lease is still valid — no reclaim (the observed bug window).
+    await runCoordinatorTick({ leaseOwner: "loop-restart", now: Date.now() });
+    assert.equal(getWorkItem(devItem.id).status, "leased");
+    assert.equal(listWorkerSessionsForIssue(issueId)[0].status, "running");
+    // Later tick after lease expiry — reclaim via the poll path (manipulate clock; do not
+    // hang a fake handler to simulate the dead worker).
+    registerEffectHandler("developer", async () => cleanHandoff());
+    registerEffectHandler("reviewer", async () => approvedVerdict);
+    await runCoordinatorTick({ leaseOwner: "loop-later", now: Date.now() + 120_000 });
+    await drainCoordinator();
+    const orphan = listWorkerSessionsForIssue(issueId).find((s) => s.id === session.id);
+    assert.equal(orphan.status, "failed");
+    assert.match(orphan.errorJson ?? "", /presumed dead/);
+    // Reclaim requeued then this same tick claimed + completed the developer work item.
+    assert.equal(getWorkItem(devItem.id).status, "done");
+    assert.ok(listWorkerSessionsForIssue(issueId).some((s) => s.id !== session.id && s.role === "developer"), "a fresh developer session ran after reclaim");
+});
+test("crash after effect: a duplicate applyCompletion (same or stale token) is a no-op", async () => {
+    const issueId = newIssue();
+    const handoff = cleanHandoff();
+    startWorkflow(issueId);
+    const claimed = claimWorkItem("w1", { leaseMs: 60_000 });
+    const first = await applyCompletion(claimed.id, claimed.leaseToken, handoff);
+    assert.equal(first.applied, true);
+    // The worker "crashed" after committing but before recording success — it retries.
+    const second = await applyCompletion(claimed.id, claimed.leaseToken, handoff);
+    assert.equal(second.applied, false);
+    // Recovery also races an apply against the same (now stale) observed token.
+    const stale = await applyCompletion(claimed.id, claimed.leaseToken, { kind: "session_failed" });
+    assert.equal(stale.applied, false);
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.kind === "reviewer").length, 1);
+    assert.equal(listWorkflowEventsForIssue(issueId).filter((e) => e.type === "pull_request.opened").length, 1);
+});
+test("fail-after-done: a completeSession failure never revives a work item that already advanced", async () => {
+    // Regression for the reviewer's "failure path can undo a successful apply".
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    const claimed = claimWorkItem("w1", { leaseMs: 60_000 });
+    await applyCompletion(claimed.id, claimed.leaseToken, cleanHandoff());
+    assert.equal(getWorkItem(claimed.id).status, "done");
+    // A late token-fenced failure attempt (what the old catch path would have done) is a no-op.
+    const { requeueWorkItem, finishWorkItem } = await import("../repository/work-items.js");
+    assert.equal(requeueWorkItem(claimed.id, claimed.leaseToken, { e: 1 }, { backoffMs: 0 }), false);
+    assert.equal(finishWorkItem(claimed.id, claimed.leaseToken, { status: "dead" }), null);
+    assert.equal(getWorkItem(claimed.id).status, "done");
+});
+test("lease expiry: a hung worker's late completion is dropped; the requeued item wins", async () => {
+    const issueId = newIssue();
+    registerEffectHandler("developer", async () => cleanHandoff());
+    registerEffectHandler("reviewer", async () => approvedVerdict);
+    startWorkflow(issueId);
+    const devItemId = listWorkItemsForIssue(issueId)[0].id;
+    // A hung worker: it holds the lease but its heartbeat stopped (process frozen).
+    const hung = claimWorkItem("hung", { leaseMs: 20 });
+    await new Promise((r) => setTimeout(r, 40));
+    // The periodic reclaim requeues the now-expired lease.
+    const res = await recoverCoordinator({ now: Date.now() });
+    assert.deepEqual(res.reclaimed, [devItemId]);
+    assert.equal(getWorkItem(devItemId).status, "pending");
+    // The hung worker finally wakes and reports success — but its token is dead: no-op.
+    const late = await applyCompletion(devItemId, hung.leaseToken, cleanHandoff());
+    assert.equal(late.applied, false);
+    // A fresh worker reprocesses the requeued item and drives the workflow forward.
+    await pump();
+    assert.equal(getIssue(issueId).status, "final_review");
+});
+test("duplicate dispatch: two racing ticks run one worker session, one advance", async () => {
+    const issueId = newIssue();
+    registerEffectHandler("developer", async () => {
+        await new Promise((r) => setTimeout(r, 15));
+        return cleanHandoff();
+    });
+    registerEffectHandler("reviewer", async () => approvedVerdict);
+    startWorkflow(issueId);
+    await Promise.all([
+        runCoordinatorTick({ leaseOwner: "A" }),
+        runCoordinatorTick({ leaseOwner: "B" }),
+    ]);
+    await drainCoordinator();
+    assert.equal(listWorkerSessionsForIssue(issueId).filter((s) => s.role === "developer").length, 1);
+    await pump();
+    assert.equal(getIssue(issueId).status, "final_review");
+});
+test("a recovery-requeued re-attempt is tracked separately from its zombie predecessor", async () => {
+    // Regression for "active.set(item.id) replaces the old promise" — key by lease token.
+    const prevHb = process.env.COORDINATOR_HEARTBEAT_MS;
+    const prevLease = process.env.COORDINATOR_LEASE_MS;
+    process.env.COORDINATOR_HEARTBEAT_MS = "100000"; // effectively never during the test
+    process.env.COORDINATOR_LEASE_MS = "10";
+    try {
+        const issueId = newIssue();
+        let calls = 0;
+        let releaseA = () => { };
+        const gateA = new Promise((r) => {
+            releaseA = r;
+        });
+        registerEffectHandler("developer", async () => {
+            calls++;
+            if (calls === 1)
+                await gateA;
+            return cleanHandoff(`h${calls}`);
+        });
+        registerEffectHandler("reviewer", async () => approvedVerdict);
+        startWorkflow(issueId);
+        await runCoordinatorTick({ leaseOwner: "A" }); // attempt A starts, hangs on gateA
+        assert.equal(activeAttemptCount(), 1);
+        await new Promise((r) => setTimeout(r, 25)); // the 10ms lease expires; no heartbeat fires
+        await recoverCoordinator({ now: Date.now() }); // requeues the item + fails A's session
+        const predecessorSessionId = listWorkerSessionsForIssue(issueId)[0].id;
+        assert.equal(listWorkerSessionsForIssue(issueId)[0].status, "failed");
+        await runCoordinatorTick({ leaseOwner: "B" }); // attempt B claims the requeued item
+        assert.equal(activeAttemptCount(), 2, "zombie A + re-attempt B tracked separately");
+        releaseA();
+        await drainCoordinator();
+        assert.equal(activeAttemptCount(), 0);
+        // A's late completion must NOT overwrite recovery's terminal evidence on its session.
+        const predecessor = listWorkerSessionsForIssue(issueId).find((s) => s.id === predecessorSessionId);
+        assert.equal(predecessor.status, "failed");
+        assert.match(predecessor.errorJson ?? "", /presumed dead/);
+        await pump(); // run the reviewer B enqueued
+        assert.equal(getIssue(issueId).status, "final_review");
+    }
+    finally {
+        restoreEnv("COORDINATOR_HEARTBEAT_MS", prevHb);
+        restoreEnv("COORDINATOR_LEASE_MS", prevLease);
+    }
+});
+function restoreEnv(key, prev) {
+    if (prev === undefined)
+        delete process.env[key];
+    else
+        process.env[key] = prev;
+}
+test("startCoordinatorLoop actually polls and drives an issue forward without any manual tick (NOT-65 wiring)", async () => {
+    const prevPoll = process.env.COORDINATOR_POLL_INTERVAL_MS;
+    process.env.COORDINATOR_POLL_INTERVAL_MS = "10";
+    try {
+        const issueId = newIssue();
+        registerEffectHandler("developer", async () => cleanHandoff());
+        registerEffectHandler("reviewer", async () => approvedVerdict);
+        startWorkflow(issueId);
+        startCoordinatorLoop();
+        try {
+            // Poll the DB (not runCoordinatorTick) — this is the same interval-driven loop
+            // index.ts wires into the real server, not a test harness calling the tick fn.
+            const deadline = Date.now() + 5000;
+            while (getIssue(issueId).status !== "final_review" && Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 20));
+            }
+        }
+        finally {
+            stopCoordinatorLoop();
+            await drainCoordinator();
+        }
+        assert.equal(getIssue(issueId).status, "final_review");
+    }
+    finally {
+        restoreEnv("COORDINATOR_POLL_INTERVAL_MS", prevPoll);
+    }
+});
+test("placeholder handlers escalate rather than fabricating a PR", async () => {
+    const issueId = newIssue();
+    // no handlers registered → defaults return session_failed, an infra-class outcome
+    startWorkflow(issueId);
+    await pump();
+    // maxInfraAttempts 3 → session_failed retries until exhausted, then policy_escalation
+    // (never attempts_exhausted — that stays pure to a reviewer's changes_requested).
+    assert.equal(getIssue(issueId).status, "needs_human");
+    assert.equal(listHumanActionsForIssue(issueId).find((a) => a.status === "open").actionType, "policy_escalation");
+});

package/bundle/server/dist/coordinator/workflow-instances.test.js

@@ -0,0 +1,45 @@
+// packages/server/src/coordinator/workflow-instances.test.ts
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-wfinst-"));
+const { migrate } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue } = await import("../repository/issues.js");
+const { startWorkflowInstance, completeWorkflowInstance, getActiveWorkflowInstance, getWorkflowInstance, listWorkflowInstancesForIssue, WorkflowAlreadyActiveError } = await import("../repository/workflow-events.js");
+before(() => migrate());
+function newIssue() {
+    return createIssue({
+        title: "WF host",
+        repo: "acme/app",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "manual"
+    }).id;
+}
+test("startWorkflowInstance creates one active instance", () => {
+    const issueId = newIssue();
+    const inst = startWorkflowInstance(issueId, "dev_reviewer_v1");
+    assert.equal(inst.completedAt, null);
+    assert.equal(getActiveWorkflowInstance(issueId).id, inst.id);
+    assert.deepEqual(getWorkflowInstance(inst.id), inst);
+});
+test("a second start throws WorkflowAlreadyActiveError", () => {
+    const issueId = newIssue();
+    startWorkflowInstance(issueId, "dev_reviewer_v1");
+    assert.throws(() => startWorkflowInstance(issueId, "dev_reviewer_v1"), (err) => err instanceof WorkflowAlreadyActiveError);
+});
+test("completing an instance frees the issue for a new one", () => {
+    const issueId = newIssue();
+    const first = startWorkflowInstance(issueId, "dev_reviewer_v1");
+    completeWorkflowInstance(first.id, "done");
+    assert.equal(getActiveWorkflowInstance(issueId), null);
+    const second = startWorkflowInstance(issueId, "dev_reviewer_v1");
+    assert.equal(listWorkflowInstancesForIssue(issueId).length, 2);
+    assert.equal(getActiveWorkflowInstance(issueId).id, second.id);
+});

package/bundle/server/dist/coordinator/worktree-owner-liveness.js

@@ -0,0 +1,82 @@
+// packages/server/src/coordinator/worktree-owner-liveness.ts
+//
+// NOT-127: before resolveDeveloperWorktree reuses or conflicts on a leftover, ask whether
+// the session that owns that path still has a live CLI. Filesystem clean/dirty alone is
+// wrong in both directions when the predecessor was wrongly presumed dead (NOT-124): a
+// clean leftover gets adopted while an agent is mid-run; a dirty leftover escalates as a
+// worktree conflict when the "conflict" is just the live owner's WIP.
+import fs from "node:fs";
+import { getDb } from "../db/index.js";
+import { sessionIdFromRoleWorktreePath, } from "../adapters/git-worktree.js";
+import { getWorkerSession } from "../repository/worker-sessions.js";
+import { processLiveness } from "./process-liveness.js";
+function tryRealpath(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/**
+ * Every worker_session that may own this coordinator-managed worktree path.
+ *
+ * Basename id (`<id>-developer`) is not enough on its own: after a dead-and-clean *reuse*,
+ * the directory keeps the predecessor's name while the successor's `worktree_path` also
+ * points there. Preferring only the basename then hides the live successor and lets the
+ * next retry adopt (or mis-escalate) the tree — the exact NOT-127 failure, one hop later.
+ */
+export function listWorkerSessionsOwningWorktree(worktreePath) {
+    const seen = new Set();
+    const out = [];
+    const push = (s) => {
+        if (!s || seen.has(s.id))
+            return;
+        seen.add(s.id);
+        out.push(s);
+    };
+    const fromPath = sessionIdFromRoleWorktreePath(worktreePath);
+    if (fromPath)
+        push(getWorkerSession(fromPath));
+    const real = tryRealpath(worktreePath);
+    const rows = getDb()
+        .prepare(`SELECT id FROM worker_sessions
+       WHERE worktree_path = ? OR worktree_path = ?
+       ORDER BY created_at DESC`)
+        .all(worktreePath, real);
+    for (const row of rows)
+        push(getWorkerSession(row.id));
+    return out;
+}
+/** First candidate from {@link listWorkerSessionsOwningWorktree} — tests that only need one row. */
+export function findWorkerSessionOwningWorktree(worktreePath) {
+    const all = listWorkerSessionsOwningWorktree(worktreePath);
+    return all[0] ?? null;
+}
+function sessionLooksLive(session) {
+    const verdict = processLiveness(session.processPid, session.processOwner, session.processStartedAt ?? null);
+    if (session.status === "running") {
+        // Dead pid → the process is gone even if the row hasn't been completed yet.
+        if (verdict === "dead")
+            return false;
+        // alive or unknown (including running with no pid yet, pre-spawn) → still owns the tree.
+        return true;
+    }
+    // Terminal session whose recorded pid still answers alive (wrongly presumed dead).
+    return verdict === "alive";
+}
+/**
+ * Live owner → block adoption. Dead / unknown / no session → filesystem clean/dirty path.
+ *
+ * Returns alive if **any** candidate session for this path is live — basename predecessor
+ * and every `worktree_path` match (see {@link listWorkerSessionsOwningWorktree}).
+ */
+export function checkDeveloperWorktreeOwnerLiveness(worktreePath) {
+    const candidates = listWorkerSessionsOwningWorktree(worktreePath);
+    for (const session of candidates) {
+        if (sessionLooksLive(session)) {
+            return { state: "alive", sessionId: session.id };
+        }
+    }
+    return { state: "dead" };
+}

package/bundle/server/dist/coordinator/worktree-owner-liveness.test.js

@@ -0,0 +1,199 @@
+// packages/server/src/coordinator/worktree-owner-liveness.test.ts
+//
+// NOT-127: session + pid lookup that feeds resolveDeveloperWorktree's ownerLiveness hook.
+import { test, before, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-wt-owner-"));
+const { migrate, getDb } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue } = await import("../repository/issues.js");
+const { createWorkerSession, startSession, completeSession, recordSessionProcess, patchRunningSession } = await import("../repository/worker-sessions.js");
+const { COORDINATOR_PROCESS_OWNER, readProcessStartTime } = await import("./process-liveness.js");
+const { checkDeveloperWorktreeOwnerLiveness, findWorkerSessionOwningWorktree } = await import("./worktree-owner-liveness.js");
+let issueId;
+before(() => {
+    migrate();
+    issueId = createIssue({
+        title: "owner-liveness host",
+        repo: "acme/app",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        baseBranch: "main",
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "manual"
+    }).id;
+});
+beforeEach(() => {
+    getDb().exec("DELETE FROM worker_sessions");
+});
+function spawnLiveChild() {
+    const child = spawn("sleep", ["30"], { stdio: "ignore" });
+    const startTime = readProcessStartTime(child.pid) ?? "unknown";
+    return {
+        pid: child.pid,
+        startTime,
+        kill: () => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    };
+}
+test("findWorkerSessionOwningWorktree resolves the session id encoded in the path basename", () => {
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code"
+    });
+    startSession(session.id);
+    const wt = `/repo/.agent-dealer-worktrees/${session.id}-developer`;
+    patchRunningSession(session.id, { worktreePath: wt });
+    assert.equal(findWorkerSessionOwningWorktree(wt)?.id, session.id);
+});
+test("checkDeveloperWorktreeOwnerLiveness: running session with live pid is alive", () => {
+    const child = spawnLiveChild();
+    try {
+        const session = createWorkerSession({
+            issueId,
+            role: "developer",
+            round: 1,
+            agentId: BUILTIN_AGENT_CLAUDE_ID,
+            runtime: "claude_code"
+        });
+        startSession(session.id);
+        const wt = `/repo/.agent-dealer-worktrees/${session.id}-developer`;
+        patchRunningSession(session.id, { worktreePath: wt });
+        recordSessionProcess(session.id, child.pid, COORDINATOR_PROCESS_OWNER, child.startTime);
+        assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), {
+            state: "alive",
+            sessionId: session.id
+        });
+    }
+    finally {
+        child.kill();
+    }
+});
+test("checkDeveloperWorktreeOwnerLiveness: terminal session whose pid is still alive is alive (NOT-127)", () => {
+    const child = spawnLiveChild();
+    try {
+        const session = createWorkerSession({
+            issueId,
+            role: "developer",
+            round: 1,
+            agentId: BUILTIN_AGENT_CLAUDE_ID,
+            runtime: "claude_code"
+        });
+        startSession(session.id);
+        const wt = `/repo/.agent-dealer-worktrees/${session.id}-developer`;
+        patchRunningSession(session.id, { worktreePath: wt });
+        recordSessionProcess(session.id, child.pid, COORDINATOR_PROCESS_OWNER, child.startTime);
+        // Recovery wrongly marked it failed while the CLI kept running.
+        completeSession(session.id, {
+            status: "failed",
+            errorJson: JSON.stringify({ reason: "recovered — worker process presumed dead" })
+        });
+        assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), {
+            state: "alive",
+            sessionId: session.id
+        });
+    }
+    finally {
+        child.kill();
+    }
+});
+test("checkDeveloperWorktreeOwnerLiveness: terminal session with a dead pid is dead", async () => {
+    const child = spawnLiveChild();
+    const { pid, startTime } = child;
+    child.kill();
+    // Wait until the OS reaps it so kill(pid, 0) fails.
+    for (let i = 0; i < 50; i++) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((r) => setTimeout(r, 20));
+        }
+        catch {
+            break;
+        }
+    }
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code"
+    });
+    startSession(session.id);
+    const wt = `/repo/.agent-dealer-worktrees/${session.id}-developer`;
+    patchRunningSession(session.id, { worktreePath: wt });
+    recordSessionProcess(session.id, pid, COORDINATOR_PROCESS_OWNER, startTime);
+    completeSession(session.id, { status: "failed", errorJson: JSON.stringify({ reason: "gone" }) });
+    assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), { state: "dead" });
+});
+test("checkDeveloperWorktreeOwnerLiveness: unknown path with no session is dead", () => {
+    assert.deepEqual(checkDeveloperWorktreeOwnerLiveness("/repo/.agent-dealer-worktrees/no-such-session-developer"), { state: "dead" });
+});
+test("checkDeveloperWorktreeOwnerLiveness: running session with no pid yet still owns the worktree", () => {
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code"
+    });
+    startSession(session.id);
+    const wt = `/repo/.agent-dealer-worktrees/${session.id}-developer`;
+    patchRunningSession(session.id, { worktreePath: wt });
+    // No recordSessionProcess yet — worktree.ready before spawn.
+    assert.deepEqual(checkDeveloperWorktreeOwnerLiveness(wt), {
+        state: "alive",
+        sessionId: session.id
+    });
+});
+test("checkDeveloperWorktreeOwnerLiveness: after clean reuse, live successor on predecessor's path basename is still detected (Lens stale-basename-owner)", () => {
+    const child = spawnLiveChild();
+    try {
+        const predecessor = createWorkerSession({
+            issueId,
+            role: "developer",
+            round: 1,
+            agentId: BUILTIN_AGENT_CLAUDE_ID,
+            runtime: "claude_code"
+        });
+        startSession(predecessor.id);
+        const wt = `/repo/.agent-dealer-worktrees/${predecessor.id}-developer`;
+        patchRunningSession(predecessor.id, { worktreePath: wt });
+        completeSession(predecessor.id, {
+            status: "failed",
+            errorJson: JSON.stringify({ reason: "presumed dead" })
+        });
+        // Successor reused the leftover path in place — directory still named for predecessor.
+        const successor = createWorkerSession({
+            issueId,
+            role: "developer",
+            round: 1,
+            agentId: BUILTIN_AGENT_CLAUDE_ID,
+            runtime: "claude_code"
+        });
+        startSession(successor.id);
+        patchRunningSession(successor.id, { worktreePath: wt });
+        recordSessionProcess(successor.id, child.pid, COORDINATOR_PROCESS_OWNER, child.startTime);
+        const verdict = checkDeveloperWorktreeOwnerLiveness(wt);
+        assert.equal(verdict.state, "alive");
+        if (verdict.state === "alive") {
+            assert.equal(verdict.sessionId, successor.id, "must prefer the live successor over the dead basename predecessor");
+        }
+    }
+    finally {
+        child.kill();
+    }
+});

package/bundle/server/dist/db/artifacts-issue-columns.test.js

@@ -0,0 +1,18 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-artifact-cols-"));
+const { migrate, getDbPath } = await import("./index.js");
+test("migrate() adds issue_id and worker_session_id to the legacy artifacts table", () => {
+    migrate();
+    const db = new Database(getDbPath(), { readonly: true });
+    const cols = db.prepare("PRAGMA table_info(artifacts)").all();
+    const names = cols.map((c) => c.name);
+    assert.ok(names.includes("issue_id"), "expected artifacts.issue_id to exist");
+    assert.ok(names.includes("worker_session_id"), "expected artifacts.worker_session_id to exist");
+    assert.ok(names.includes("run_id"), "run_id must remain for legacy rows");
+    db.close();
+});