gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -1,73 +1,156 @@
 /**
- * Regression test for #3580 — complete-slice verification gate
+ * Behavioural regression test for #3580 — complete-slice verification gate.
  *
- * Without the gate, a prompt regression could silently advance a blocked
- * or failed slice to "complete" status. The fix adds a BLOCKED_SIGNALS
- * regex that rejects completion when verification/UAT content clearly
- * indicates blocked or failed state.
+ * The gate must reject completion when the verification or UAT content
+ * indicates a blocked or failed slice. Drives the real handler with
+ * blocked-signal fixtures and asserts on the returned error. Replaces an
+ * earlier test file that only string-matched the BLOCKED_SIGNALS regex
+ * literal in the source (Refs #4826/#4831).
  */
 
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { extractSourceRegion } from "./test-helpers.ts";
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'tools', 'complete-slice.ts'),
-  'utf-8',
-)
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from '../gsd-db.ts';
+import { handleCompleteSlice } from '../tools/complete-slice.ts';
+import type { CompleteSliceParams } from '../types.ts';
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-blocked-gate-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanupDb(dbPath: string): void {
+  closeDatabase();
+  try { fs.rmSync(path.dirname(dbPath), { recursive: true, force: true }); } catch { /* */ }
+}
+
+function makeProject(): string {
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-gate-proj-'));
+  fs.mkdirSync(path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+  fs.writeFileSync(
+    path.join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md'),
+    `# M001\n\n## Slices\n- [ ] **S01: Test** \`risk:low\` \`depends:[]\`\n  - After this: works\n`,
+  );
+  return basePath;
+}
+
+function makeParams(overrides: Partial<CompleteSliceParams>): CompleteSliceParams {
+  return {
+    sliceId: 'S01',
+    milestoneId: 'M001',
+    sliceTitle: 'Test Slice',
+    oneLiner: 'one liner',
+    narrative: 'narrative',
+    verification: 'all green',
+    deviations: 'None.',
+    knownLimitations: 'None.',
+    followUps: 'None.',
+    keyFiles: [],
+    keyDecisions: [],
+    patternsEstablished: [],
+    observabilitySurfaces: [],
+    provides: [],
+    requirementsSurfaced: [],
+    drillDownPaths: [],
+    affects: [],
+    requirementsAdvanced: [],
+    requirementsValidated: [],
+    requirementsInvalidated: [],
+    filesModified: [],
+    requires: [],
+    uatContent: 'UAT body.',
+    ...overrides,
+  };
+}
 
 describe('complete-slice verification gate (#3580)', () => {
-  it('BLOCKED_SIGNALS regex is defined', () => {
-    assert.ok(
-      src.includes('BLOCKED_SIGNALS'),
-      'BLOCKED_SIGNALS constant must be defined in complete-slice.ts',
-    )
-  })
+  let dbPath: string;
+  let basePath: string;
+
+  beforeEach(() => {
+    dbPath = tempDbPath();
+    openDatabase(dbPath);
+    basePath = makeProject();
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'T1' });
+  });
 
-  it('BLOCKED_SIGNALS is a regex that tests verification content', () => {
-    // Extract the BLOCKED_SIGNALS definition line
-    const idx = src.indexOf('BLOCKED_SIGNALS')
-    assert.ok(idx !== -1)
-    const lineEnd = src.indexOf(';', idx)
-    const definition = src.slice(idx, lineEnd)
+  afterEach(() => {
+    cleanupDb(dbPath);
+    try { fs.rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
+  });
 
-    // Must be a regex (starts with /)
-    assert.ok(
-      definition.includes('= /'),
-      'BLOCKED_SIGNALS must be assigned a regex literal',
-    )
+  test('rejects when verification text contains "verification failed"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'verification failed: the regression came back' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    // Must match key blocked/failed signals
-    assert.ok(definition.includes('blocked'), 'regex must match "blocked" signals')
-    assert.ok(definition.includes('failed'), 'regex must match "failed" signals')
-  })
+  test('rejects when uatContent contains "verification_result: failed"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: '## Result\nverification_result: failed\n' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-  it('gate checks params.verification and params.uatContent', () => {
-    // Find usage of BLOCKED_SIGNALS.test
-    const testCalls = src.match(/BLOCKED_SIGNALS\.test\([^)]+\)/g)
-    assert.ok(testCalls, 'BLOCKED_SIGNALS.test() must be called')
-    assert.ok(testCalls.length >= 2, 'must check at least verification and uatContent')
+  test('rejects when verification declares "status: blocked"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'status: blocked — db unavailable' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    const joined = testCalls.join(' ')
-    assert.ok(joined.includes('verification'), 'must test params.verification')
-    assert.ok(joined.includes('uatContent'), 'must test params.uatContent')
-  })
+  test('rejects when uatContent says "slice is blocked"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: 'slice is blocked on upstream' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-  it('gate returns an error message when blocked signals detected', () => {
-    // Find the return statement after BLOCKED_SIGNALS check
-    const gateIdx = src.indexOf('BLOCKED_SIGNALS.test(')
-    assert.ok(gateIdx !== -1)
+  test('rejects when verification says "cannot complete"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'cannot complete: requirements unmet' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    const afterGate = extractSourceRegion(src, 'BLOCKED_SIGNALS.test(')
-    assert.ok(
-      afterGate.includes('return { error:'),
-      'blocked signal detection must return an error',
-    )
-    assert.ok(
-      afterGate.includes('do not complete'),
-      'error message must explain why completion is rejected',
-    )
-  })
-})
+  test('passes the gate when verification + uatContent are clean', async () => {
+    // Sanity: the gate is not over-eager. Clean inputs reach the rest of
+    // the handler. (This call may still fail downstream because we provide
+    // a thin fixture; the only guarantee here is that the error — if any —
+    // is NOT the blocked-signals error.)
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'all 8 sections pass', uatContent: 'green across the board' }),
+      basePath,
+    );
+    if ('error' in result) {
+      assert.doesNotMatch(
+        result.error,
+        /blocked\/failed state — do not complete/,
+        `clean inputs should not be rejected by the BLOCKED_SIGNALS gate, got: ${result.error}`,
+      );
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -13,6 +13,7 @@ import {
   getSlice,
   updateSliceStatus,
   getSliceTasks,
+  SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteSlice } from '../tools/complete-slice.ts';
 import type { CompleteSliceParams } from '../types.ts';
@@ -115,19 +116,21 @@ Run the test suite and verify all assertions pass.
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-slice: Schema v6 migration
+// complete-slice: fresh DB migrates to current schema version
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-slice: schema v6 migration ===');
+console.log('\n=== complete-slice: fresh DB migrates to current schema version ===');
 {
   const dbPath = tempDbPath();
   openDatabase(dbPath);
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v22 — quality_gates DDL fix)
+  // Pin schema version against the source-of-truth constant so this test
+  // survives migration bumps but still catches a "fresh DB was not migrated"
+  // regression.
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 22, 'schema version should be 22');
+  assertEq(versionRow?.['v'], SCHEMA_VERSION, 'fresh DB should be migrated to current SCHEMA_VERSION');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

package/src/resources/extensions/gsd/tests/completed-at-reconcile.test.ts

@@ -1,42 +1,99 @@
 /**
- * Regression test for #4129: tasks.completed_at stays NULL when status is
- * reconciled to 'complete' via the file-existence path in state.ts.
+ * Behavioural regression test for #4129.
  *
- * Root cause: reconcileSliceTasks called
- *   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
- * without a completedAt timestamp, so the column stays NULL.
+ * When deriveStateFromDb's reconcileSliceTasks finds a SUMMARY.md on disk
+ * for a task whose DB row is still pending, it flips the row to "complete".
+ * Before #4129, the call to updateTaskStatus omitted the completedAt
+ * timestamp, leaving completed_at NULL forever.
  *
- * Fix: pass new Date().toISOString() as the 5th argument.
+ * The fix passes new Date().toISOString() as the 5th argument; this test
+ * exercises that path end-to-end and asserts the column is populated.
+ *
+ * Refs #4829 (rewrite from positional source-grep).
  */
 
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
-
-describe("completed-at reconcile (#4129)", () => {
-  test("reconcileSliceTasks passes a completedAt timestamp when setting status to complete", () => {
-    // Before the fix, state.ts had:
-    //   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
-    // which leaves completed_at NULL in the DB.
-    // After the fix, a timestamp must be passed as the 5th argument.
-    assert.doesNotMatch(
-      stateSource,
-      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*\)/,
-      "updateTaskStatus must not be called without a completedAt timestamp when reconciling tasks to 'complete' (#4129)",
-    );
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+} from '../gsd-db.ts';
+
+let basePath: string;
+
+function setupProject(): void {
+  basePath = mkdtempSync(join(tmpdir(), 'gsd-completed-at-'));
+  // Project structure with active milestone, one slice, one task whose
+  // SUMMARY.md is already on disk — but the DB row is still "pending".
+  mkdirSync(join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+
+  // CONTEXT + ROADMAP so deriveState identifies M001 as active and S01 as the active slice.
+  writeFileSync(
+    join(basePath, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'),
+    '# M001\nActive milestone.\n',
+  );
+  writeFileSync(
+    join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md'),
+    `# M001\n\n## Slices\n\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  - After this: works\n`,
+  );
+
+  // Plan file for the slice so reconcile can populate task list if DB is empty.
+  writeFileSync(
+    join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md'),
+    `# S01: Slice\n\n## Tasks\n\n- [ ] **T01: Test task** \`est:30m\`\n  - Do: x\n  - Verify: y\n`,
+  );
+
+  // The summary file: this is the on-disk evidence that flips the task
+  // status to "complete" inside reconcileSliceTasks.
+  writeFileSync(
+    join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md'),
+    '---\nid: T01\nparent: S01\nmilestone: M001\nblocker_discovered: false\n---\n# T01\n',
+  );
+}
+
+describe('completed_at reconcile (#4129)', () => {
+  beforeEach(() => {
+    setupProject();
+    openDatabase(join(basePath, '.gsd', 'gsd.db'));
+    insertMilestone({ id: 'M001', title: 'M001', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'active' });
+    // Task is "pending" in DB, but SUMMARY.md exists on disk → reconcile flips it.
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
+    invalidateStateCache();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    try { rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
   });
 
-  test("reconcileSliceTasks passes new Date().toISOString() as the completedAt argument", () => {
-    // Positive assertion: the fixed call must include a timestamp.
-    assert.match(
-      stateSource,
-      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*,\s*new Date\(\)\.toISOString\(\)\s*\)/,
-      "reconcileSliceTasks must pass new Date().toISOString() as completedAt when setting task status to 'complete' (#4129)",
+  test('reconcileSliceTasks sets completed_at when flipping a pending task to complete via SUMMARY.md', async () => {
+    const before = getTask('M001', 'S01', 'T01');
+    assert.strictEqual(before?.status, 'pending', 'task starts pending');
+    assert.strictEqual(before?.completed_at, null, 'task starts with completed_at NULL');
+
+    // Trigger the reconcile path (state.ts → reconcileSliceTasks).
+    await deriveStateFromDb(basePath);
+
+    const after = getTask('M001', 'S01', 'T01');
+    assert.strictEqual(after?.status, 'complete', 'task should be flipped to complete');
+    assert.ok(
+      typeof after?.completed_at === 'string' && after.completed_at.length > 0,
+      `completed_at must be populated by reconcileSliceTasks (#4129); got ${JSON.stringify(after?.completed_at)}`,
+    );
+    // Sanity: timestamp parses as a valid ISO date.
+    assert.ok(
+      !Number.isNaN(Date.parse(after!.completed_at!)),
+      `completed_at should be a valid ISO timestamp, got ${after!.completed_at}`,
     );
   });
 });

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -12,7 +12,7 @@ import { mkdtempSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { autoLoop, resolveAgentEnd, _resetPendingResolve } from "../auto-loop.js";
+import { autoLoop, resolveAgentEnd, _hasPendingResolveForTest, _resetPendingResolve } from "../auto-loop.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { writeGraph, readGraph, type WorkflowGraph, type GraphStep } from "../graph.ts";
@@ -29,6 +29,17 @@ function makeTmpDir(): string {
   return dir;
 }
 
+async function resolveNextAgentEnd(timeoutMs = 3_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!_hasPendingResolveForTest()) {
+    if (Date.now() > deadline) {
+      throw new Error("Timed out waiting for pending agent_end resolver");
+    }
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  resolveAgentEnd({ messages: [{ role: "assistant" }] });
+}
+
 afterEach(() => {
   _resetPendingResolve();
   for (const d of tmpDirs) {
@@ -276,19 +287,16 @@ describe("Custom engine loop integration", () => {
     // We need to resolve resolveAgentEnd for each step.
 
     // Step 1: step-a
-    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // Step 2: step-b
-    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // Step 3: step-c
-    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // After step-c completes, engine.reconcile marks it complete, then
     // next deriveState sees isComplete=true → stopAuto → loop exits
@@ -398,8 +406,7 @@ describe("Custom engine loop integration", () => {
 
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
-    await new Promise((r) => setTimeout(r, 80));
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     await loopPromise;
 
@@ -460,12 +467,10 @@ describe("Custom engine loop integration", () => {
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
     // Resolve step-a
-    await new Promise((r) => setTimeout(r, 80));
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // Resolve step-b
-    await new Promise((r) => setTimeout(r, 80));
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     await loopPromise;
 
@@ -514,7 +519,9 @@ describe("Custom engine loop integration", () => {
     });
 
     const resolver = setInterval(() => {
-      resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      if (_hasPendingResolveForTest()) {
+        resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      }
     }, 25);
     let timeout: NodeJS.Timeout | undefined;
     try {
@@ -569,7 +576,9 @@ describe("Custom engine loop integration", () => {
     });
     const deps1 = makeMockDeps();
     const resolver1 = setInterval(() => {
-      resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      if (_hasPendingResolveForTest()) {
+        resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      }
       if (pi1.calls.length >= 2) {
         s1.active = false;
       }
@@ -614,7 +623,9 @@ describe("Custom engine loop integration", () => {
       },
     });
     const resolver2 = setInterval(() => {
-      resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      if (_hasPendingResolveForTest()) {
+        resolveAgentEnd({ messages: [{ role: "assistant" }] });
+      }
     }, 25);
     let timeout2: NodeJS.Timeout | undefined;
     try {
@@ -640,7 +651,12 @@ describe("Custom engine loop integration", () => {
     assert.match(stopEntry ?? "", /requested retry 4 times without passing/);
   });
 
-  it("GRAPH.yaml step stays pending when session deactivates before reconcile", async () => {
+  it("two-step workflow drives both steps to complete and stops when isComplete fires", async () => {
+    // Note (#4831): renamed from "GRAPH.yaml step stays pending when session
+    // deactivates before reconcile" — the assertion body never proved the
+    // pending-on-deactivate claim and even comments that "the reconcile
+    // will still run for step-b". The behaviour this test actually pins is:
+    // both steps reconcile complete and stopAuto fires once isComplete.
     _resetPendingResolve();
 
     // Two-step workflow: a → b. We will complete step-a, then force a break
@@ -672,28 +688,30 @@ describe("Custom engine loop integration", () => {
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
     // Resolve step-a successfully
-    await new Promise((r) => setTimeout(r, 80));
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // Step-b enters runUnit — deactivate the session before resolving.
     // runUnit checks s.active after newSession and returns cancelled if false.
     // But since newSession resolves synchronously in our mock (before the
     // active check), the unit still runs. Instead, let's just cancel it.
-    await new Promise((r) => setTimeout(r, 80));
     // Resolve as cancelled to simulate a failed session
-    resolveAgentEnd({ messages: [{ role: "assistant" }] });
+    await resolveNextAgentEnd();
 
     // The reconcile will still run for step-b in this flow since
     // runUnitPhase returns "next" (not "break") for completed units.
     // After both steps complete, the engine detects isComplete and stops.
     await loopPromise;
 
-    // Verify step-a is complete
+    // Both steps reconcile complete; the renamed expectation pins that the
+    // engine drives the workflow through isComplete rather than leaving any
+    // step pending.
     const finalGraph = readGraph(runDir);
     const stepA = finalGraph.steps.find(s => s.id === "step-a");
+    const stepB = finalGraph.steps.find(s => s.id === "step-b");
     assert.equal(stepA?.status, "complete", "Step-a should be complete");
+    assert.equal(stepB?.status, "complete", "Step-b should be complete");
 
-    // Verify the loop stopped appropriately
+    // The loop must stop once isComplete fires.
     assert.ok(
       deps.callLog.some((e: string) => e.startsWith("stopAuto:")),
       "stopAuto should have been called",

package/src/resources/extensions/gsd/tests/db-path-worktree-symlink.test.ts

@@ -16,7 +16,6 @@
  * retrying can never succeed and causes cost spikes.
  */
 
-import { readFileSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createTestContext } from "./test-helpers.ts";
 
@@ -89,47 +88,8 @@ assertEq(
   "Non-worktree path is unchanged",
 );
 
-// ── Part 2: ensureDbOpen returns structured failure context ──────────────
-
-console.log("\n=== #2517 Part 2: ensureDbOpen structured diagnostics ===");
-
-const dynamicToolsSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "dynamic-tools.ts"),
-  "utf-8",
-);
-
-// ensureDbOpen should surface diagnostic context, not just boolean false
-// Check that the catch block logs error details via workflow-logger
-assertTrue(
-  dynamicToolsSrc.includes("ensureDbOpen failed") && dynamicToolsSrc.includes("logWarning"),
-  "ensureDbOpen catch block surfaces diagnostic information via logWarning instead of bare false (#2517)",
-);
-
-// ── Part 3: post-unit does NOT artifact-retry on db_unavailable ──────────
-
-console.log("\n=== #2517 Part 3: post-unit db_unavailable is infra-fatal ===");
-
-const postUnitSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto-post-unit.ts"),
-  "utf-8",
-);
-
-// The artifact retry block should check DB availability and skip retry
-// when the DB is unavailable (infra failure, not a missing artifact).
-assertTrue(
-  postUnitSrc.includes("db_unavailable") || postUnitSrc.includes("isDbAvailable"),
-  "post-unit artifact retry path checks DB availability to avoid retry loop (#2517)",
-);
-
-// Verify the retry block is guarded: when !isDbAvailable(), the code must
-// NOT return "retry". The pattern should be: if (!verified && !isDbAvailable()) { skip }
-// followed by else if (!verified) { ... return "retry" }
-const dbUnavailableGuard = postUnitSrc.match(
-  /!triggerArtifactVerified\s*&&\s*!isDbAvailable\(\)/,
-);
-assertTrue(
-  !!dbUnavailableGuard,
-  "The retry block explicitly guards against !isDbAvailable() before returning 'retry' (#2517)",
-);
+// Source-grep checks for ensureDbOpen diagnostics + post-unit retry guard
+// were removed (#4826) — the behavioural retry-loop tests live in
+// auto-post-unit.test.ts and exercise isDbAvailable() directly.
 
 report();

package/src/resources/extensions/gsd/tests/debug-logger.test.ts

@@ -167,9 +167,11 @@ test('auto-prunes old debug logs', () => {
   enableDebug(tmp);
 
   const files = readdirSync(debugDir).filter(f => f.startsWith('debug-') && f.endsWith('.log'));
-  // Should have at most MAX_DEBUG_LOGS (5) = 5 old + 1 new, but pruned to 5 total
-  // Actually: prunes to < 5 old, then creates 1 new = at most 5
-  assert.ok(files.length <= 6, `should have pruned old logs, got ${files.length}`);
+  // MAX_DEBUG_LOGS is 5 — enableDebug prunes to < 5 old and then creates 1 new,
+  // so the directory must hold at most 5 files in total. The previous
+  // assertion (<= 6) would have passed even with one stale log left behind
+  // (Refs #4831).
+  assert.ok(files.length <= 5, `should have pruned old logs to <= 5, got ${files.length}`);
 
   disableDebug();
 });