gsd-pi 2.78.0 → 2.78.1-dev.9d08d820b

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();
 });

package/src/resources/extensions/gsd/tests/deferred-milestone-dir-4996.test.ts

@@ -0,0 +1,116 @@
+// GSD Extension — Regression test for #4996: deferred milestone dir creation
+// Verifies that showHeadlessMilestoneCreation does not pre-create the milestone
+// directory before the discuss flow runs. The dir should only appear after a
+// writer (saveArtifactToDb / atomicWriteAsync) emits the first artifact.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, existsSync, rmSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { isReusableGhostMilestone } from "../state.ts";
+import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
+import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
+
+function getShowHeadlessBody(): string {
+  const source = readFileSync(GUIDED_FLOW_PATH, "utf-8");
+  const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
+  assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist in guided-flow.ts");
+  const nextExport = source.indexOf("\nexport ", fnStart + 1);
+  return source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
+}
+
+function makeBase(prefix = "gsd-deferred-dir-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+describe("showHeadlessMilestoneCreation source guard (#4996)", () => {
+  it("does not call mkdirSync in the headless milestone creation path", () => {
+    const body = getShowHeadlessBody();
+    assert.doesNotMatch(
+      body,
+      /\bmkdirSync\s*\(/,
+      "showHeadlessMilestoneCreation must not pre-create milestone directories",
+    );
+  });
+
+  it("does not call mkdir or mkdirp before dispatchWorkflow", () => {
+    const body = getShowHeadlessBody();
+    const dispatchIdx = body.indexOf("dispatchWorkflow");
+    assert.ok(dispatchIdx > -1, "dispatchWorkflow must be present");
+
+    const beforeDispatch = body.slice(0, dispatchIdx);
+    assert.doesNotMatch(
+      beforeDispatch,
+      /\b(?:mkdir|mkdirp)\s*\(/,
+      "showHeadlessMilestoneCreation must defer directory creation until artifact write",
+    );
+  });
+});
+
+describe("deferred milestone dir creation (#4996)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    clearReservedMilestoneIds();
+  });
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { invalidateAllCaches(); } catch { /* ignore */ }
+    try { clearReservedMilestoneIds(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("(a) fresh project: milestones dir has no M001 entry before any discuss flow", () => {
+    base = makeBase();
+    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    assert.equal(nextId, "M001", "reservation should choose M001 for a fresh project");
+
+    const ids = findMilestoneIds(base);
+    assert.equal(ids.length, 0, "no milestone dirs should exist before any discuss flow");
+
+    // And specifically M001 should not exist
+    const m001Dir = join(base, ".gsd", "milestones", "M001");
+    assert.ok(!existsSync(m001Dir), "M001 dir must not exist before the discuss flow runs");
+  });
+
+  it("(b) abandoned discuss flow leaves no orphan: isReusableGhostMilestone returns false for non-existent dir", () => {
+    base = makeBase();
+    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    assert.equal(nextId, "M001", "reservation should not require a pre-created directory");
+
+    const m001Dir = join(base, ".gsd", "milestones", "M001");
+    assert.ok(!existsSync(m001Dir), "no M001 dir should exist");
+    assert.equal(isReusableGhostMilestone(base, "M001"), false, "non-existent milestone should not be reusable");
+    // findMilestoneIds only returns dirs that exist
+    const ids = findMilestoneIds(base);
+    assert.ok(!ids.includes("M001"), "M001 should not appear in findMilestoneIds when no dir exists");
+  });
+
+  it("(c) a stub dir left from a previous bug IS reusable but a newly-generated ID with no dir is not in the ghost list", () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    // Create a stub to represent a pre-existing phantom
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices"), { recursive: true });
+
+    // isReusableGhostMilestone identifies the orphaned stub
+    assert.ok(isReusableGhostMilestone(base, "M001"), "pre-existing stub should be identified as reusable ghost");
+    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
+    assert.equal(nextId, "M001", "reservation should reuse the pre-existing ghost");
+
+    // The new ID (M002, which would be max+1 in this scenario but ghost reuse returns M001)
+    // should not have a dir
+    const m002Dir = join(base, ".gsd", "milestones", "M002");
+    assert.ok(!existsSync(m002Dir), "a freshly-requested ID should have no dir until first artifact write");
+  });
+});