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

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -0,0 +1,134 @@
+// gsd-2 + Stuck-state DB-migration regression (Phase C)
+//
+// stuck-state.json file IO has been deleted. The auto-loop now reconstructs
+// recentUnits from unit_dispatches (Phase B ledger) and persists
+// stuckRecoveryAttempts in runtime_kv (stable project scope, soft state).
+//
+// This test verifies the round-trip via the db modules directly: write
+// dispatch rows + a runtime_kv counter, then confirm the same data shape
+// the loop expects is returned.
+
+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,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import {
+  recordDispatchClaim,
+  getRecentUnitKeysForWorker,
+} from "../db/unit-dispatches.ts";
+import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stuck-state-db-"));
+  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("getRecentUnitKeysForWorker reconstructs the recentUnits sliding window", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  // Record three dispatches in chronological order. Each must transition
+  // out of 'claimed' before the next one with the same unit_id can claim
+  // (partial unique index). We use distinct unit IDs so all three coexist.
+  const claims: number[] = [];
+  for (const id of ["U1", "U2", "U3"]) {
+    const c = recordDispatchClaim({
+      traceId: id, workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M001", unitType: "plan-slice", unitId: id,
+    });
+    assert.equal(c.ok, true);
+    if (c.ok) claims.push(c.dispatchId);
+  }
+
+  // The loader should return them oldest-first to match the in-memory
+  // window semantics that detect-stuck.ts expects.
+  const window = getRecentUnitKeysForWorker(worker, 20);
+  assert.deepEqual(window.map(w => w.key), ["U1", "U2", "U3"]);
+});
+
+test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  for (let i = 0; i < 25; i++) {
+    const c = recordDispatchClaim({
+      traceId: `t${i}`, workerId: worker, milestoneLeaseToken: lease.token,
+      milestoneId: "M001", unitType: "plan-slice", unitId: `U${i}`,
+    });
+    assert.equal(c.ok, true);
+  }
+
+  const win20 = getRecentUnitKeysForWorker(worker, 20);
+  assert.equal(win20.length, 20);
+  // Most recent 20 are U5..U24 (chronological), oldest-first → U5..U24.
+  assert.equal(win20[0].key, "U5");
+  assert.equal(win20[19].key, "U24");
+});
+
+test("stuckRecoveryAttempts round-trips via runtime_kv (stable project scope)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  registerAutoWorker({ projectRootRealpath: base });
+
+  setRuntimeKv("global", base, "stuck_recovery_attempts", 3);
+  assert.equal(getRuntimeKv<number>("global", base, "stuck_recovery_attempts"), 3);
+  setRuntimeKv("global", base, "stuck_recovery_attempts", 7);
+  assert.equal(getRuntimeKv<number>("global", base, "stuck_recovery_attempts"), 7);
+});
+
+test("getRecentUnitKeysForWorker filters by worker_id (no cross-worker bleed)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertMilestone({ id: "M002", title: "U", status: "active" });
+  const w1 = registerAutoWorker({ projectRootRealpath: base });
+  const w2 = registerAutoWorker({ projectRootRealpath: base });
+  const lease1 = claimMilestoneLease(w1, "M001");
+  const lease2 = claimMilestoneLease(w2, "M002");
+  assert.equal(lease1.ok, true);
+  assert.equal(lease2.ok, true);
+  if (!lease1.ok || !lease2.ok) return;
+
+  recordDispatchClaim({
+    traceId: "ta", workerId: w1, milestoneLeaseToken: lease1.token,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "for-w1",
+  });
+  recordDispatchClaim({
+    traceId: "tb", workerId: w2, milestoneLeaseToken: lease2.token,
+    milestoneId: "M002", unitType: "plan-slice", unitId: "for-w2",
+  });
+
+  const w1Window = getRecentUnitKeysForWorker(w1, 20);
+  const w2Window = getRecentUnitKeysForWorker(w2, 20);
+  assert.deepEqual(w1Window.map(w => w.key), ["for-w1"]);
+  assert.deepEqual(w2Window.map(w => w.key), ["for-w2"]);
+});

package/src/resources/extensions/gsd/tests/sync-layer-scope.test.ts

@@ -21,8 +21,10 @@ import {
   syncStateToProjectRootByScope,
   syncGsdStateToWorktree,
   syncGsdStateToWorktreeByScope,
-  reconcilePlanCheckboxesByScope,
 } from "../auto-worktree.ts";
+// Phase C: reconcilePlanCheckboxesByScope was deleted along with the
+// underlying reconcilePlanCheckboxes (auto-worktree.ts). Worktrees no
+// longer maintain a parallel .gsd/ projection that needs reconciliation.
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
@@ -124,19 +126,8 @@ describe("ByScope variants: mismatched-workspace identity assertion", () => {
     );
   });
 
-  test("reconcilePlanCheckboxesByScope throws when identityKeys differ", () => {
-    mkdirSync(join(tmpA, ".gsd"), { recursive: true });
-    mkdirSync(join(tmpB, ".gsd"), { recursive: true });
-    const wsA = createWorkspace(tmpA);
-    const wsB = createWorkspace(tmpB);
-    const scopeA = scopeMilestone(wsA, MID);
-    const scopeB = scopeMilestone(wsB, MID);
-
-    assert.throws(
-      () => reconcilePlanCheckboxesByScope(scopeA, scopeB),
-      /scope identity mismatch/,
-    );
-  });
+  // Phase C: reconcilePlanCheckboxesByScope identity-mismatch test
+  // removed along with the deleted function.
 });
 
 // ─── Suite: same-milestone, same-workspace path identity ────────────────────
@@ -425,18 +416,8 @@ describe("ByScope variants: milestoneId mismatch throws for milestone-aware wrap
     );
   });
 
-  test("reconcilePlanCheckboxesByScope throws when milestoneIds differ", () => {
-    const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);
-    const rootWs = createWorkspace(projectDir);
-    const worktreeWs = createWorkspace(worktreeDir);
-    const rootScope = scopeMilestone(rootWs, "M001-abc123");
-    const worktreeScope = scopeMilestone(worktreeWs, "M002-def456");
-
-    assert.throws(
-      () => reconcilePlanCheckboxesByScope(rootScope, worktreeScope),
-      /milestoneId mismatch/,
-    );
-  });
+  // Phase C: reconcilePlanCheckboxesByScope milestoneId-mismatch test
+  // removed along with the deleted function.
 
   test("syncGsdStateToWorktreeByScope does NOT throw when milestoneIds differ (workspace-only wrapper)", () => {
     const { projectDir, worktreeDir } = makeProjectAndWorktree(tmp);

package/src/resources/extensions/gsd/tests/teardown-cleanup-parity.test.ts

@@ -53,24 +53,21 @@ describe("teardownAutoWorktree cleanup parity", () => {
     _resetAutoWorktreeOriginalBaseForTests();
   });
 
-  test("STATE.md, auto.lock, and M001-META.json are removed after abort teardown", () => {
+  test("STATE.md and M001-META.json are removed after abort teardown", () => {
+    // Phase C pt 2: auto.lock no longer exists as a file — it migrated
+    // to the workers + unit_dispatches tables. clearProjectRootStateFiles
+    // still removes STATE.md and {MID}-META.json on teardown.
     const gsdDir = join(repoDir, ".gsd");
     const milestonesDir = join(gsdDir, "milestones", "M001");
     mkdirSync(milestonesDir, { recursive: true });
 
     const stateMd = join(gsdDir, "STATE.md");
-    const autoLock = join(gsdDir, "auto.lock");
     const metaJson = join(milestonesDir, "M001-META.json");
 
     writeFileSync(stateMd, "# State\nactive\n");
-    writeFileSync(
-      autoLock,
-      JSON.stringify({ pid: process.pid, unitType: "plan-milestone", unitId: "M001" }),
-    );
     writeFileSync(metaJson, JSON.stringify({ milestoneId: "M001" }));
 
     assert.ok(existsSync(stateMd), "STATE.md exists before teardown");
-    assert.ok(existsSync(autoLock), "auto.lock exists before teardown");
     assert.ok(existsSync(metaJson), "M001-META.json exists before teardown");
 
     // teardownAutoWorktree may throw when git worktree removal fails
@@ -83,7 +80,6 @@ describe("teardownAutoWorktree cleanup parity", () => {
     }
 
     assert.ok(!existsSync(stateMd), "STATE.md removed by teardownAutoWorktree");
-    assert.ok(!existsSync(autoLock), "auto.lock removed by teardownAutoWorktree");
     assert.ok(!existsSync(metaJson), "M001-META.json removed by teardownAutoWorktree");
   });
 

package/src/resources/extensions/gsd/tests/unit-dispatches.test.ts

@@ -0,0 +1,247 @@
+// gsd-2 + Unit dispatch ledger tests (Phase B coordination — partial unique index, retry metadata)
+
+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,
+  insertSlice,
+} from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease } from "../db/milestone-leases.ts";
+import {
+  recordDispatchClaim,
+  markRunning,
+  markCompleted,
+  markFailed,
+  markStuck,
+  markCanceled,
+  getRecentForUnit,
+  getLatestForUnit,
+} from "../db/unit-dispatches.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-dispatches-"));
+  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 */ }
+}
+
+function setup(base: string): { workerId: string; leaseToken: number } {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice" });
+  const workerId = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) throw new Error("expected test lease");
+  return { workerId, leaseToken: lease.token };
+}
+
+test("recordDispatchClaim creates a claimed row", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const claim = recordDispatchClaim({
+    traceId: "trace-1",
+    turnId: "turn-1",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    sliceId: "S01",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(claim.ok, true);
+  if (claim.ok) {
+    const row = getLatestForUnit("M001/S01");
+    assert.ok(row);
+    assert.equal(row!.id, claim.dispatchId);
+    assert.equal(row!.status, "claimed");
+    assert.equal(row!.worker_id, workerId);
+    assert.equal(row!.attempt_n, 1);
+  }
+});
+
+test("partial unique index rejects double-claim of the same active unit", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "t-a",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+
+  // Second worker tries to claim the same unit while first is still claimed
+  const second = recordDispatchClaim({
+    traceId: "t-b",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(second.ok, false);
+  if (!second.ok) {
+    assert.equal(second.error, "already_active");
+    assert.equal(second.existingWorker, workerId);
+  }
+});
+
+test("after markCompleted, a fresh claim for the same unit succeeds", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const first = recordDispatchClaim({
+    traceId: "t-1",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(first.ok, true);
+  if (!first.ok) return;
+  markRunning(first.dispatchId);
+  markCompleted(first.dispatchId);
+
+  // Re-dispatch
+  const second = recordDispatchClaim({
+    traceId: "t-2",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+    attemptN: 2,
+  });
+  assert.equal(second.ok, true);
+  if (second.ok) {
+    const recent = getRecentForUnit("M001/S01", 5);
+    assert.equal(recent.length, 2);
+    assert.equal(recent[0].status, "claimed");
+    assert.equal(recent[0].attempt_n, 2);
+    assert.equal(recent[1].status, "completed");
+  }
+});
+
+test("markFailed records error_summary and retry metadata", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const claim = recordDispatchClaim({
+    traceId: "t-1",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+  markRunning(claim.dispatchId);
+  markFailed(claim.dispatchId, {
+    errorSummary: "boom",
+    errorCode: "test-fail",
+    retryAfterMs: 5000,
+  });
+
+  const row = getLatestForUnit("M001/S01")!;
+  assert.equal(row.status, "failed");
+  assert.equal(row.error_summary, "boom");
+  assert.equal(row.last_error_code, "test-fail");
+  assert.equal(row.retry_after_ms, 5000);
+  assert.ok(row.next_run_at, "next_run_at scheduled");
+});
+
+test("markStuck and markCanceled set their respective statuses", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const a = recordDispatchClaim({
+    traceId: "ta", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "plan-slice", unitId: "M001/S01",
+  });
+  assert.equal(a.ok, true);
+  if (!a.ok) return;
+  markStuck(a.dispatchId, "test-stuck");
+  assert.equal(getLatestForUnit("M001/S01")!.status, "stuck");
+
+  const b = recordDispatchClaim({
+    traceId: "tb", workerId, milestoneLeaseToken: leaseToken,
+    milestoneId: "M001", unitType: "run-task", unitId: "M001/S01/T01",
+  });
+  assert.equal(b.ok, true);
+  if (!b.ok) return;
+  markCanceled(b.dispatchId, "user-cancel");
+  assert.equal(getLatestForUnit("M001/S01/T01")!.status, "canceled");
+});
+
+test("terminal transitions do not overwrite an already terminal dispatch", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  const { workerId, leaseToken } = setup(base);
+
+  const claim = recordDispatchClaim({
+    traceId: "t-terminal",
+    workerId,
+    milestoneLeaseToken: leaseToken,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S09",
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+
+  markRunning(claim.dispatchId);
+  markCompleted(claim.dispatchId, { exitReason: "done" });
+  markFailed(claim.dispatchId, { errorSummary: "late-failure" });
+  markStuck(claim.dispatchId, "late-stuck");
+
+  const row = getLatestForUnit("M001/S09")!;
+  assert.equal(row.status, "completed");
+  assert.equal(row.exit_reason, "done");
+  assert.equal(row.error_summary, null);
+});
+
+test("recordDispatchClaim rejects claims for missing leases before insert", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  setup(base);
+
+  const claim = recordDispatchClaim({
+    traceId: "t-stale-lease",
+    workerId: "missing-worker",
+    milestoneLeaseToken: 1,
+    milestoneId: "M001",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+  });
+
+  assert.deepEqual(claim, {
+    ok: false,
+    error: "stale_lease",
+    milestoneId: "M001",
+    workerId: "missing-worker",
+    milestoneLeaseToken: 1,
+  });
+});

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { deriveState, isValidationTerminal } from "../state.ts";
+import { deriveState, invalidateStateCache, isValidationTerminal } from "../state.ts";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact } from "../auto-artifact-paths.ts";
 import { verifyExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
 import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
@@ -24,6 +24,7 @@ function makeTmpBase(): string {
 }
 
 function cleanup(base: string): void {
+  invalidateStateCache();
   clearPathCache();
   clearParseCache();
   closeDatabase();
@@ -394,6 +395,45 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
+test("skip write immediately advances deriveState out of validating-milestone", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" } as any);
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" } as any);
+
+    writeContext(base, "M001");
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone.");
+
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
+
+    const before = await deriveState(base);
+    assert.equal(before.phase, "validating-milestone", "precondition: missing VALIDATION keeps phase in validation");
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state: before,
+      prefs: { phases: { skip_milestone_validation: true } },
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "skip");
+
+    const after = await deriveState(base);
+    assert.equal(
+      after.phase,
+      "completing-milestone",
+      "post-skip deriveState should see the new VALIDATION file without manual cache invalidation",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("dispatch rule ignores failure-path SUMMARY projection when DB milestone is not complete (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },

package/src/resources/extensions/gsd/tests/workspace.test.ts

@@ -60,11 +60,12 @@ describe("createWorkspace", () => {
   });
 
   test("follows symlinks — identityKey matches realpath of target", (t) => {
-    const linkPath = join(tmpdir(), `gsd-ws-link-${Date.now()}`);
-    symlinkSync(projectDir, linkPath);
+    const linkParent = mkdtempSync(join(tmpdir(), "gsd-ws-link-"));
+    const linkPath = join(linkParent, "project");
     t.after(() => {
-      try { rmSync(linkPath); } catch { /* ignore */ }
+      rmSync(linkParent, { recursive: true, force: true });
     });
+    symlinkSync(projectDir, linkPath, "junction");
 
     const ws = createWorkspace(linkPath);
     assert.equal(ws.identityKey, realpathSync(projectDir));
@@ -146,18 +147,23 @@ describe("scopeMilestone path methods", () => {
 });
 
 describe("createWorkspace: contract.projectGsd is realpath-canonicalized when basePath is a symlink", () => {
-  let projectDir: string;
-  let linkPath: string;
+  let projectDir = "";
+  let linkParent = "";
+  let linkPath = "";
 
   beforeEach(() => {
     projectDir = makeProjectDir();
-    linkPath = join(tmpdir(), `gsd-ws-symlink-${Date.now()}`);
-    symlinkSync(projectDir, linkPath);
+    linkParent = mkdtempSync(join(tmpdir(), "gsd-ws-symlink-"));
+    linkPath = join(linkParent, "project");
+    symlinkSync(projectDir, linkPath, "junction");
   });
 
   afterEach(() => {
-    try { rmSync(linkPath); } catch { /* ignore */ }
-    rmSync(projectDir, { recursive: true, force: true });
+    if (linkParent) rmSync(linkParent, { recursive: true, force: true });
+    if (projectDir) rmSync(projectDir, { recursive: true, force: true });
+    linkParent = "";
+    linkPath = "";
+    projectDir = "";
   });
 
   test("contract.projectGsd matches realpath of projectRoot when workspace is created via symlink", () => {

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -299,31 +299,39 @@ test('write-gate: deep root PROJECT/REQUIREMENTS final saves require verified ap
 });
 
 test('write-gate: reopening a gate revokes its previous verified approval', () => {
-  clearDiscussionFlowState(process.cwd());
+  const base = join(tmpdir(), `gsd-write-gate-reopen-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
 
-  markApprovalGateVerified('depth_verification_project_confirm');
-  assert.strictEqual(
-    shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(process.cwd()),
-      'PROJECT',
-      { requireVerifiedApproval: true },
-    ).block,
-    false,
-    'precondition: verified approval unlocks the final project artifact',
-  );
-
-  setPendingGate('depth_verification_project_confirm', process.cwd());
-  clearPendingGate(process.cwd());
+  try {
+    clearDiscussionFlowState(base);
 
-  assert.strictEqual(
-    shouldBlockRootArtifactSaveInSnapshot(
-      loadWriteGateSnapshot(process.cwd()),
-      'PROJECT',
-      { requireVerifiedApproval: true },
-    ).block,
-    true,
-    'a re-asked gate must require a fresh approval',
-  );
+    markApprovalGateVerified('depth_verification_project_confirm', base);
+    assert.strictEqual(
+      shouldBlockRootArtifactSaveInSnapshot(
+        loadWriteGateSnapshot(base),
+        'PROJECT',
+        { requireVerifiedApproval: true },
+      ).block,
+      false,
+      'precondition: verified approval unlocks the final project artifact',
+    );
+
+    setPendingGate('depth_verification_project_confirm', base);
+    clearPendingGate(base);
+
+    assert.strictEqual(
+      shouldBlockRootArtifactSaveInSnapshot(
+        loadWriteGateSnapshot(base),
+        'PROJECT',
+        { requireVerifiedApproval: true },
+      ).block,
+      true,
+      'a re-asked gate must require a fresh approval',
+    );
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 // ═══════════════════════════════════════════════════════════════════════