gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/tests/flag-file-db.test.ts

@@ -0,0 +1,290 @@
+/**
+ * flag-file-db.test.ts — Verify that REPLAN.md and REPLAN-TRIGGER.md
+ * flag-file detection in deriveStateFromDb() works from DB-only data
+ * (no disk flag files needed when DB is seeded).
+ *
+ * Semantics:
+ *   - blocker_discovered on a completed task → replanning-slice (unless loop-protected)
+ *   - replan_triggered_at column on slice → replanning-slice (unless loop-protected)
+ *   - Loop protection: replan_history entries for the slice → skip replanning
+ */
+
+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,
+  isDbAvailable,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertReplanHistory,
+  _getAdapter,
+} from '../gsd-db.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-flag-file-db-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+const ROADMAP_CONTENT = `# M001: Flag-File DB Test
+
+**Vision:** Test flag-file detection via DB.
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > After this: done.
+`;
+
+const PLAN_CONTENT = `# S01: Test Slice
+
+**Goal:** Test replanning detection.
+**Demo:** Tests pass.
+
+## Tasks
+
+- [x] **T01: Done Task** \`est:10m\`
+  Already done.
+
+- [ ] **T02: Active Task** \`est:10m\`
+  Current task.
+`;
+
+// Minimal task plan file content — deriveStateFromDb checks the tasks dir has .md files
+const TASK_PLAN_STUB = `# T02: Active Task\n\nDo stuff.\n`;
+const TASK_SUMMARY_STUB = `---\nblocker_discovered: false\n---\n# T01 Summary\nDone.\n`;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+
+  // ─── Test 1: blocker_discovered + no replan_history → replanning-slice ──
+  console.log('\n=== flag-file-db: blocker + no history → replanning ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // Write disk files needed by deriveStateFromDb (roadmap check, task dir check)
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', TASK_PLAN_STUB);
+
+      openDatabase(':memory:');
+      assertTrue(isDbAvailable(), 'test1: DB is available');
+
+      insertMilestone({ id: 'M001', title: 'Flag-File DB Test', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', risk: 'low', depends: [] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete', blockerDiscovered: true });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Active Task', status: 'pending' });
+
+      // No replan_history entries, no disk REPLAN.md — should trigger replanning
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assertEq(state.phase, 'replanning-slice', 'test1: phase is replanning-slice');
+      assertTrue(state.blockers.length > 0, 'test1: has blockers');
+      assertTrue(state.blockers[0]?.includes('blocker'), 'test1: blocker message mentions blocker');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test 2: blocker_discovered + replan_history exists → loop protection → executing ──
+  console.log('\n=== flag-file-db: blocker + history → loop protection ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', TASK_PLAN_STUB);
+
+      openDatabase(':memory:');
+
+      insertMilestone({ id: 'M001', title: 'Flag-File DB Test', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', risk: 'low', depends: [] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete', blockerDiscovered: true });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Active Task', status: 'pending' });
+
+      // Insert replan_history entry — loop protection should kick in
+      insertReplanHistory({
+        milestoneId: 'M001',
+        sliceId: 'S01',
+        summary: 'Replan already completed for this slice',
+      });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assertEq(state.phase, 'executing', 'test2: phase is executing (loop protection)');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test 3: replan_triggered_at set + no replan_history → replanning-slice ──
+  console.log('\n=== flag-file-db: trigger column + no history → replanning ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', TASK_PLAN_STUB);
+
+      openDatabase(':memory:');
+
+      insertMilestone({ id: 'M001', title: 'Flag-File DB Test', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', risk: 'low', depends: [] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete' });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Active Task', status: 'pending' });
+
+      // Set replan_triggered_at directly via SQL (simulating triage-resolution.ts writing it)
+      const adapter = _getAdapter();
+      adapter!.prepare(
+        "UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid",
+      ).run({ ":ts": new Date().toISOString(), ":mid": "M001", ":sid": "S01" });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assertEq(state.phase, 'replanning-slice', 'test3: phase is replanning-slice');
+      assertTrue(state.blockers.length > 0, 'test3: has blockers');
+      assertTrue(state.blockers[0]?.includes('Triage replan trigger'), 'test3: blocker message mentions triage trigger');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test 4: replan_triggered_at set + replan_history exists → loop protection ──
+  console.log('\n=== flag-file-db: trigger column + history → loop protection ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', TASK_PLAN_STUB);
+
+      openDatabase(':memory:');
+
+      insertMilestone({ id: 'M001', title: 'Flag-File DB Test', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', risk: 'low', depends: [] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete' });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Active Task', status: 'pending' });
+
+      // Set trigger column
+      const adapter = _getAdapter();
+      adapter!.prepare(
+        "UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid",
+      ).run({ ":ts": new Date().toISOString(), ":mid": "M001", ":sid": "S01" });
+
+      // Also add replan_history — loop protection should prevent replanning
+      insertReplanHistory({
+        milestoneId: 'M001',
+        sliceId: 'S01',
+        summary: 'Replan already done',
+      });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assertEq(state.phase, 'executing', 'test4: phase is executing (loop protection)');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Test 5: no blocker, no trigger → phase is executing ──────────────
+  console.log('\n=== flag-file-db: no blocker, no trigger → executing ===');
+  {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', TASK_PLAN_STUB);
+
+      openDatabase(':memory:');
+
+      insertMilestone({ id: 'M001', title: 'Flag-File DB Test', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice', status: 'active', risk: 'low', depends: [] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Done Task', status: 'complete' });
+      insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Active Task', status: 'pending' });
+
+      // No blocker, no trigger, no replan_history — normal executing
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assertEq(state.phase, 'executing', 'test5: phase is executing');
+      assertEq(state.activeTask?.id, 'T02', 'test5: activeTask is T02');
+      assertEq(state.blockers.length, 0, 'test5: no blockers');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  }
+
+  // ─── Diagnostic test: DB column inspection ──────────────────────────
+  console.log('\n=== flag-file-db: replan_triggered_at column is queryable ===');
+  {
+    openDatabase(':memory:');
+
+    insertMilestone({ id: 'M001', title: 'Diagnostic', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test', status: 'active', risk: 'low', depends: [] });
+
+    // Initially null
+    const adapter = _getAdapter();
+    const before = adapter!.prepare(
+      "SELECT id, replan_triggered_at FROM slices WHERE milestone_id = :mid",
+    ).get({ ":mid": "M001" }) as Record<string, unknown>;
+    assertEq(before["replan_triggered_at"], null, 'diagnostic: replan_triggered_at initially null');
+
+    // After setting
+    adapter!.prepare(
+      "UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid",
+    ).run({ ":ts": "2025-01-01T00:00:00Z", ":mid": "M001", ":sid": "S01" });
+
+    const after = adapter!.prepare(
+      "SELECT id, replan_triggered_at FROM slices WHERE milestone_id = :mid",
+    ).get({ ":mid": "M001" }) as Record<string, unknown>;
+    assertEq(after["replan_triggered_at"], "2025-01-01T00:00:00Z", 'diagnostic: replan_triggered_at is set');
+
+    closeDatabase();
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/freeform-decisions.test.ts

@@ -0,0 +1,240 @@
+import { createTestContext } from './test-helpers.ts';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import {
+  openDatabase,
+  closeDatabase,
+} from '../gsd-db.ts';
+import {
+  parseDecisionsTable,
+} from '../md-importer.ts';
+import {
+  saveDecisionToDb,
+} from '../db-writer.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function makeTmpDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-freeform-'));
+  fs.mkdirSync(path.join(dir, '.gsd'), { recursive: true });
+  return dir;
+}
+
+function cleanupDir(dir: string): void {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch { /* swallow */ }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Bug reproduction: freeform DECISIONS.md content destroyed (#2301)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── parseDecisionsTable silently drops freeform content ──');
+
+{
+  const freeform = `# Project Decisions
+
+## Architecture
+We decided to use a microservices architecture because monoliths don't scale.
+
+## Database
+PostgreSQL was chosen for its reliability and JSONB support.
+
+## Deployment
+- Kubernetes for orchestration
+- Helm charts for packaging
+`;
+
+  const parsed = parseDecisionsTable(freeform);
+  assertEq(parsed.length, 0, 'freeform content yields zero parsed decisions (expected — it is not a table)');
+}
+
+console.log('\n── saveDecisionToDb destroys freeform DECISIONS.md content ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+  openDatabase(dbPath);
+
+  const freeformContent = `# Project Decisions
+
+## Architecture
+We decided to use a microservices architecture because monoliths don't scale.
+
+## Database
+PostgreSQL was chosen for its reliability and JSONB support.
+
+## Deployment
+- Kubernetes for orchestration
+- Helm charts for packaging
+`;
+
+  // Pre-populate DECISIONS.md with freeform content
+  fs.writeFileSync(mdPath, freeformContent, 'utf-8');
+
+  try {
+    // Save a new decision — this should NOT destroy the freeform content
+    const result = await saveDecisionToDb({
+      scope: 'testing',
+      decision: 'Use Jest for unit tests',
+      choice: 'Jest',
+      rationale: 'Well-known, good DX',
+      when_context: 'M001',
+    }, tmpDir);
+
+    assertEq(result.id, 'D001', 'decision ID assigned correctly');
+
+    // Read back the file
+    const afterContent = fs.readFileSync(mdPath, 'utf-8');
+
+    // The freeform content MUST still be present
+    assertTrue(
+      afterContent.includes('microservices architecture'),
+      'freeform architecture section preserved after saveDecisionToDb',
+    );
+    assertTrue(
+      afterContent.includes('PostgreSQL was chosen'),
+      'freeform database section preserved after saveDecisionToDb',
+    );
+    assertTrue(
+      afterContent.includes('Kubernetes for orchestration'),
+      'freeform deployment section preserved after saveDecisionToDb',
+    );
+
+    // The new decision MUST also be present
+    assertTrue(
+      afterContent.includes('D001'),
+      'new decision D001 present in file',
+    );
+    assertTrue(
+      afterContent.includes('Use Jest for unit tests'),
+      'new decision text present in file',
+    );
+
+    // Save a second decision — freeform content must still survive
+    const result2 = await saveDecisionToDb({
+      scope: 'ci',
+      decision: 'Use GitHub Actions for CI',
+      choice: 'GitHub Actions',
+      rationale: 'Native integration',
+      when_context: 'M001',
+    }, tmpDir);
+
+    assertEq(result2.id, 'D002', 'second decision ID assigned correctly');
+
+    const afterContent2 = fs.readFileSync(mdPath, 'utf-8');
+
+    assertTrue(
+      afterContent2.includes('microservices architecture'),
+      'freeform content still preserved after second save',
+    );
+    assertTrue(
+      afterContent2.includes('D001'),
+      'first decision still present after second save',
+    );
+    assertTrue(
+      afterContent2.includes('D002'),
+      'second decision present after second save',
+    );
+    assertTrue(
+      afterContent2.includes('Use GitHub Actions for CI'),
+      'second decision text present in file',
+    );
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
+
+console.log('\n── saveDecisionToDb with table-format DECISIONS.md still regenerates normally ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+  openDatabase(dbPath);
+
+  // Pre-populate with canonical table format
+  const tableContent = `# Decisions Register
+
+<!-- Append-only. Never edit or remove existing rows.
+     To reverse a decision, add a new row that supersedes it.
+     Read this file at the start of any planning or research phase. -->
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|
+| D001 | M001 | arch | Use REST API | REST | Simpler | Yes | human |
+`;
+
+  fs.writeFileSync(mdPath, tableContent, 'utf-8');
+
+  try {
+    const result = await saveDecisionToDb({
+      scope: 'testing',
+      decision: 'Use Vitest',
+      choice: 'Vitest',
+      rationale: 'Fast',
+      when_context: 'M001',
+    }, tmpDir);
+
+    // The pre-existing table decision was NOT in DB, so it won't appear after regen.
+    // But the new decision should be there.
+    assertEq(result.id, 'D001', 'gets D001 since DB was empty');
+
+    const afterContent = fs.readFileSync(mdPath, 'utf-8');
+    // Table-format file gets fully regenerated — this is the normal path
+    assertTrue(
+      afterContent.includes('# Decisions Register'),
+      'table-format file still has header after save',
+    );
+    assertTrue(
+      afterContent.includes('Use Vitest'),
+      'new decision present in regenerated table',
+    );
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
+
+console.log('\n── saveDecisionToDb with no existing DECISIONS.md creates table ──');
+
+{
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+  openDatabase(dbPath);
+
+  // No DECISIONS.md exists at all
+  assertTrue(!fs.existsSync(mdPath), 'DECISIONS.md does not exist initially');
+
+  try {
+    const result = await saveDecisionToDb({
+      scope: 'arch',
+      decision: 'Brand new decision',
+      choice: 'Option A',
+      rationale: 'Best fit',
+    }, tmpDir);
+
+    assertEq(result.id, 'D001', 'first decision gets D001');
+    assertTrue(fs.existsSync(mdPath), 'DECISIONS.md created');
+
+    const content = fs.readFileSync(mdPath, 'utf-8');
+    assertTrue(content.includes('# Decisions Register'), 'new file has header');
+    assertTrue(content.includes('Brand new decision'), 'new file has decision');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -251,8 +251,8 @@ async function main(): Promise<void> {
 
   assertEq(
     RUNTIME_EXCLUSION_PATHS.length,
-    9,
-    "exactly 9 runtime exclusion paths"
+    13,
+    "exactly 13 runtime exclusion paths"
   );
 
   const expectedPaths = [
@@ -264,6 +264,10 @@ async function main(): Promise<void> {
     ".gsd/completed-units.json",
     ".gsd/STATE.md",
     ".gsd/gsd.db",
+    ".gsd/gsd.db-shm",
+    ".gsd/gsd.db-wal",
+    ".gsd/journal/",
+    ".gsd/doctor-history.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
   ];
 

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

@@ -66,7 +66,7 @@ console.log('\n=== gsd-db: fresh DB schema init (memory) ===');
   // Check schema_version table
   const adapter = _getAdapter()!;
   const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-  assertEq(version?.['version'], 4, 'schema version should be 4');
+  assertEq(version?.['version'], 10, 'schema version should be 10');
 
   // Check tables exist by querying them
   const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();