gsd-pi 2.65.0 → 2.66.0-dev.6c91c1f

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/orphaned-worktree-audit.test.ts

@@ -0,0 +1,189 @@
+// GSD2 — Tests for auditOrphanedMilestoneBranches bootstrap audit
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { auditOrphanedMilestoneBranches } from "../auto-start.ts";
+import { openDatabase, closeDatabase, insertMilestone, updateMilestoneStatus } from "../gsd-db.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with .gsd structure and DB. */
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "orphan-audit-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  // Create .gsd structure on disk (not tracked in git)
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+
+  return dir;
+}
+
+describe("auditOrphanedMilestoneBranches", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    openDatabase(join(dir, ".gsd", "gsd.db"));
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("no milestone branches → no-op", () => {
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+  });
+
+  test("skips in none isolation mode", () => {
+    // Create a milestone branch that would otherwise be detected
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "none");
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "branch should be preserved in none mode");
+  });
+
+  test("deletes merged branch for completed milestone", () => {
+    // Create milestone branch from main (so it's already merged)
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(result.recovered.length > 0, "should have recovered actions");
+    assert.ok(
+      result.recovered.some(r => r.includes("Deleted merged branch milestone/M001")),
+      "should report branch deletion",
+    );
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should be gone
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.deepStrictEqual(branches, "", "branch should be deleted");
+  });
+
+  test("warns about unmerged branch for completed milestone", () => {
+    // Create milestone branch with divergent commits (not merged into main)
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "new feature\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"add feature on milestone branch\"", dir);
+    run("git checkout main", dir);
+
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, [], "should not delete unmerged branch");
+    assert.ok(result.warnings.length > 0, "should have warnings");
+    assert.ok(
+      result.warnings.some(w => w.includes("NOT merged")),
+      "should warn about unmerged branch",
+    );
+
+    // Branch should still exist (data safety)
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "unmerged branch must be preserved");
+  });
+
+  test("skips active (non-complete) milestone branches", () => {
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "active milestone branch should be preserved");
+  });
+
+  test("cleans up orphaned worktree directory for merged milestone", () => {
+    // Create milestone branch (merged — same as main)
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    // Create orphaned worktree directory
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "orphaned file\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(result.recovered.length > 0, "should have recovered actions");
+    assert.ok(
+      result.recovered.some(r => r.includes("worktree directory")),
+      "should report worktree cleanup",
+    );
+
+    // Worktree directory should be cleaned up
+    assert.ok(!existsSync(wtDir), "orphaned worktree directory should be removed");
+  });
+
+  test("handles multiple milestones with mixed states", () => {
+    // M001: complete, branch merged → should clean up
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "First", status: "complete" });
+
+    // M002: active, branch exists → should skip
+    run("git branch milestone/M002", dir);
+    insertMilestone({ id: "M002", title: "Second", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // M001 should be cleaned up
+    assert.ok(
+      result.recovered.some(r => r.includes("M001")),
+      "should clean up completed M001",
+    );
+
+    // M002 should not be touched
+    const branches = run("git branch --list milestone/M002", dir);
+    assert.ok(branches.includes("milestone/M002"), "active M002 branch should be preserved");
+  });
+
+  test("works in branch isolation mode", () => {
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "branch");
+
+    assert.ok(result.recovered.length > 0, "should work in branch mode too");
+    assert.ok(
+      result.recovered.some(r => r.includes("Deleted merged branch")),
+      "should delete branch in branch mode",
+    );
+  });
+
+  test("handles milestone in DB but no branch (no-op)", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+  });
+});

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',
+    )
+  })
+})