gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/tests/queue-reorder-e2e.test.ts

@@ -1,282 +0,0 @@
-/**
- * End-to-end integration tests for the Queue Reorder feature.
- *
- * Verifies the full chain: QUEUE-ORDER.json + findMilestoneIds() + deriveState()
- * + depends_on removal from CONTEXT.md files.
- *
- * These tests simulate what happens when a user reorders milestones and confirms:
- * 1. QUEUE-ORDER.json is written with the new order
- * 2. depends_on is removed from CONTEXT.md frontmatter
- * 3. deriveState() picks the correct milestone as active
- * 4. A fresh deriveState() call (simulating new session) also works
- */
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { deriveState, invalidateStateCache } from '../state.ts';
-import { findMilestoneIds } from '../guided-flow.ts';
-import { saveQueueOrder, loadQueueOrder } from '../queue-order.ts';
-import { parseContextDependsOn } from '../files.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ─── Fixture Helpers ───────────────────────────────────────────────────────
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-reorder-e2e-'));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-function writeMilestoneDir(base: string, mid: string): void {
-  mkdirSync(join(base, '.gsd', 'milestones', mid), { recursive: true });
-}
-
-function writeContext(base: string, mid: string, frontmatter: string, body: string = ''): void {
-  const dir = join(base, '.gsd', 'milestones', mid);
-  mkdirSync(dir, { recursive: true });
-  const fm = frontmatter ? `---\n${frontmatter}\n---\n\n` : '';
-  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `${fm}# ${mid}: Test\n\n${body}`);
-}
-
-function writeCompleteMilestone(base: string, mid: string): void {
-  const dir = join(base, '.gsd', 'milestones', mid);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${mid}-ROADMAP.md`), `# ${mid}: Complete
-
-**Vision:** Done.
-
-## Slices
-
-- [x] **S01: Done** \`risk:low\` \`depends:[]\`
-  > After this: Done.
-`);
-  writeFileSync(join(dir, `${mid}-VALIDATION.md`), `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.`);
-  writeFileSync(join(dir, `${mid}-SUMMARY.md`), `# ${mid} Summary\n\nComplete.`);
-}
-
-function readContextFile(base: string, mid: string): string {
-  return readFileSync(join(base, '.gsd', 'milestones', mid, `${mid}-CONTEXT.md`), 'utf-8');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Queue order changes milestone activation
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: queue-order changes active milestone ===');
-{
-  const base = createFixtureBase();
-  try {
-    // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
-    writeCompleteMilestone(base, 'M007');
-    writeMilestoneDir(base, 'M008');
-    writeContext(base, 'M008', '', 'Multi-Session Parallel Orchestration');
-    writeMilestoneDir(base, 'M009');
-    writeContext(base, 'M009', '', 'Context-Budget Visibility');
-
-    // Without custom order: M008 comes first (numeric sort)
-    invalidateStateCache();
-    const stateBefore = await deriveState(base);
-    assertEq(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
-
-    // Save custom order: M009 before M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // With custom order: M009 should be active
-    invalidateStateCache();
-    const stateAfter = await deriveState(base);
-    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
-
-    // findMilestoneIds respects the order
-    const ids = findMilestoneIds(base);
-    const m008Idx = ids.indexOf('M008');
-    const m009Idx = ids.indexOf('M009');
-    assertTrue(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Reorder + depends_on removal = correct state
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: reorder with depends_on removal ===');
-{
-  const base = createFixtureBase();
-  try {
-    // Setup: M007 complete, M008 depends_on M009, M009 no deps
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', 'depends_on: [M009]', 'Multi-Session Parallel');
-    writeContext(base, 'M009', '', 'Context-Budget Visibility');
-
-    // Before: M008 depends on M009, so deriveState skips M008, M009 is active
-    invalidateStateCache();
-    const stateBefore = await deriveState(base);
-    assertEq(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
-
-    // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Remove depends_on from M008-CONTEXT.md (simulating what handleQueueReorder does)
-    const contextContent = readContextFile(base, 'M008');
-    const newContent = contextContent.replace(/---\ndepends_on: \[M009\]\n---\n\n/, '');
-    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), newContent);
-
-    // Verify: depends_on is gone
-    const updatedContent = readContextFile(base, 'M008');
-    const deps = parseContextDependsOn(updatedContent);
-    assertEq(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
-
-    // Verify: deriveState still picks M009 (it's first in queue order)
-    invalidateStateCache();
-    const stateAfter = await deriveState(base);
-    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
-
-    // Verify: M008 is now pending (not dep-blocked)
-    const m008Entry = stateAfter.registry.find(m => m.id === 'M008');
-    assertEq(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
-    assertTrue(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Fresh deriveState (simulating new session) respects queue order
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: fresh session respects queue order ===');
-{
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel Orchestration');
-    writeContext(base, 'M009', '', 'Budget Visibility');
-
-    // Save queue order
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Simulate fresh session — invalidate all caches
-    invalidateStateCache();
-
-    // Derive state — should read QUEUE-ORDER.json from disk
-    const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
-
-    // Verify queue order persisted
-    const order = loadQueueOrder(base);
-    assertEq(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Queue order with newly added milestones
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: new milestones appended to queue ===');
-{
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-
-    // Custom order only has M009, M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Add M010 (not in queue order)
-    writeContext(base, 'M010', '', 'New feature');
-
-    invalidateStateCache();
-    const ids = findMilestoneIds(base);
-
-    // M009 first, M008 second, M010 appended at end
-    const m009Idx = ids.indexOf('M009');
-    const m008Idx = ids.indexOf('M008');
-    const m010Idx = ids.indexOf('M010');
-    assertTrue(m009Idx < m008Idx, 'M009 before M008');
-    assertTrue(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
-
-    // M009 is still active (first non-complete in queue order)
-    const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: No queue order file = default numeric sort (backward compat)
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
-{
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-
-    // No QUEUE-ORDER.json — default numeric sort
-    invalidateStateCache();
-    const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
-
-    const ids = findMilestoneIds(base);
-    assertTrue(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: depends_on inline array format removal
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: depends_on inline format preserved after partial removal ===');
-{
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    // M008 depends on both M009 and M010
-    writeContext(base, 'M008', 'depends_on: [M009, M010]', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-    writeContext(base, 'M010', '', 'Other');
-
-    // Verify both deps are parsed
-    const contentBefore = readContextFile(base, 'M008');
-    const depsBefore = parseContextDependsOn(contentBefore);
-    assertEq(depsBefore.length, 2, 'M008 has 2 deps before');
-
-    // Simulate removing only M009 dep (keep M010)
-    const content = readContextFile(base, 'M008');
-    const updated = content.replace('depends_on: [M009, M010]', 'depends_on: [M010]');
-    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), updated);
-
-    // Verify only M010 remains
-    const contentAfter = readContextFile(base, 'M008');
-    const depsAfter = parseContextDependsOn(contentAfter);
-    assertEq(depsAfter.length, 1, 'M008 has 1 dep after removal');
-    assertEq(depsAfter[0], 'M010', 'remaining dep is M010');
-
-  } finally {
-    cleanup(base);
-  }
-}
-
-report();

package/dist/resources/extensions/gsd/tests/reassess-detection.test.ts

@@ -1,154 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
-
-import { checkNeedsReassessment } from "../auto-prompts.ts";
-import { invalidateAllCaches } from "../cache.ts";
-import type { GSDState } from "../types.ts";
-
-function makeTmpBase(): string {
-  const base = join(tmpdir(), `gsd-test-reassess-${randomUUID()}`);
-  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
-}
-
-function writeRoadmap(base: string, content: string): void {
-  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), content);
-}
-
-function writeSummary(base: string, sid: string): void {
-  writeFileSync(
-    join(base, ".gsd", "milestones", "M001", "slices", sid, `${sid}-SUMMARY.md`),
-    `---\nid: ${sid}\n---\n# ${sid} Summary\nDone.`,
-  );
-}
-
-function writeAssessment(base: string, sid: string): void {
-  writeFileSync(
-    join(base, ".gsd", "milestones", "M001", "slices", sid, `${sid}-ASSESSMENT.md`),
-    `# ${sid} Assessment\nNo changes needed.`,
-  );
-}
-
-const ROADMAP_S01_DONE_S02_TODO = `# M001 Roadmap
-## Slices
-- [x] **S01: First** \`risk:high\` \`depends:[]\`
-- [ ] **S02: Second** \`risk:medium\` \`depends:[S01]\`
-`;
-
-const dummyState: GSDState = {
-  phase: "executing",
-  activeMilestone: { id: "M001", title: "Test" },
-  activeSlice: { id: "S02", title: "Second" },
-  activeTask: null,
-  recentDecisions: [],
-  blockers: [],
-  nextAction: "",
-  registry: [{ id: "M001", title: "Test", status: "active" }],
-};
-
-// ─── checkNeedsReassessment: returns null when assessment exists ─────────
-
-test("checkNeedsReassessment returns null when assessment file exists", async () => {
-  const base = makeTmpBase();
-  try {
-    invalidateAllCaches();
-    writeRoadmap(base, ROADMAP_S01_DONE_S02_TODO);
-    writeSummary(base, "S01");
-    writeAssessment(base, "S01");
-
-    const result = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.strictEqual(result, null, "should return null when assessment exists");
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── checkNeedsReassessment: returns sliceId when assessment missing ─────
-
-test("checkNeedsReassessment returns sliceId when assessment is missing", async () => {
-  const base = makeTmpBase();
-  try {
-    invalidateAllCaches();
-    writeRoadmap(base, ROADMAP_S01_DONE_S02_TODO);
-    writeSummary(base, "S01");
-    // No assessment written
-
-    const result = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.deepStrictEqual(result, { sliceId: "S01" });
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── checkNeedsReassessment: returns null when no summary exists ─────────
-
-test("checkNeedsReassessment returns null when summary is missing", async () => {
-  const base = makeTmpBase();
-  try {
-    invalidateAllCaches();
-    writeRoadmap(base, ROADMAP_S01_DONE_S02_TODO);
-    // No summary, no assessment
-
-    const result = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.strictEqual(result, null, "should return null — can't reassess without summary");
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── checkNeedsReassessment: detects assessment written after cache ──────
-// This is the core regression test for #1112: the assessment file is written
-// to disk AFTER the path cache was populated (simulating the worktree race
-// condition where readdirSync doesn't see a freshly written file).
-
-test("checkNeedsReassessment detects assessment written after initial cache population", async () => {
-  const base = makeTmpBase();
-  try {
-    writeRoadmap(base, ROADMAP_S01_DONE_S02_TODO);
-    writeSummary(base, "S01");
-
-    // First call: no assessment exists — populates internal caches
-    invalidateAllCaches();
-    const before = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.deepStrictEqual(before, { sliceId: "S01" }, "should need reassessment initially");
-
-    // Now write the assessment WITHOUT clearing caches.
-    // This simulates the race condition: the agent wrote the file, but the
-    // directory listing cache still has the old state.
-    writeAssessment(base, "S01");
-
-    // Second call: the file exists on disk but caches may be stale.
-    // With the fix (#1112), the existsSync fallback should detect it.
-    invalidateAllCaches();
-    const after = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.strictEqual(after, null, "should return null — assessment exists on disk (fallback check)");
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── checkNeedsReassessment: returns null when all slices done ───────────
-
-test("checkNeedsReassessment returns null when all slices are complete", async () => {
-  const base = makeTmpBase();
-  try {
-    invalidateAllCaches();
-    const allDone = `# M001 Roadmap\n## Slices\n- [x] **S01: First** \`risk:high\` \`depends:[]\`\n- [x] **S02: Second** \`risk:medium\` \`depends:[S01]\`\n`;
-    writeRoadmap(base, allDone);
-    writeSummary(base, "S02");
-
-    const result = await checkNeedsReassessment(base, "M001", dummyState);
-    assert.strictEqual(result, null, "should return null — all slices done, no point reassessing");
-  } finally {
-    cleanup(base);
-  }
-});

package/dist/resources/extensions/gsd/tests/reassess-prompt.test.ts

@@ -1,145 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createTestContext } from './test-helpers.ts';
-
-// loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
-// In a worktree the file may not exist there yet, so we resolve prompts
-// relative to this test file's location (the worktree copy).
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const worktreePromptsDir = join(__dirname, "..", "prompts");
-
-const { assertTrue, report } = createTestContext();
-/**
- * Load a prompt template from the worktree prompts directory
- * and apply variable substitution (mirrors loadPrompt logic).
- */
-function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
-  const path = join(worktreePromptsDir, `${name}.md`);
-  let content = readFileSync(path, "utf-8");
-  for (const [key, value] of Object.entries(vars)) {
-    content = content.replaceAll(`{{${key}}}`, value);
-  }
-  return content.trim();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function main(): Promise<void> {
-
-  // ─── reassess-roadmap prompt loads and substitutes ─────────────────────
-  console.log("\n=== reassess-roadmap prompt loads and substitutes ===");
-  {
-    const testVars = {
-      workingDirectory: "/tmp/test-project",
-      milestoneId: "M099",
-      completedSliceId: "S03",
-      assessmentPath: ".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md",
-      roadmapPath: ".gsd/milestones/M099/M099-ROADMAP.md",
-      inlinedContext: "--- test inlined context block ---",
-    };
-
-    let result: string;
-    let threw = false;
-    try {
-      result = loadPromptFromWorktree("reassess-roadmap", testVars);
-    } catch (err) {
-      threw = true;
-      result = "";
-      console.error(`  ERROR: loadPrompt threw: ${err}`);
-    }
-
-    assertTrue(!threw, "loadPrompt does not throw for reassess-roadmap");
-    assertTrue(typeof result === "string" && result.length > 0, "loadPrompt returns a non-empty string");
-
-    // Verify all test variables were substituted into the output
-    assertTrue(result.includes("M099"), "prompt contains milestoneId 'M099'");
-    assertTrue(result.includes("S03"), "prompt contains completedSliceId 'S03'");
-    assertTrue(result.includes(".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md"), "prompt contains assessmentPath");
-    assertTrue(result.includes(".gsd/milestones/M099/M099-ROADMAP.md"), "prompt contains roadmapPath");
-    assertTrue(result.includes("--- test inlined context block ---"), "prompt contains inlinedContext");
-
-    // Verify no un-substituted variables remain
-    assertTrue(!result.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
-    assertTrue(!result.includes("{{completedSliceId}}"), "no un-substituted {{completedSliceId}}");
-    assertTrue(!result.includes("{{assessmentPath}}"), "no un-substituted {{assessmentPath}}");
-    assertTrue(!result.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
-    assertTrue(!result.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
-  }
-
-  // ─── reassess-roadmap contains coverage-check instruction ─────────────
-  console.log("\n=== reassess-roadmap contains coverage-check instruction ===");
-  {
-    const prompt = loadPromptFromWorktree("reassess-roadmap", {
-      workingDirectory: "/tmp/test-project",
-      milestoneId: "M001",
-      completedSliceId: "S01",
-      assessmentPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
-      roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
-      inlinedContext: "context",
-    });
-
-    // Normalize to lowercase for case-insensitive matching
-    const lower = prompt.toLowerCase();
-
-    // The prompt must mention "each success criterion" or "every success criterion"
-    assertTrue(
-      lower.includes("each success criterion") || lower.includes("every success criterion"),
-      "prompt contains 'each success criterion' or 'every success criterion'"
-    );
-
-    // The prompt must mention "owning slice" or "remaining slice"
-    assertTrue(
-      lower.includes("owning slice") || lower.includes("remaining slice"),
-      "prompt contains 'owning slice' or 'remaining slice'"
-    );
-
-    // The prompt must mention "no remaining owner" or "no owner" or "no slice"
-    assertTrue(
-      lower.includes("no remaining owner") || lower.includes("no owner") || lower.includes("no slice"),
-      "prompt contains 'no remaining owner', 'no owner', or 'no slice'"
-    );
-
-    // The prompt must mention "blocking issue" or "blocking"
-    assertTrue(
-      lower.includes("blocking issue") || lower.includes("blocking"),
-      "prompt contains 'blocking issue' or 'blocking'"
-    );
-  }
-
-  // ─── coverage-check requires at-least-one semantics ───────────────────
-  console.log("\n=== coverage-check requires at-least-one semantics ===");
-  {
-    const prompt = loadPromptFromWorktree("reassess-roadmap", {
-      workingDirectory: "/tmp/test-project",
-      milestoneId: "M001",
-      completedSliceId: "S01",
-      assessmentPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
-      roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
-      inlinedContext: "context",
-    });
-
-    const lower = prompt.toLowerCase();
-
-    // The instruction must use "at least one" or equivalent inclusive language
-    assertTrue(
-      lower.includes("at least one") || lower.includes("at-least-one") || lower.includes("one or more"),
-      "prompt uses 'at least one' or equivalent inclusive language for slice ownership"
-    );
-
-    // The instruction must NOT require "exactly one" — that would be too rigid
-    assertTrue(
-      !lower.includes("exactly one owner") && !lower.includes("exactly one slice"),
-      "prompt does NOT use 'exactly one' for slice ownership (would be too rigid)"
-    );
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});