gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/command-queue.test.ts

@@ -0,0 +1,141 @@
+// gsd-2 + Command queue tests (Phase B coordination — IPC inbox + broadcast NULL semantics)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import {
+  enqueueCommand,
+  claimNextCommand,
+  completeCommand,
+  getCommand,
+} from "../db/command-queue.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-cmd-q-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("enqueue + claim + complete round-trip for targeted command", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({
+    targetWorker: "worker-A",
+    command: "cancel",
+    args: { reason: "user-request" },
+  });
+  assert.ok(id > 0);
+
+  const claimed = claimNextCommand("worker-A");
+  assert.ok(claimed);
+  assert.equal(claimed!.id, id);
+  assert.equal(claimed!.command, "cancel");
+  assert.equal(claimed!.claimed_by, "worker-A");
+  assert.ok(claimed!.claimed_at);
+
+  completeCommand(id, "worker-A", { acknowledged: true });
+  const final = getCommand(id);
+  assert.ok(final!.completed_at);
+  assert.equal(final!.result_json, JSON.stringify({ acknowledged: true }));
+});
+
+test("targeted command is invisible to other workers", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: "worker-A", command: "for-A" });
+  const wrong = claimNextCommand("worker-B");
+  assert.equal(wrong, null, "worker-B sees nothing for worker-A");
+
+  const right = claimNextCommand("worker-A");
+  assert.ok(right);
+  assert.equal(right!.command, "for-A");
+});
+
+test("broadcast command (target=null) is visible to ANY worker, claimed exactly once", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: null, command: "broadcast-cancel" });
+
+  const a = claimNextCommand("worker-A");
+  assert.ok(a, "first poller wins");
+  assert.equal(a!.command, "broadcast-cancel");
+
+  // Second poller (different worker) sees nothing — broadcast is single-delivery
+  const b = claimNextCommand("worker-B");
+  assert.equal(b, null);
+});
+
+test("oldest-first ordering across mixed targeted + broadcast queue", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  enqueueCommand({ targetWorker: null, command: "first" });
+  enqueueCommand({ targetWorker: "worker-A", command: "second" });
+  enqueueCommand({ targetWorker: null, command: "third" });
+
+  const c1 = claimNextCommand("worker-A")!;
+  const c2 = claimNextCommand("worker-A")!;
+  const c3 = claimNextCommand("worker-A")!;
+  assert.equal(c1.command, "first");
+  assert.equal(c2.command, "second");
+  assert.equal(c3.command, "third");
+  assert.equal(claimNextCommand("worker-A"), null);
+});
+
+test("completeCommand is idempotent — second call does not overwrite", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "w", command: "x" });
+  claimNextCommand("w");
+  completeCommand(id, "w", { result: 1 });
+  completeCommand(id, "w", { result: 2 }); // second call should no-op
+  const row = getCommand(id)!;
+  assert.equal(row.result_json, JSON.stringify({ result: 1 }));
+});
+
+test("completed commands cannot be reclaimed or completed by a different worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "worker-A", command: "x" });
+  const claimed = claimNextCommand("worker-A");
+  assert.ok(claimed);
+
+  completeCommand(id, "worker-A", { result: 1 });
+  completeCommand(id, "worker-B", { result: 2 });
+
+  assert.equal(claimNextCommand("worker-A"), null);
+  const row = getCommand(id)!;
+  assert.equal(row.result_json, JSON.stringify({ result: 1 }));
+});
+
+test("completeCommand does not complete an unclaimed command", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = enqueueCommand({ targetWorker: "w", command: "x" });
+  completeCommand(id, "w", { result: 1 });
+  const row = getCommand(id)!;
+  assert.equal(row.completed_at, null);
+  assert.equal(row.result_json, null);
+});

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -0,0 +1,203 @@
+// gsd-2 + Crash recovery via DB (Phase C pt 2 — auto.lock migration)
+//
+// auto.lock file IO is gone. readCrashLock now synthesizes a LockData
+// from the workers + unit_dispatches + runtime_kv tables. These tests
+// verify the synthesis end-to-end: register a worker, simulate it going
+// stale (heartbeat lapsed), and confirm readCrashLock returns the
+// correct LockData with PID, started_at, unit details, and session
+// file derived from the DB.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+import {
+  writeLock,
+  readCrashLock,
+  clearLock,
+  isLockProcessAlive,
+} from "../crash-recovery.ts";
+import { normalizeRealPath } from "../paths.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+/** Force a worker's last_heartbeat_at into the past so the stale-detector picks it up. */
+function expireWorker(workerId: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :w`,
+  ).run({ ":w": workerId });
+}
+
+function setWorkerPid(workerId: string, pid: number): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET pid = :pid WHERE worker_id = :w`,
+  ).run({ ":pid": pid, ":w": workerId });
+}
+
+test("readCrashLock returns null when no workers exist", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock returns null when only fresh (un-expired) workers exist", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  // Heartbeat is fresh — not stale yet.
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock ignores a stale heartbeat when the worker PID is still alive", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  expireWorker(workerId);
+
+  assert.equal(readCrashLock(base), null);
+});
+
+test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches yet)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.pid, 99999);
+  // Bootstrap default — no dispatches recorded
+  assert.equal(lock!.unitType, "starting");
+  assert.equal(lock!.unitId, "bootstrap");
+  assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
+});
+
+test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  recordDispatchClaim({
+    traceId: "t1", workerId, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.unitType, "plan-slice");
+  assert.equal(lock!.unitId, "M001/S01");
+});
+
+test("readCrashLock surfaces sessionFile from runtime_kv", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/pi-session-abc.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.sessionFile, "/tmp/pi-session-abc.jsonl");
+});
+
+test("isLockProcessAlive returns true for the current process", () => {
+  const lock = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isLockProcessAlive(lock), true);
+});
+
+test("isLockProcessAlive returns false for a dead PID", () => {
+  // PID 99999 is essentially guaranteed dead on a fresh test box.
+  const lock = {
+    pid: 99999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isLockProcessAlive(lock), false);
+});
+
+test("writeLock stores the session_file in runtime_kv (worker scope)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session-xyz.jsonl");
+
+  // Verify the value was written for the live worker.
+  const stored = getRuntimeKv<string>("worker", workerId, "session_file");
+  assert.equal(stored, "/tmp/session-xyz.jsonl");
+
+  // Confirm a stale read picks it up via readCrashLock.
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  const lock = readCrashLock(base);
+  assert.ok(lock);
+  assert.equal(lock!.sessionFile, "/tmp/session-xyz.jsonl");
+});
+
+test("clearLock removes the session_file row for the active worker", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session-xyz.jsonl");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), "/tmp/session-xyz.jsonl");
+
+  // clearLock operates on the active worker (this process) — must run
+  // BEFORE expiring the heartbeat, mirroring stopAuto's order: clearLock
+  // → markWorkerStopping → done.
+  clearLock(base);
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), null,
+    "session_file row deleted by clearLock");
+});

package/src/resources/extensions/gsd/tests/crash-recovery.test.ts

@@ -18,39 +18,96 @@ import {
   hasResumableDerivedState,
   isBootstrapCrashLock,
   readPausedSessionMetadata,
+  PAUSED_SESSION_KV_KEY,
 } from "../interrupted-session.ts";
-import { gsdRoot } from "../paths.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  _getAdapter,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { insertSlice, insertTask } from "../gsd-db.ts";
+import { setRuntimeKv } from "../db/runtime-kv.ts";
+import { normalizeRealPath } from "../paths.ts";
 import type { GSDState } from "../types.ts";
 import { _synthesizePausedSessionRecoveryForTest } from "../auto.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
   mkdirSync(join(base, ".gsd"), { recursive: true });
+  // Phase C pt 2: lock and paused-session live in the DB now. Open it
+  // for every test base so the helpers below can write through.
+  openDatabase(join(base, ".gsd", "gsd.db"));
   return base;
 }
 
 function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* */ }
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+/**
+ * Phase C pt 2 fixture: insert a stale worker row + dispatch + session_file
+ * directly via SQL so it appears as a crashed PEER process, not as the
+ * current test process. assessInterruptedSession filters out
+ * `rawLock.pid === process.pid` to avoid classifying its own process as
+ * a previous crash; using PID 999999999 (functionally guaranteed dead)
+ * bypasses that guard exactly the way the old file-based writeTestLock
+ * did with the same PID.
+ */
 function writeTestLock(
   base: string,
   unitType: string,
   unitId: string,
   sessionFile?: string,
 ): void {
-  writeFileSync(
-    join(gsdRoot(base), "auto.lock"),
-    JSON.stringify({
-      pid: 999999999,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-      sessionFile,
-    }, null, 2),
-    "utf-8",
-  );
+  const projectRoot = normalizeRealPath(base);
+  const workerId = `test-fake-${randomUUID().slice(0, 8)}`;
+  const fakePid = 999999999;
+  const stalePast = "1970-01-01T00:00:00.000Z";
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO workers (
+      worker_id, host, pid, started_at, version,
+      last_heartbeat_at, status, project_root_realpath
+    ) VALUES (
+      :w, 'test-host', :pid, :started_at, 'test',
+      :stale, 'active', :project_root
+    )`,
+  ).run({
+    ":w": workerId,
+    ":pid": fakePid,
+    ":started_at": new Date().toISOString(),
+    ":stale": stalePast,
+    ":project_root": projectRoot,
+  });
+
+  // Ensure milestones referenced by the unitId exist so the dispatch
+  // FK is satisfied. Parse "M###/S##" or "M###" or "starting" / etc.
+  const midMatch = unitId.match(/^(M\d+)/);
+  if (midMatch && unitType !== "starting") {
+    const mid = midMatch[1];
+    try { insertMilestone({ id: mid, title: `Test ${mid}`, status: "active" }); }
+    catch { /* may already exist */ }
+    try {
+      const lease = claimMilestoneLease(workerId, mid);
+      recordDispatchClaim({
+        traceId: randomUUID(),
+        workerId,
+        milestoneLeaseToken: lease.ok ? lease.token : 0,
+        milestoneId: mid,
+        unitType,
+        unitId,
+      });
+    } catch { /* ignore — best-effort */ }
+  }
+
+  if (sessionFile) {
+    setRuntimeKv("worker", workerId, "session_file", sessionFile);
+  }
 }
 
 function writeRoadmap(base: string, checked = false): void {
@@ -82,6 +139,25 @@ function writeRoadmap(base: string, checked = false): void {
     ].join("\n"),
     "utf-8",
   );
+  // Phase C pt 2: makeTmpBase() opens the DB so writeTestLock can write
+  // the workers row. deriveState then goes DB-first; mirror the markdown
+  // fixture into the DB so the assessment sees the same milestone state.
+  // Use direct upsert SQL so calling writeRoadmap twice (e.g. once for
+  // base + once for a paused worktree) actually flips the status.
+  const status = checked ? "complete" : "active";
+  const adapter = _getAdapter();
+  if (adapter) {
+    adapter.prepare(
+      `INSERT INTO milestones (id, title, status, created_at)
+       VALUES (:id, :title, :status, :now)
+       ON CONFLICT(id) DO UPDATE SET status = excluded.status, title = excluded.title`,
+    ).run({ ":id": "M001", ":title": "Test Milestone", ":status": status, ":now": new Date().toISOString() });
+    adapter.prepare(
+      `INSERT INTO slices (milestone_id, id, title, status, created_at)
+       VALUES (:mid, :sid, :title, :status, :now)
+       ON CONFLICT(milestone_id, id) DO UPDATE SET status = excluded.status, title = excluded.title`,
+    ).run({ ":mid": "M001", ":sid": "S01", ":title": "Test slice", ":status": status, ":now": new Date().toISOString() });
+  }
 }
 
 function writeCompleteSliceArtifacts(base: string): void {
@@ -105,13 +181,16 @@ function writePausedSession(
   unitType?: string,
   unitId?: string,
 ): void {
-  const runtimeDir = join(base, ".gsd", "runtime");
-  mkdirSync(runtimeDir, { recursive: true });
-  writeFileSync(
-    join(runtimeDir, "paused-session.json"),
-    JSON.stringify({ milestoneId, originalBasePath: base, stepMode, worktreePath, unitType, unitId }, null, 2),
-    "utf-8",
-  );
+  // Phase C pt 2: paused-session.json migrated to runtime_kv
+  // (global scope, key PAUSED_SESSION_KV_KEY).
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+    milestoneId,
+    originalBasePath: base,
+    stepMode,
+    worktreePath,
+    unitType,
+    unitId,
+  });
 }
 
 function writeActivityLog(base: string, entries: Record<string, unknown>[]): void {
@@ -231,14 +310,12 @@ test("readPausedSessionMetadata preserves unitType and unitId through round-trip
 test("readPausedSessionMetadata handles legacy metadata without unitType/unitId", () => {
   const base = makeTmpBase();
   try {
-    // Write metadata without unitType/unitId (simulates older version)
-    const runtimeDir = join(base, ".gsd", "runtime");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      join(runtimeDir, "paused-session.json"),
-      JSON.stringify({ milestoneId: "M001", originalBasePath: base }),
-      "utf-8",
-    );
+    // Phase C pt 2: write directly to runtime_kv (simulates older payload
+    // missing the now-canonical unitType/unitId fields).
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: "M001",
+      originalBasePath: base,
+    });
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta?.milestoneId, "M001");
     assert.equal(meta?.unitType, undefined);
@@ -251,23 +328,23 @@ test("readPausedSessionMetadata handles legacy metadata without unitType/unitId"
 test("readPausedSessionMetadata drops stale discuss-milestone pseudo PROJECT metadata", () => {
   const base = makeTmpBase();
   try {
-    const runtimeDir = join(base, ".gsd", "runtime");
-    const pausedPath = join(runtimeDir, "paused-session.json");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      pausedPath,
-      JSON.stringify({
-        milestoneId: null,
-        originalBasePath: base,
-        unitType: "discuss-milestone",
-        unitId: "PROJECT",
-      }, null, 2),
-      "utf-8",
-    );
+    // Phase C pt 2: write directly to runtime_kv (the file location is gone)
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: null,
+      originalBasePath: base,
+      unitType: "discuss-milestone",
+      unitId: "PROJECT",
+    });
 
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta, null);
-    assert.equal(existsSync(pausedPath), false);
+    // Confirm the row was deleted by readPausedSessionMetadata's
+    // isStalePseudoMilestonePause branch.
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT 1 FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :k`,
+    ).get({ ":k": PAUSED_SESSION_KV_KEY });
+    assert.equal(row, undefined);
   } finally {
     cleanup(base);
   }
@@ -276,23 +353,20 @@ test("readPausedSessionMetadata drops stale discuss-milestone pseudo PROJECT met
 test("readPausedSessionMetadata drops stale deep setup pseudo-unit metadata", () => {
   const base = makeTmpBase();
   try {
-    const runtimeDir = join(base, ".gsd", "runtime");
-    const pausedPath = join(runtimeDir, "paused-session.json");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(
-      pausedPath,
-      JSON.stringify({
-        milestoneId: "WORKFLOW-PREFS",
-        originalBasePath: base,
-        unitType: "workflow-preferences",
-        unitId: "WORKFLOW-PREFS",
-      }, null, 2),
-      "utf-8",
-    );
+    setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, {
+      milestoneId: "WORKFLOW-PREFS",
+      originalBasePath: base,
+      unitType: "workflow-preferences",
+      unitId: "WORKFLOW-PREFS",
+    });
 
     const meta = readPausedSessionMetadata(base);
     assert.equal(meta, null);
-    assert.equal(existsSync(pausedPath), false);
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT 1 FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :k`,
+    ).get({ ":k": PAUSED_SESSION_KV_KEY });
+    assert.equal(row, undefined);
   } finally {
     cleanup(base);
   }
@@ -504,10 +578,29 @@ test("assessInterruptedSession treats bootstrap crash as stale without paused me
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
 test("writeLock creates lock file and readCrashLock reads it", (t) => {
+  // Phase C pt 2: lock state is reconstructed from workers + unit_dispatches
+  // + runtime_kv. The fresh worker is not stale yet — we register, dispatch,
+  // write the session_file, then expire the heartbeat to simulate a crash.
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  recordDispatchClaim({
+    traceId: "t1", workerId, milestoneLeaseToken: lease.token,
+    milestoneId: "M001", unitType: "execute-task", unitId: "M001/S01/T01",
+  });
   writeLock(base, "execute-task", "M001/S01/T01", "/tmp/session.jsonl");
+
+  // Force stale so readCrashLock surfaces it.
+  _getAdapter()!.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :w`,
+  ).run({ ":w": workerId });
+
   const lock = readCrashLock(base);
   assert.ok(lock, "lock should exist");
   assert.equal(lock!.unitType, "execute-task");
@@ -527,13 +620,30 @@ test("readCrashLock returns null when no lock exists", (t) => {
 // ─── clearLock ────────────────────────────────────────────────────────────
 
 test("clearLock removes existing lock file", (t) => {
+  // Phase C pt 2: clearLock now drops the session_file runtime_kv row
+  // for the LIVE worker (not the stale one). The "lock state" itself
+  // (pid, unitType, etc.) lives in workers + unit_dispatches; those are
+  // managed by markWorkerStopping (called from stopAuto, not here).
   const base = makeTmpBase();
   t.after(() => cleanup(base));
 
-  writeLock(base, "plan-slice", "M001/S01");
-  assert.ok(readCrashLock(base), "lock should exist before clear");
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  writeLock(base, "plan-slice", "M001/S01", "/tmp/session.jsonl");
+  // Confirm the session_file row landed for the live worker.
+  const adapter = _getAdapter()!;
+  const before = adapter.prepare(
+    `SELECT 1 FROM runtime_kv WHERE scope = 'worker' AND scope_id = :w AND key = 'session_file'`,
+  ).get({ ":w": workerId });
+  assert.ok(before, "session_file row exists before clear");
+
   clearLock(base);
-  assert.equal(readCrashLock(base), null, "lock should be gone after clear");
+
+  const after = adapter.prepare(
+    `SELECT 1 FROM runtime_kv WHERE scope = 'worker' AND scope_id = :w AND key = 'session_file'`,
+  ).get({ ":w": workerId });
+  assert.equal(after, undefined, "session_file row gone after clearLock");
 });
 
 test("clearLock is safe when no lock exists", (t) => {