gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.d0517ff

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Regression test for #3675 — isolation:none stale branch guard
+ *
+ * When switching from isolation:branch/worktree to isolation:none, HEAD
+ * could remain on a milestone/<MID> branch. The fix in auto-start.ts
+ * detects this and auto-checks out to the integration branch.
+ *
+ * This structural test verifies the milestone/ branch check exists
+ * in auto-start.ts.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'auto-start.ts'), 'utf-8');
+
+describe('isolation:none stale branch guard (#3675)', () => {
+  test('checks for milestone/ branch prefix', () => {
+    assert.match(source, /startsWith\(["']milestone\//,
+      'auto-start should check for milestone/ branch prefix');
+  });
+
+  test('imports nativeGetCurrentBranch', () => {
+    assert.match(source, /nativeGetCurrentBranch/,
+      'auto-start should import nativeGetCurrentBranch');
+  });
+
+  test('imports nativeDetectMainBranch', () => {
+    assert.match(source, /nativeDetectMainBranch/,
+      'auto-start should import nativeDetectMainBranch');
+  });
+
+  test('imports nativeCheckoutBranch', () => {
+    assert.match(source, /nativeCheckoutBranch/,
+      'auto-start should import nativeCheckoutBranch');
+  });
+
+  test('guard is conditional on isolation mode "none"', () => {
+    assert.match(source, /getIsolationMode\(\)\s*===\s*["']none["']/,
+      'guard should only activate when isolation mode is "none"');
+  });
+
+  test('calls nativeCheckoutBranch to return to integration branch', () => {
+    assert.match(source, /nativeCheckoutBranch\(base,\s*integrationBranch\)/,
+      'should checkout to the integration branch');
+  });
+
+  test('guard is wrapped in try-catch (non-fatal)', () => {
+    // Find the milestone/ check and verify it is inside a try block
+    const milestoneIdx = source.indexOf('startsWith("milestone/")');
+    assert.ok(milestoneIdx > 0, 'milestone/ check should exist');
+    const before = source.slice(Math.max(0, milestoneIdx - 500), milestoneIdx);
+    assert.match(before, /try\s*\{/,
+      'milestone branch guard should be inside a try block');
+  });
+});

package/src/resources/extensions/gsd/tests/needs-remediation-revalidation.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Regression test for #3670 — needs-remediation verdict forces re-validation
+ *
+ * When validation returns needs-remediation, the state machine must route
+ * back to validating-milestone instead of completing-milestone. Without this,
+ * dispatch blocks completion for needs-remediation while state derives
+ * completing-milestone, creating a permanent deadlock.
+ *
+ * This structural test verifies the verdict === 'needs-remediation' guard
+ * exists at all three derivation paths in state.ts.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+
+describe('needs-remediation revalidation guard (#3670)', () => {
+  test('verdict === needs-remediation guard exists in state.ts', () => {
+    const matches = source.match(/verdict\s*===\s*['"]needs-remediation['"]/g);
+    assert.ok(matches, 'verdict === "needs-remediation" check must exist in state.ts');
+    assert.ok(matches.length >= 2,
+      `Expected at least 2 needs-remediation guards (deriveStateFromDb + _deriveStateImpl), found ${matches.length}`);
+  });
+
+  test('needsRevalidation variable is derived from verdict', () => {
+    assert.match(source, /needsRevalidation.*=.*verdict\s*===\s*['"]needs-remediation['"]/,
+      'needsRevalidation should incorporate verdict === "needs-remediation"');
+  });
+
+  test('deriveStateFromDb path uses needs-remediation guard', () => {
+    assert.match(source, /!validationTerminal\s*\|\|\s*verdict\s*===\s*['"]needs-remediation['"]/,
+      'deriveStateFromDb should check !validationTerminal || verdict === "needs-remediation"');
+  });
+
+  test('extractVerdict is called on validation content', () => {
+    const extractCalls = source.match(/extractVerdict\(validationContent\)/g);
+    assert.ok(extractCalls, 'extractVerdict should be called on validation content');
+    assert.ok(extractCalls.length >= 2,
+      `Expected at least 2 extractVerdict calls, found ${extractCalls.length}`);
+  });
+});

package/src/resources/extensions/gsd/tests/note-captures-executed.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Regression test for #3578 — note captures marked as executed
+ *
+ * Note-classified captures were stuck in "resolved but not executed" limbo
+ * because executeTriageResolutions only handled inject/replan/defer. The fix
+ * adds a filter for classification === "note" and calls markCaptureExecuted
+ * for each matching capture.
+ *
+ * Structural verification test — reads source to confirm the note filter
+ * and markCaptureExecuted call exist.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'triage-resolution.ts'), 'utf-8');
+
+describe('note captures executed in triage resolution (#3578)', () => {
+  test('markCaptureExecuted is imported', () => {
+    assert.match(source, /markCaptureExecuted/,
+      'markCaptureExecuted should be imported');
+  });
+
+  test('note classification filter exists', () => {
+    assert.match(source, /classification\s*===\s*"note"/,
+      'filter should check classification === "note"');
+  });
+
+  test('note filter checks resolved status and not-executed', () => {
+    assert.match(source, /status\s*===\s*"resolved"\s*&&\s*!c\.executed\s*&&\s*c\.classification\s*===\s*"note"/,
+      'filter should check resolved + not-executed + note classification');
+  });
+
+  test('markCaptureExecuted is called for note captures', () => {
+    // The source should call markCaptureExecuted for note captures
+    const noteSection = source.slice(source.indexOf('classification === "note"'));
+    assert.match(noteSection, /markCaptureExecuted\(basePath,\s*cap\.id\)/,
+      'markCaptureExecuted should be called for note captures');
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Parallel research slices dispatch — structural tests.
+ *
+ * Verifies the dispatch rule and prompt builder exist with correct structure.
+ */
+
+import 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 dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+const templatePath = join(__dirname, "..", "prompts", "parallel-research-slices.md");
+const templateSrc = readFileSync(templatePath, "utf-8");
+
+// ─── Dispatch rule ────────────────────────────────────────────────────────
+
+test("dispatch: parallel-research-slices rule exists", () => {
+  assert.ok(
+    dispatchSrc.includes("parallel-research-slices"),
+    "dispatch table should have parallel-research-slices rule",
+  );
+});
+
+test("dispatch: parallel-research-slices requires 2+ slices", () => {
+  assert.ok(
+    dispatchSrc.includes("researchReadySlices.length < 2"),
+    "rule should require at least 2 slices for parallel dispatch",
+  );
+});
+
+test("dispatch: parallel-research-slices respects skip_research", () => {
+  const ruleIdx = dispatchSrc.indexOf("parallel-research-slices");
+  const ruleBlock = dispatchSrc.slice(ruleIdx, ruleIdx + 500);
+  assert.ok(
+    ruleBlock.includes("skip_research") || dispatchSrc.slice(ruleIdx - 300, ruleIdx).includes("skip_research"),
+    "rule should check skip_research preference",
+  );
+});
+
+// ─── Prompt builder ───────────────────────────────────────────────────────
+
+test("prompt: buildParallelResearchSlicesPrompt exported", () => {
+  assert.ok(
+    promptsSrc.includes("export async function buildParallelResearchSlicesPrompt"),
+    "buildParallelResearchSlicesPrompt should be exported",
+  );
+});
+
+test("prompt: builds per-slice subagent prompts", () => {
+  assert.ok(
+    promptsSrc.includes("buildResearchSlicePrompt"),
+    "parallel prompt builder should delegate to per-slice research prompts",
+  );
+});
+
+// ─── Template ─────────────────────────────────────────────────────────────
+
+test("template: parallel-research-slices.md has required variables", () => {
+  assert.ok(templateSrc.includes("{{sliceCount}}"), "template should use sliceCount");
+  assert.ok(templateSrc.includes("{{mid}}"), "template should use mid");
+  assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
+});
+
+// ─── Validate milestone prompt ────────────────────────────────────────────
+
+test("template: validate-milestone uses parallel reviewers", () => {
+  const validateSrc = readFileSync(join(__dirname, "..", "prompts", "validate-milestone.md"), "utf-8");
+  assert.ok(
+    validateSrc.includes("Reviewer A") && validateSrc.includes("Reviewer B") && validateSrc.includes("Reviewer C"),
+    "validate-milestone should dispatch 3 parallel reviewers",
+  );
+});

package/src/resources/extensions/gsd/tests/phantom-ghost-detection.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Regression test for #3671 — isGhostMilestone detects phantom queued rows
+ *
+ * gsd_milestone_generate_id inserts a DB row with status "queued" as a side
+ * effect. If the milestone is never planned, isGhostMilestone previously
+ * returned false for any milestone with a DB row, blocking the state machine.
+ *
+ * The fix makes isGhostMilestone treat a "queued" DB row with no disk
+ * artifacts (CONTEXT, ROADMAP, SUMMARY) as a ghost.
+ *
+ * This structural test verifies the dbRow.status === 'queued' guard exists.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+
+describe('isGhostMilestone phantom queued detection (#3671)', () => {
+  test('isGhostMilestone function exists', () => {
+    assert.match(source, /export function isGhostMilestone\(/,
+      'isGhostMilestone should be exported');
+  });
+
+  test('checks dbRow.status === queued', () => {
+    assert.match(source, /dbRow\.status\s*===\s*['"]queued['"]/,
+      'isGhostMilestone should check dbRow.status === "queued"');
+  });
+
+  test('checks for CONTEXT disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']CONTEXT["']\)/,
+      'should check for CONTEXT file');
+  });
+
+  test('checks for ROADMAP disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']ROADMAP["']\)/,
+      'should check for ROADMAP file');
+  });
+
+  test('checks for SUMMARY disk artifact', () => {
+    assert.match(source, /resolveMilestoneFile\(basePath,\s*mid,\s*["']SUMMARY["']\)/,
+      'should check for SUMMARY file');
+  });
+
+  test('returns !hasContent for queued rows (ghost if no artifacts)', () => {
+    assert.match(source, /return !hasContent/,
+      'should return !hasContent for queued phantom milestones');
+  });
+});

package/src/resources/extensions/gsd/tests/phantom-milestone-default-queued.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Regression test for #3695 — insertMilestone defaults status to "queued"
+ *
+ * Milestones were being auto-created with status "active", causing phantom
+ * milestones to appear as active work.  The fix defaults to "queued" so
+ * new milestones must be explicitly activated.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const dbSrc = readFileSync(
+  join(__dirname, '..', 'gsd-db.ts'),
+  'utf-8',
+);
+
+describe('insertMilestone defaults status to queued (#3695)', () => {
+  test('insertMilestone function exists', () => {
+    assert.match(dbSrc, /export function insertMilestone\(/,
+      'insertMilestone should be exported from gsd-db.ts');
+  });
+
+  test('default status is "queued" not "active"', () => {
+    // The status parameter should default to "queued" via nullish coalescing
+    assert.match(dbSrc, /m\.status\s*\?\?\s*"queued"/,
+      'insertMilestone should default status to "queued"');
+  });
+
+  test('comment explains the rationale', () => {
+    assert.match(dbSrc, /never auto-create milestones as "active"/i,
+      'should have a comment explaining why default is queued');
+  });
+});

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Regression test for #3626 / #3649 — pre-execution-checks false positives
+ *
+ * Two sources of false positives were fixed:
+ *   1. normalizeFilePath did not strip backtick wrapping from LLM-generated
+ *      paths like `src/foo.ts`, causing file-existence checks to fail (#3649).
+ *   2. checkFilePathConsistency checked both task.files and task.inputs, but
+ *      task.files ("files likely touched") intentionally includes files that
+ *      will be created by the task, so they don't need to pre-exist (#3626).
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'pre-execution-checks.ts'),
+  'utf-8',
+)
+
+describe('normalizeFilePath backtick stripping (#3649)', () => {
+  it('strips backticks from file paths', () => {
+    assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
+  })
+
+  it('strips backticks even when mixed with other normalization', () => {
+    assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
+  })
+
+  it('leaves normal paths unchanged', () => {
+    assert.equal(normalizeFilePath('src/foo.ts'), 'src/foo.ts')
+  })
+
+  it('handles empty string', () => {
+    assert.equal(normalizeFilePath(''), '')
+  })
+})
+
+describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', () => {
+  it('source uses only task.inputs in filesToCheck', () => {
+    // Verify the fix structurally: the spread should be [...task.inputs] only
+    const fnStart = src.indexOf('export function checkFilePathConsistency(')
+    assert.ok(fnStart !== -1, 'checkFilePathConsistency function must exist')
+
+    // Find the filesToCheck assignment
+    const filesToCheckLine = src.indexOf('filesToCheck', fnStart)
+    assert.ok(filesToCheckLine !== -1, 'filesToCheck assignment must exist')
+
+    // Extract the line
+    const lineEnd = src.indexOf('\n', filesToCheckLine)
+    const line = src.slice(filesToCheckLine, lineEnd)
+
+    // Must include task.inputs
+    assert.ok(
+      line.includes('task.inputs'),
+      'filesToCheck must reference task.inputs',
+    )
+
+    // Must NOT include task.files
+    assert.ok(
+      !line.includes('task.files'),
+      'filesToCheck must NOT reference task.files — files likely touched include ' +
+        'files the task will create, so they do not need to pre-exist',
+    )
+  })
+})