@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/core/__tests__/orchestrator.test.ts

@@ -1,19 +1,25 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect, afterEach } from "bun:test";
+import type { Subprocess } from "bun";
 import { mkdtemp, mkdir, writeFile, utimes, rm, readdir, readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
+  adoptOrphanedRunners,
   drainPendingQueue,
   handleChildExit,
   resolveDirs,
+  startOrchestrator,
   promoteSeedFile,
   restoreSeedFile,
 } from "../orchestrator";
+import type { ChildHandle } from "../orchestrator";
 import {
   getConcurrencyRuntimePaths,
   getJobConcurrencyStatus,
 } from "../job-concurrency";
+import { isProcessAlive } from "../runner-liveness";
+import { resetConfig } from "../config";
 
 async function setupDir(prefix: string): Promise<string> {
   const dir = await mkdtemp(join(tmpdir(), prefix));
@@ -131,6 +137,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 2,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual(["job-a", "job-b"]);
@@ -154,6 +161,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 0,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual([]);
@@ -181,6 +189,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 5,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual(["job-fresh"]);
@@ -206,6 +215,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 5,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual(["job-staged"]);
@@ -232,6 +242,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 5,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual(["job-heal"]);
@@ -255,6 +266,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 5,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: fakeSpawnRunner(pids),
       });
       expect(result.promoted).toEqual(["job-a", "job-b", "job-c"]);
@@ -274,6 +286,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 2,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: failingSpawn,
       });
       expect(result.promoted).toEqual([]);
@@ -300,6 +313,7 @@ describe("drainPendingQueue", () => {
           dataDir: dir,
           maxConcurrentJobs: 2,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: failingSpawn,
         });
       }
@@ -328,6 +342,7 @@ describe("drainPendingQueue", () => {
           dataDir: dir,
           maxConcurrentJobs: 2,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: failingSpawn,
         });
       }
@@ -354,6 +369,7 @@ describe("drainPendingQueue", () => {
           dataDir: dir,
           maxConcurrentJobs: 2,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: fakeSpawnRunner(new Map()),
         });
       }
@@ -377,6 +393,7 @@ describe("drainPendingQueue", () => {
         dataDir: dir,
         maxConcurrentJobs: 2,
         lockTimeoutMs: 10,
+        staleLeaseTimeoutMs: 10,
         spawnRunner: async () => {
           await mkdir(lockDir, { recursive: true });
           await writeFile(join(lockDir, "owner.json"), JSON.stringify({ pid: process.pid, acquiredAt: new Date().toISOString() }));
@@ -412,6 +429,7 @@ describe("handleChildExit", () => {
         dataDir: dir,
         maxConcurrentJobs: 1,
         lockTimeoutMs: 1000,
+        staleLeaseTimeoutMs: 1000,
         spawnRunner: spawn,
       });
       expect(first.promoted).toEqual(["job-a"]);
@@ -423,6 +441,7 @@ describe("handleChildExit", () => {
           dataDir: dir,
           maxConcurrentJobs: 1,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: spawn,
         }).then((r) => {
           drainResult = r;
@@ -463,6 +482,146 @@ describe("handleChildExit", () => {
       await rm(dir, { recursive: true });
     }
   });
+
+  test("handleChildExit still attempts reconciliation when slot release fails", async () => {
+    const dir = await setupDir("exit-release-fails-");
+    try {
+      const releaseError = new Error("release failed");
+      let drained = false;
+      let reconciled = false;
+
+      await expect(handleChildExit({
+        dataDir: dir,
+        jobId: "job-release-fails",
+        triggerDrain: () => {
+          drained = true;
+        },
+        lockTimeoutMs: 1000,
+        releaseSlot: async () => {
+          throw releaseError;
+        },
+        reconcileJob: async () => {
+          reconciled = true;
+          return { reconciled: false, reason: "unreadable" };
+        },
+      })).rejects.toThrow("release failed");
+
+      expect(reconciled).toBe(true);
+      expect(drained).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("handleChildExit reports both cleanup errors when slot release and reconciliation fail", async () => {
+    const dir = await setupDir("exit-both-fail-");
+    try {
+      const releaseError = new Error("release failed");
+      const reconcileError = new Error("reconcile failed");
+      let drained = false;
+
+      let thrown: unknown;
+      try {
+        await handleChildExit({
+          dataDir: dir,
+          jobId: "job-both-fail",
+          triggerDrain: () => {
+            drained = true;
+          },
+          lockTimeoutMs: 1000,
+          releaseSlot: async () => {
+            throw releaseError;
+          },
+          reconcileJob: async () => {
+            throw reconcileError;
+          },
+        });
+      } catch (err) {
+        thrown = err;
+      }
+
+      expect(thrown).toBeInstanceOf(AggregateError);
+      expect((thrown as AggregateError).message).toBe("child exit cleanup failed");
+      expect((thrown as AggregateError).errors).toEqual([releaseError, reconcileError]);
+      expect(drained).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("AC-3: a mid-job runner exit marks the running task and job failed, releases the slot, and triggers a drain", async () => {
+    const dir = await setupDir("exit-reconcile-");
+    try {
+      const jobId = "job-running";
+      const jobDir = join(dir, "current", jobId);
+      await mkdir(jobDir, { recursive: true });
+      await writeFile(
+        join(jobDir, "tasks-status.json"),
+        JSON.stringify({
+          id: jobId,
+          state: "running",
+          current: "research",
+          currentStage: null,
+          lastUpdated: "2026-06-19T11:00:00.000Z",
+          tasks: { research: { state: "running" } },
+          files: { artifacts: [], logs: [], tmp: [] },
+        }),
+      );
+      await writeFile(join(jobDir, "runner.pid"), "999999");
+
+      let drained = false;
+      await handleChildExit({
+        dataDir: dir,
+        jobId,
+        triggerDrain: () => {
+          drained = true;
+        },
+        code: 1,
+        signal: null,
+        lockTimeoutMs: 1000,
+      });
+
+      expect(drained).toBe(true);
+      const { runningJobsDir } = getConcurrencyRuntimePaths(dir);
+      expect(existsSync(join(runningJobsDir, `${jobId}.json`))).toBe(false);
+
+      const snapshot = JSON.parse(await readFile(join(jobDir, "tasks-status.json"), "utf-8")) as Record<string, unknown>;
+      expect(snapshot["state"]).toBe("failed");
+      const tasks = snapshot["tasks"] as Record<string, Record<string, unknown>>;
+      expect(tasks["research"]?.["state"]).toBe("failed");
+      expect(tasks["research"]?.["error"]).toBeTruthy();
+      const errorContext = tasks["research"]?.["errorContext"] as Record<string, unknown>;
+      expect(errorContext?.["kind"]).toBe("runner-interrupted");
+      expect(errorContext?.["code"]).toBe(1);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("AC-10: a job already moved to complete/ (no current/ status) is untouched, and the drain still fires", async () => {
+    const dir = await setupDir("exit-complete-");
+    try {
+      const jobId = "job-gone";
+      const statusPath = join(dir, "current", jobId, "tasks-status.json");
+
+      let drainCount = 0;
+      await handleChildExit({
+        dataDir: dir,
+        jobId,
+        triggerDrain: () => {
+          drainCount++;
+        },
+        code: 0,
+        signal: null,
+        lockTimeoutMs: 1000,
+      });
+
+      expect(drainCount).toBe(1);
+      expect(existsSync(statusPath)).toBe(false);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
 });
 
 describe("drainPendingQueue concurrency", () => {
@@ -481,12 +640,14 @@ describe("drainPendingQueue concurrency", () => {
           dataDir: dir,
           maxConcurrentJobs: 2,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: spawn,
         }),
         drainPendingQueue({
           dataDir: dir,
           maxConcurrentJobs: 2,
           lockTimeoutMs: 1000,
+          staleLeaseTimeoutMs: 1000,
           spawnRunner: spawn,
         }),
       ]);
@@ -512,3 +673,455 @@ describe("drainPendingQueue concurrency", () => {
     }
   });
 });
+
+describe("drainPendingQueue stale-lease age (AC-5)", () => {
+  test("does not prune a fresh null-pid in-flight lease when lockTimeoutMs is short but staleLeaseTimeoutMs is long", async () => {
+    const dir = await setupDir("drain-stale-age-");
+    try {
+      await writeLease(
+        dir,
+        "job-held",
+        null,
+        new Date(Date.now() - 1000).toISOString(),
+      );
+      await writeSeed(dir, "job-queued", { pipeline: "p" }, 1700000000);
+
+      const result = await drainPendingQueue({
+        dataDir: dir,
+        maxConcurrentJobs: 1,
+        lockTimeoutMs: 50,
+        staleLeaseTimeoutMs: 30000,
+        spawnRunner: fakeSpawnRunner(new Map()),
+      });
+
+      expect(result.promoted).toEqual([]);
+      const { runningJobsDir } = getConcurrencyRuntimePaths(dir);
+      expect(existsSync(join(runningJobsDir, "job-held.json"))).toBe(true);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+});
+
+interface FakeWatcher {
+  on(event: "add", cb: (path: string) => void): FakeWatcher;
+  on(event: "ready", cb: () => void): FakeWatcher;
+  on(event: "error", cb: (err: Error) => void): FakeWatcher;
+  close(): Promise<void>;
+}
+
+function makeFakeWatcherFactory() {
+  return (_path: string, _options: Record<string, unknown>): FakeWatcher => {
+    const watcher = {
+      on(event: "add" | "ready" | "error", cb: () => void): FakeWatcher {
+        if (event === "ready") queueMicrotask(() => cb());
+        return watcher;
+      },
+      close(): Promise<void> {
+        return Promise.resolve();
+      },
+    } as unknown as FakeWatcher;
+    return watcher;
+  };
+}
+
+async function writeRunningJob(
+  dataDir: string,
+  jobId: string,
+  lastUpdated: string,
+  runnerPid: number,
+): Promise<void> {
+  const jobDir = join(dataDir, "current", jobId);
+  await mkdir(jobDir, { recursive: true });
+  await writeFile(
+    join(jobDir, "tasks-status.json"),
+    JSON.stringify({
+      id: jobId,
+      state: "running",
+      current: "research",
+      currentStage: null,
+      lastUpdated,
+      tasks: { research: { state: "running" } },
+      files: { artifacts: [], logs: [], tmp: [] },
+    }),
+  );
+  await writeFile(join(jobDir, "runner.pid"), String(runnerPid));
+}
+
+async function writeLease(
+  dataDir: string,
+  jobId: string,
+  pid: number | null,
+  acquiredAt: string,
+): Promise<string> {
+  const { runningJobsDir } = getConcurrencyRuntimePaths(dataDir);
+  await mkdir(runningJobsDir, { recursive: true });
+  const slotPath = join(runningJobsDir, `${jobId}.json`);
+  await writeFile(slotPath, JSON.stringify({
+    jobId,
+    pid,
+    acquiredAt,
+    source: "orchestrator",
+    slotPath,
+  }));
+  return slotPath;
+}
+
+describe("startOrchestrator boot sweep (AC-16)", () => {
+  afterEach(() => {
+    resetConfig();
+  });
+
+  test("a stale orphaned job in current/ is marked failed and the handle still resolves", async () => {
+    const root = await mkdtemp(join(tmpdir(), "boot-stale-"));
+    const dataDir = join(root, "pipeline-data");
+    try {
+      await writeRunningJob(dataDir, "job-stale", "2020-01-01T00:00:00.000Z", 999999);
+
+      const handle = await startOrchestrator({
+        dataDir,
+        watcherFactory: makeFakeWatcherFactory(),
+      });
+
+      expect(handle).toBeDefined();
+      expect(typeof handle.stop).toBe("function");
+
+      const snapshot = JSON.parse(
+        await readFile(join(dataDir, "current", "job-stale", "tasks-status.json"), "utf-8"),
+      ) as Record<string, unknown>;
+      expect(snapshot["state"]).toBe("failed");
+      const tasks = snapshot["tasks"] as Record<string, Record<string, unknown>>;
+      expect(tasks["research"]?.["state"]).toBe("failed");
+
+      await handle.stop();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("a live job in current/ is left running and the handle still resolves", async () => {
+    const root = await mkdtemp(join(tmpdir(), "boot-live-"));
+    const dataDir = join(root, "pipeline-data");
+    try {
+      await writeRunningJob(dataDir, "job-live", "2020-01-01T00:00:00.000Z", process.pid);
+
+      const handle = await startOrchestrator({
+        dataDir,
+        watcherFactory: makeFakeWatcherFactory(),
+      });
+
+      expect(handle).toBeDefined();
+      expect(typeof handle.stop).toBe("function");
+
+      const snapshot = JSON.parse(
+        await readFile(join(dataDir, "current", "job-live", "tasks-status.json"), "utf-8"),
+      ) as Record<string, unknown>;
+      expect(snapshot["state"]).toBe("running");
+      const tasks = snapshot["tasks"] as Record<string, Record<string, unknown>>;
+      expect(tasks["research"]?.["state"]).toBe("running");
+
+      await handle.stop();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-13: threads staleLeaseTimeoutMs into boot reconciliation so a mid-aged in-flight lease is not abandoned", async () => {
+    const root = await mkdtemp(join(tmpdir(), "boot-stale-age-"));
+    const dataDir = join(root, "pipeline-data");
+    const previous = process.env["PO_STALE_LEASE_TIMEOUT_MS"];
+    process.env["PO_STALE_LEASE_TIMEOUT_MS"] = "60000";
+    resetConfig();
+    try {
+      await writeRunningJob(dataDir, "job-inflight", "2020-01-01T00:00:00.000Z", 999999);
+      await writeLease(
+        dataDir,
+        "job-inflight",
+        null,
+        new Date(Date.now() - 40000).toISOString(),
+      );
+
+      const handle = await startOrchestrator({
+        dataDir,
+        watcherFactory: makeFakeWatcherFactory(),
+      });
+
+      const snapshot = JSON.parse(
+        await readFile(join(dataDir, "current", "job-inflight", "tasks-status.json"), "utf-8"),
+      ) as Record<string, unknown>;
+      expect(snapshot["state"]).toBe("running");
+
+      await handle.stop();
+    } finally {
+      if (previous === undefined) delete process.env["PO_STALE_LEASE_TIMEOUT_MS"];
+      else process.env["PO_STALE_LEASE_TIMEOUT_MS"] = previous;
+      resetConfig();
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-2: a stale dead_pid lease in runtime/running-jobs/ is pruned at boot", async () => {
+    const root = await mkdtemp(join(tmpdir(), "boot-prune-dead-"));
+    const dataDir = join(root, "pipeline-data");
+    try {
+      await writeRunningJob(dataDir, "job-dead", "2020-01-01T00:00:00.000Z", 999999);
+      await writeLease(dataDir, "job-dead", 999999, "2020-01-01T00:00:00.000Z");
+
+      const handle = await startOrchestrator({
+        dataDir,
+        watcherFactory: makeFakeWatcherFactory(),
+      });
+
+      const { runningJobsDir } = getConcurrencyRuntimePaths(dataDir);
+      expect(existsSync(join(runningJobsDir, "job-dead.json"))).toBe(false);
+
+      await handle.stop();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-2: a live-pid lease with matching runner.pid is retained at boot", async () => {
+    const root = await mkdtemp(join(tmpdir(), "boot-prune-live-"));
+    const dataDir = join(root, "pipeline-data");
+    // Use a real disposable child for the "live pid" so re-adoption + handle.stop()
+    // (which SIGTERMs the adopted handle) targets the child, never the test runner.
+    const child = spawnSleeperChild();
+    try {
+      await writeRunningJob(dataDir, "job-live", "2020-01-01T00:00:00.000Z", child.pid!);
+      await writeLease(dataDir, "job-live", child.pid!, "2020-01-01T00:00:00.000Z");
+
+      const handle = await startOrchestrator({
+        dataDir,
+        watcherFactory: makeFakeWatcherFactory(),
+      });
+
+      const { runningJobsDir } = getConcurrencyRuntimePaths(dataDir);
+      expect(existsSync(join(runningJobsDir, "job-live.json"))).toBe(true);
+
+      await handle.stop();
+    } finally {
+      await teardownChild(child);
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-7: with PO_MAX_RUNNING_JOBS=foo, startOrchestrator throws synchronously before creating pipeline-data directories", () => {
+    const root = mkdtempSync(join(tmpdir(), "boot-bad-env-"));
+    const dataDir = join(root, "pipeline-data");
+    const previous = process.env["PO_MAX_RUNNING_JOBS"];
+    process.env["PO_MAX_RUNNING_JOBS"] = "foo";
+    resetConfig();
+    try {
+      expect(() =>
+        startOrchestrator({
+          dataDir,
+          watcherFactory: makeFakeWatcherFactory(),
+        }),
+      ).toThrow(/PO_MAX_RUNNING_JOBS/);
+
+      expect(existsSync(join(dataDir, "pending"))).toBe(false);
+      expect(existsSync(join(dataDir, "current"))).toBe(false);
+      expect(existsSync(join(dataDir, "complete"))).toBe(false);
+      expect(existsSync(join(dataDir, "rejected"))).toBe(false);
+      expect(existsSync(join(dataDir, "staging"))).toBe(false);
+    } finally {
+      if (previous === undefined) delete process.env["PO_MAX_RUNNING_JOBS"];
+      else process.env["PO_MAX_RUNNING_JOBS"] = previous;
+      resetConfig();
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+function spawnSleeperChild(): Subprocess<"ignore", "ignore", "ignore"> {
+  return Bun.spawn(["sleep", "30"], {
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+}
+
+async function teardownChild(child: Subprocess<"ignore", "ignore", "ignore">): Promise<void> {
+  try {
+    child.kill(9);
+  } catch {
+    // already gone
+  }
+  await child.exited.catch(() => undefined);
+}
+
+async function writeRunnerPid(dataDir: string, jobId: string, pid: number): Promise<void> {
+  const jobDir = join(dataDir, "current", jobId);
+  await mkdir(jobDir, { recursive: true });
+  await writeFile(join(jobDir, "runner.pid"), String(pid));
+}
+
+describe("adoptOrphanedRunners (AC-4, AC-10, AC-11, AC-12)", () => {
+  test("AC-4: a live lease whose runner.pid matches is adopted, and kill(15) delivers SIGTERM to the child", async () => {
+    const dir = await setupDir("adopt-live-");
+    const child = spawnSleeperChild();
+    try {
+      const jobId = "job-adopt";
+      await writeRunnerPid(dir, jobId, child.pid!);
+      await writeLease(dir, jobId, child.pid!, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      const adopted = await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      expect(adopted).toEqual([jobId]);
+      expect(running.has(jobId)).toBe(true);
+
+      const handle = running.get(jobId)!;
+      handle.kill(15);
+
+      const result = await Promise.race([
+        child.exited.then(() => "exited" as const),
+        new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 3000)),
+      ]);
+      expect(result).toBe("exited");
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-10: a lease with a dead pid is not adopted", async () => {
+    const dir = await setupDir("adopt-dead-");
+    const child = spawnSleeperChild();
+    try {
+      const deadPid = 999999;
+      await writeRunnerPid(dir, "job-dead", deadPid);
+      await writeLease(dir, "job-dead", deadPid, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      const adopted = await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      expect(adopted).toEqual([]);
+      expect(running.size).toBe(0);
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-10: a live lease with an absent runner.pid is not adopted", async () => {
+    const dir = await setupDir("adopt-nopidfile-");
+    const child = spawnSleeperChild();
+    try {
+      const jobId = "job-nopidfile";
+      await mkdir(join(dir, "current", jobId), { recursive: true });
+      await writeLease(dir, jobId, child.pid!, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      const adopted = await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      expect(adopted).toEqual([]);
+      expect(running.size).toBe(0);
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-10: a live lease whose runner.pid mismatches is not adopted", async () => {
+    const dir = await setupDir("adopt-mismatch-");
+    const child = spawnSleeperChild();
+    try {
+      const jobId = "job-mismatch";
+      await writeRunnerPid(dir, jobId, child.pid! + 1);
+      await writeLease(dir, jobId, child.pid!, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      const adopted = await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      expect(adopted).toEqual([]);
+      expect(running.size).toBe(0);
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-11: mutating runner.pid to a different value before kill causes the signal to be skipped", async () => {
+    const dir = await setupDir("adopt-reread-");
+    const child = spawnSleeperChild();
+    try {
+      const jobId = "job-reread";
+      await writeRunnerPid(dir, jobId, child.pid!);
+      await writeLease(dir, jobId, child.pid!, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      // Mutate runner.pid before kill so the re-read guard skips the signal.
+      await writeFile(join(dir, "current", jobId, "runner.pid"), String(child.pid! + 1));
+
+      const handle = running.get(jobId)!;
+      handle.kill(15);
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      expect(isProcessAlive(child.pid!)).toBe(true);
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("AC-12: reading exited starts the poll and resolves with completionType 'signal' after death; getter is lazy (memoized)", async () => {
+    const dir = await setupDir("adopt-exited-");
+    const child = spawnSleeperChild();
+    try {
+      const jobId = "job-exited";
+      await writeRunnerPid(dir, jobId, child.pid!);
+      await writeLease(dir, jobId, child.pid!, new Date().toISOString());
+
+      const running = new Map<string, ChildHandle>();
+      await adoptOrphanedRunners({
+        dataDir: dir,
+        currentDir: join(dir, "current"),
+        running,
+      });
+
+      const handle = running.get(jobId)!;
+
+      // Reading `exited` is what starts the poll; the getter must memoize the promise.
+      const exitedA = handle.exited;
+      const exitedB = handle.exited;
+      expect(exitedA).toBe(exitedB);
+
+      child.kill(9);
+
+      const result = await Promise.race([
+        exitedA,
+        new Promise<{ completionType: string }>((resolve) =>
+          setTimeout(() => resolve({ completionType: "timeout" }), 3000),
+        ),
+      ]);
+      expect(result).toEqual({ code: null, signal: null, completionType: "signal" });
+    } finally {
+      await teardownChild(child);
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});