gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

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

@@ -15,6 +15,7 @@ import {
   type SkillsPolicy,
   type UnitContextManifest,
 } from "../unit-context-manifest.ts";
+import { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../bootstrap/write-gate.ts";
 
 // ─── Coverage: every known unit type has a manifest ──────────────────────
 
@@ -199,8 +200,8 @@ test("#4934: every manifest declares a tools policy", () => {
   }
 });
 
-test("#4934: tools.mode is one of the four declared policies", () => {
-  const validModes = new Set(["all", "read-only", "planning", "docs"]);
+test("#4934: tools.mode is one of the declared policies", () => {
+  const validModes = new Set(["all", "read-only", "planning", "planning-dispatch", "docs"]);
   for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
     const mode = (manifest as { tools: { mode: string } }).tools.mode;
     assert.ok(
@@ -219,7 +220,51 @@ test('#4934: only execute-task and reactive-execute may use tools.mode "all" (fu
         allowedAllUnits.has(unitType),
         `manifest "${unitType}" declares tools.mode = "all" but is not on the execute-track. ` +
         'Only execute-task and reactive-execute should have full source write access; ' +
-        'planning/discuss/research units must use "planning" (or "docs" for rewrite-docs).',
+        'planning/discuss/research units must use "planning" or "planning-dispatch" (or "docs" for rewrite-docs).',
+      );
+    }
+  }
+});
+
+test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
+  const allowedDispatchUnits = new Set([
+    "plan-slice",
+    "refine-slice",
+    "complete-slice",
+    "complete-milestone",
+    // Deep planning mode: research-project orchestrates 4 parallel research
+    // subagents (stack/features/architecture/pitfalls). Subagent dispatch is
+    // the unit's core mechanism — without it, the unit cannot do its job.
+    "research-project",
+    "validate-milestone",
+  ]);
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    const mode = (manifest as { tools: { mode: string } }).tools.mode;
+    if (mode === "planning-dispatch") {
+      assert.ok(
+        allowedDispatchUnits.has(unitType),
+        `manifest "${unitType}" declares tools.mode = "planning-dispatch" but is not on the dispatch-allowed allowlist. ` +
+        'planning-dispatch is intentionally narrow — extend the allowlist consciously when a new unit type genuinely benefits from subagent delegation.',
+      );
+    }
+  }
+});
+
+test('planning-dispatch manifests declare non-empty allowedSubagents lists', () => {
+  for (const [unitType, manifest] of Object.entries(UNIT_MANIFESTS)) {
+    if (manifest.tools.mode !== "planning-dispatch") continue;
+    assert.ok(
+      Array.isArray(manifest.tools.allowedSubagents) && manifest.tools.allowedSubagents.length > 0,
+      `manifest "${unitType}" has planning-dispatch policy but no allowedSubagents — explicit allowlist is required for runtime dispatch gating`,
+    );
+    for (const agent of manifest.tools.allowedSubagents) {
+      assert.ok(
+        typeof agent === "string" && agent.length > 0,
+        `manifest "${unitType}" has empty/invalid allowedSubagents entry: ${JSON.stringify(agent)}`,
+      );
+      assert.ok(
+        ALLOWED_PLANNING_DISPATCH_AGENTS.has(agent),
+        `manifest "${unitType}" allows "${agent}", but the runtime planning-dispatch registry will hard-block it`,
       );
     }
   }

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

@@ -253,5 +253,46 @@ console.log("\n=== must-haves: substring matching (no backtick tokens) ===");
   assert.ok(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
 }
 
+console.log("\n=== per-record lock: stale .lock is reclaimed, list ignores .lock files ===");
+{
+  const { utimesSync, existsSync: lockExists } = await import("node:fs");
+  const { listUnitRuntimeRecords } = await import("../unit-runtime.ts");
+
+  // (1) Stale .lock should not block a new writer.
+  const lockBase = mkdtempSync(join(tmpdir(), "gsd-runtime-lock-test-"));
+  try {
+    const unitsDir = join(lockBase, ".gsd", "runtime", "units");
+    mkdirSync(unitsDir, { recursive: true });
+    const recordPath = join(unitsDir, "execute-task-M001-S01-T01.json");
+    const lockPath = recordPath + ".lock";
+    writeFileSync(lockPath, "");
+    const staleTime = new Date(Date.now() - 60_000);
+    utimesSync(lockPath, staleTime, staleTime);
+
+    const written = writeUnitRuntimeRecord(lockBase, "execute-task", "M001/S01/T01", 1000, { phase: "dispatched" });
+    assert.deepStrictEqual(written.phase, "dispatched", "stale-lock path should not block writers");
+
+    const readBack = readUnitRuntimeRecord(lockBase, "execute-task", "M001/S01/T01");
+    assert.ok(readBack !== null, "record persisted after stealing stale lock");
+    assert.equal(lockExists(lockPath), false, "lock file released after write completes");
+  } finally {
+    rmSync(lockBase, { recursive: true, force: true });
+  }
+
+  // (2) Orphaned .lock files must not be returned by listUnitRuntimeRecords.
+  const listBase = mkdtempSync(join(tmpdir(), "gsd-runtime-list-test-"));
+  try {
+    writeUnitRuntimeRecord(listBase, "execute-task", "M002/S01/T01", 1000, { phase: "dispatched" });
+    const unitsDir = join(listBase, ".gsd", "runtime", "units");
+    writeFileSync(join(unitsDir, "execute-task-M002-S01-T01.json.lock"), "");
+
+    const records = listUnitRuntimeRecords(listBase);
+    assert.equal(records.length, 1, "listUnitRuntimeRecords filters .lock files (only the .json record)");
+    assert.equal(records[0].unitId, "M002/S01/T01");
+  } finally {
+    rmSync(listBase, { recursive: true, force: true });
+  }
+}
+
 rmSync(mhBase, { recursive: true, force: true });
 rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -76,13 +76,11 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  test("only one return null at the end", () => {
-    const returnNulls = fnBody.match(/return null;/g);
-    assert.ok(
-      returnNulls && returnNulls.length === 1,
-      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
-    );
-  });
+  // Removed: source-grep count of `return null;` occurrences. The behaviour
+  // we care about ("function returns null only when no auto-dispatch /
+  // guided-resume / fallback path matches") is exercised by the behavioural
+  // tests below — counting literal `return null;` tokens encodes statement
+  // shape, not contract. Refs #4851.
 });
 
 // ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
-import { runTurnGitAction } from "../git-service.ts";
+import { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -83,3 +83,17 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("uok gitops turn action rethrows infrastructure failures", () => {
+  const err = Object.assign(new Error("ENFILE: file table overflow"), { code: "ENFILE" });
+
+  assert.throws(() => handleTurnGitActionError("commit", err), (thrown) => thrown === err);
+});
+
+test("uok gitops turn action keeps non-infrastructure git failures recoverable", () => {
+  const result = handleTurnGitActionError("commit", new Error("nothing to commit"));
+
+  assert.equal(result.action, "commit");
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "nothing to commit");
+});

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -16,6 +16,7 @@ import type { GSDState, Phase } from "../types.ts";
 import {
   ensurePlanV2Graph,
   hasFinalizedMilestoneContext,
+  isEmptyPlanV2GraphResult,
   isMissingFinalizedContextResult,
 } from "../uok/plan-v2.ts";
 
@@ -113,6 +114,30 @@ test("guided flow routes recoverable missing finalized context to discuss-milest
   );
 });
 
+test("guided flow checks pending deep setup before plan-v2 gate", () => {
+  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
+  const showSmartEntryIdx = source.indexOf("export async function showSmartEntry");
+  assert.notEqual(showSmartEntryIdx, -1);
+  const deepIdx = source.indexOf("hasPendingDeepStage(prefs, basePath)", showSmartEntryIdx);
+  const planIdx = source.indexOf("runPlanV2Gate(ctx, basePath, state)", showSmartEntryIdx);
+  assert.ok(
+    deepIdx > -1 && planIdx > -1 && deepIdx < planIdx,
+    "foreground deep setup must run before plan-v2 can fail-close guided /gsd",
+  );
+  assert.ok(
+    source.includes("loadEffectiveGSDPreferences(basePath)?.preferences"),
+    "guided plan-v2 gate must load preferences from the target project root",
+  );
+});
+
+test("auto pre-dispatch uses resolved plan-v2 defaults", () => {
+  const source = readFileSync(join(gsdDir, "auto", "phases.ts"), "utf-8");
+  assert.ok(
+    source.includes("uokFlags.planV2 && shouldRunPlanV2Gate(state.phase)"),
+    "auto-mode should honor resolveUokFlags defaults, not only explicit uok.plan_v2.enabled",
+  );
+});
+
 test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {
   const basePath = createBasePath();
   seedGraphRows();
@@ -204,4 +229,27 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
   assert.equal(compiled.ok, false);
   assert.match(compiled.reason ?? "", /compiled graph is empty/i);
+  assert.equal(isEmptyPlanV2GraphResult(compiled), true);
+});
+
+test("plan-v2 allows empty graph for milestone terminal phases", () => {
+  const basePath = createBasePath();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  insertSlice({
+    id: SLICE_ID,
+    milestoneId: MILESTONE_ID,
+    title: "Slice",
+    status: "complete",
+    sequence: 1,
+  });
+
+  const validating = ensurePlanV2Graph(basePath, buildState("validating-milestone"));
+  assert.equal(validating.ok, true);
+  assert.equal(validating.nodeCount, 0);
+
+  const completing = ensurePlanV2Graph(basePath, buildState("completing-milestone"));
+  assert.equal(completing.ok, true);
+  assert.equal(completing.nodeCount, 0);
 });

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

@@ -85,7 +85,7 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     assert.doesNotMatch(validationMd, /## Verification Class Compliance/);
   });
 
-  it("rolls back DB row when disk write fails", async () => {
+  it("keeps DB row and reports stale projection when disk write fails", async () => {
     base = makeTmpBase();
     const dbPath = join(base, ".gsd", "gsd.db");
     openDatabase(dbPath);
@@ -101,16 +101,15 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
 
     const result = await handleValidateMilestone(VALID_PARAMS, base);
 
-    // Should return error
-    assert.ok("error" in result, "should return error when disk write fails");
-    assert.ok(result.error.includes("disk render failed"));
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+    assert.equal(result.stale, true, "result should report stale projection");
 
-    // DB row should have been rolled back (deleted)
     const adapter = _getAdapter()!;
     const row = adapter.prepare(
-      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
-    ).get();
-    assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
+      `SELECT status FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string } | undefined;
+    assert.ok(row, "assessment row should remain committed");
+    assert.equal(row!.status, "pass");
   });
 
   it("persists milestone validation gate_runs rows when UOK gates are enabled", async () => {

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

@@ -394,7 +394,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   }
 });
 
-test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is not complete (#4658)", async () => {
+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" },
     activeSlice: null,
@@ -422,17 +422,14 @@ test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is n
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /failure-path SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async () => {
+test("dispatch rule does not reconcile DB from successful stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -473,15 +470,15 @@ test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async (
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "skip");
+    assert.equal(result.action, "dispatch");
     const milestone = getMilestone("M001");
-    assert.equal(milestone?.status, "complete");
+    assert.equal(milestone?.status, "active");
   } finally {
     cleanup(base);
   }
 });
 
-test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async () => {
+test("dispatch rule ignores ambiguous stale SUMMARY projection (#4658 superseded)", async () => {
   const state: GSDState = {
     activeMilestone: { id: "M001", title: "Test" },
     activeSlice: null,
@@ -509,11 +506,8 @@ test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async ()
       prefs: undefined,
     };
     const result = await resolveDispatch(ctx);
-    assert.equal(result.action, "stop");
-    if (result.action === "stop") {
-      assert.equal(result.level, "warning");
-      assert.match(result.reason, /ambiguous SUMMARY/i);
-    }
+    assert.equal(result.action, "dispatch");
+    assert.equal(getMilestone("M001")?.status, "active");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/validator-scope-parity.test.ts

@@ -0,0 +1,239 @@
+// GSD-2 + Tests verifying writer/validator path parity via MilestoneScope (C3)
+//
+// Critical invariant: a writer that constructs paths via scope.contextFile() /
+// scope.roadmapFile() and a validator that resolves paths via the scope-based
+// wrappers in guided-flow.ts must produce IDENTICAL absolute paths for the same
+// logical inputs.  If they diverge, writes go to a different location than the
+// validator checks, causing silent failures.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import {
+  verifyExpectedArtifactForScope,
+  resolveExpectedArtifactPathForScope,
+  isGhostMilestoneByScope,
+} from "../guided-flow.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(label = "gsd-vsp-"): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), label)));
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  return dir;
+}
+
+// ─── Suite: writer/validator path parity ─────────────────────────────────────
+
+describe("validator-scope-parity: writer and validator produce identical paths", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeProjectDir();
+  });
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("resolveExpectedArtifactPathForScope('discuss-milestone') matches scope.contextFile()", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    // Writer path: what the discuss/plan agent writes to
+    const writerPath = scope.contextFile();
+
+    // Validator path: what the validator checks
+    const validatorPath = resolveExpectedArtifactPathForScope(scope, "discuss-milestone", "M001");
+
+    assert.equal(
+      validatorPath,
+      writerPath,
+      "discuss-milestone artifact path must match scope.contextFile()",
+    );
+  });
+
+  test("resolveExpectedArtifactPathForScope('plan-milestone') matches scope.roadmapFile()", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    const writerPath = scope.roadmapFile();
+    const validatorPath = resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001");
+
+    assert.equal(
+      validatorPath,
+      writerPath,
+      "plan-milestone artifact path must match scope.roadmapFile()",
+    );
+  });
+
+  test("resolveExpectedArtifactPathForScope returns an absolute path", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    const path = resolveExpectedArtifactPathForScope(scope, "discuss-milestone", "M001");
+    assert.ok(path, "path must be non-null for a milestone unit");
+    assert.ok(path!.startsWith("/"), "path must be absolute");
+  });
+});
+
+// ─── Suite: cwd-drift immunity ────────────────────────────────────────────────
+
+describe("validator-scope-parity: scope-based validators are immune to cwd-drift", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeProjectDir();
+  });
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("resolveExpectedArtifactPathForScope path is unchanged after process.chdir", (t) => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    const pathBefore = resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001");
+
+    const originalCwd = process.cwd();
+    const altDir = mkdtempSync(join(tmpdir(), "gsd-cwd-alt-"));
+    t.after(() => {
+      process.chdir(originalCwd);
+      rmSync(altDir, { recursive: true, force: true });
+    });
+
+    process.chdir(altDir);
+
+    const pathAfter = resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001");
+
+    assert.equal(
+      pathAfter,
+      pathBefore,
+      "artifact path must not change after cwd drift",
+    );
+  });
+
+  test("isGhostMilestoneByScope result is consistent before and after process.chdir", (t) => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    // No DB, no content files — should be ghost
+    const resultBefore = isGhostMilestoneByScope(scope);
+
+    const originalCwd = process.cwd();
+    const altDir = mkdtempSync(join(tmpdir(), "gsd-cwd-alt2-"));
+    t.after(() => {
+      process.chdir(originalCwd);
+      rmSync(altDir, { recursive: true, force: true });
+    });
+
+    process.chdir(altDir);
+
+    const resultAfter = isGhostMilestoneByScope(scope);
+
+    assert.equal(
+      resultAfter,
+      resultBefore,
+      "isGhostMilestoneByScope result must be consistent across cwd change",
+    );
+  });
+});
+
+// ─── Suite: isGhostMilestoneByScope behavior ─────────────────────────────────
+
+describe("validator-scope-parity: isGhostMilestoneByScope correctness", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeProjectDir();
+  });
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("isGhostMilestoneByScope returns true for milestone dir with no content files", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    // M001 dir exists (created in beforeEach) but has no CONTEXT/ROADMAP/SUMMARY
+    assert.equal(
+      isGhostMilestoneByScope(scope),
+      true,
+      "empty milestone dir with no content files should be ghost",
+    );
+  });
+
+  test("isGhostMilestoneByScope returns false when CONTEXT.md exists", (t) => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    // Write CONTEXT.md so the milestone is no longer a ghost
+    writeFileSync(scope.contextFile(), "# M001: Test\n\nContext.\n");
+    t.after(() => {
+      try { unlinkSync(scope.contextFile()); } catch {}
+    });
+
+    assert.equal(
+      isGhostMilestoneByScope(scope),
+      false,
+      "milestone with CONTEXT.md should not be ghost",
+    );
+  });
+});
+
+// ─── Suite: worktree path resolves to canonical project root ─────────────────
+
+describe("validator-scope-parity: scope uses canonical projectRoot not worktree path", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeProjectDir("gsd-wt-parity-");
+  });
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+  });
+
+  test("scope.workspace.projectRoot equals the input base for a non-worktree project", () => {
+    const ws = createWorkspace(base);
+    // For a plain project (not a worktree), projectRoot should be the realpath of base
+    assert.equal(
+      ws.projectRoot,
+      realpathSync(base),
+      "projectRoot must be realpath of the input base for a non-worktree project",
+    );
+  });
+
+  test("validator wrapper paths are rooted at scope.workspace.projectRoot, not at a worktree dir", () => {
+    // Simulate calling with a workspace that has projectRoot set.
+    // The validator should use projectRoot, not a different runtime path.
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    const artifactPath = resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001");
+
+    assert.ok(
+      artifactPath!.startsWith(scope.workspace.projectRoot),
+      `artifact path '${artifactPath}' must be rooted at projectRoot '${scope.workspace.projectRoot}'`,
+    );
+  });
+
+  test("verifyExpectedArtifactForScope uses projectRoot: returns false for non-existent artifact", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    // The artifact does not exist on disk yet
+    const ready = verifyExpectedArtifactForScope(scope, "plan-milestone", "M001");
+    assert.equal(
+      ready,
+      false,
+      "verifyExpectedArtifactForScope should return false when artifact is absent",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -19,7 +19,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { verifyExpectedArtifact } from "../auto-recovery.ts";
-import { closeDatabase, isDbAvailable } from "../gsd-db.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
 /** Scaffold .gsd/milestones/M001/slices/S01/ with tasks/ and a T01-SUMMARY.md. */
 function scaffoldProject(t: { after: (fn: () => void) => void }): {
@@ -151,3 +151,54 @@ test("#3607: execute-task legacy branch — wrong task id in checkbox does not m
     "checkbox for a different task id must not count as T01 completion",
   );
 });
+
+test("execute-task DB lag branch — pending DB status can verify from checked plan plus summary", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  assert.equal(isDbAvailable(), true, "DB must be open to hit the DB-lag branch");
+
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Implement feature", status: "pending" });
+
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [x] **T01: Implement feature**",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    true,
+    "checked plan entry plus summary should verify while DB reconcile catches up",
+  );
+});
+
+test("execute-task DB lag branch — summary without checked plan still fails", (t) => {
+  closeDatabase();
+  const { base, planPath } = scaffoldProject(t);
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Implement feature", status: "pending" });
+
+  writeFileSync(
+    planPath,
+    [
+      "# S01 plan",
+      "",
+      "- [ ] **T01: Implement feature**",
+    ].join("\n"),
+  );
+
+  assert.equal(
+    verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+    false,
+    "pending DB status plus summary is insufficient without a checked task checkbox",
+  );
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -13,7 +13,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { GSDVisualizerOverlay } from "../visualizer-overlay.ts";
+import { GSDVisualizerOverlay, TAB_COUNT } from "../visualizer-overlay.ts";
 
 function makeTui() {
   const renders: number[] = [];
@@ -93,16 +93,16 @@ test("overlay switches tabs via 1–9,0 digit keys", (t) => {
 
 test("overlay Tab key cycles forward and wraps around at TAB_COUNT", (t) => {
   const { overlay } = makeOverlay(t);
-  overlay.activeTab = 9;
+  overlay.activeTab = TAB_COUNT - 1;
   overlay.handleInput("\t");
-  assert.equal(overlay.activeTab, 0, "Tab wraps from 9 back to 0");
+  assert.equal(overlay.activeTab, 0, `Tab wraps from ${TAB_COUNT - 1} back to 0`);
 });
 
 test("overlay Shift+Tab cycles backward and wraps", (t) => {
   const { overlay } = makeOverlay(t);
   overlay.activeTab = 0;
   overlay.handleInput("\u001b[Z");
-  assert.equal(overlay.activeTab, 9, "Shift+Tab wraps from 0 to 9");
+  assert.equal(overlay.activeTab, TAB_COUNT - 1, `Shift+Tab wraps from 0 to ${TAB_COUNT - 1}`);
 });
 
 // ─── Filter mode ─────────────────────────────────────────────────────────
@@ -331,9 +331,9 @@ test("overlay footer hint mentions tab navigation, filter, scroll, and help", (t
 
 // ─── Scroll offsets array is sized to TAB_COUNT ──────────────────────────
 
-test("overlay scrollOffsets array has one slot per tab (10 tabs total)", (t) => {
+test("overlay scrollOffsets array has one slot per tab", (t) => {
   const { overlay } = makeOverlay(t);
-  assert.equal(overlay.scrollOffsets.length, 10, "scrollOffsets sized to TAB_COUNT=10");
+  assert.equal(overlay.scrollOffsets.length, TAB_COUNT, "scrollOffsets sized to TAB_COUNT");
   assert.ok(overlay.scrollOffsets.every((n: number) => n === 0), "initialized to zero");
 });