gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2ff77b0ce

package/src/resources/extensions/gsd/tests/deep-project-setup-policy.test.ts

@@ -0,0 +1,193 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import {
+  resolveDeepProjectSetupState,
+} from "../deep-project-setup-policy.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const deepPrefs = { planning_depth: "deep" } as GSDPreferences;
+
+const validProject = readFileSync(
+  new URL("../schemas/__fixtures__/valid-project.md", import.meta.url),
+  "utf-8",
+);
+const validRequirements = readFileSync(
+  new URL("../schemas/__fixtures__/valid-requirements.md", import.meta.url),
+  "utf-8",
+);
+
+function makeBase(): string {
+  const base = join(tmpdir(), `gsd-deep-policy-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function writeReadyProject(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nplanning_depth: deep\nworkflow_prefs_captured: true\n---\n",
+  );
+  writeFileSync(join(base, ".gsd", "PROJECT.md"), validProject);
+  writeFileSync(join(base, ".gsd", "REQUIREMENTS.md"), validRequirements);
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+}
+
+function writeDecision(base: string, value: Record<string, unknown> | string): void {
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "runtime", "research-decision.json"),
+    typeof value === "string" ? value : JSON.stringify(value),
+  );
+}
+
+function readDecision(base: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(base, ".gsd", "runtime", "research-decision.json"), "utf-8"));
+}
+
+function writeAllDimensionBlockers(base: string): void {
+  mkdirSync(join(base, ".gsd", "research"), { recursive: true });
+  for (const dimension of ["STACK", "FEATURES", "ARCHITECTURE", "PITFALLS"]) {
+    writeFileSync(join(base, ".gsd", "research", `${dimension}-BLOCKER.md`), "# blocked\n");
+  }
+}
+
+test("deep setup policy: skip decision wins over stale research blockers", () => {
+  const base = makeBase();
+  try {
+    writeReadyProject(base);
+    writeDecision(base, { decision: "skip", source: "workflow-preferences" });
+    writeAllDimensionBlockers(base);
+
+    const state = resolveDeepProjectSetupState(deepPrefs, base);
+    assert.deepEqual({ status: state.status, stage: state.stage }, { status: "complete", stage: null });
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deep setup policy: legacy workflow research default normalizes to skip", () => {
+  const base = makeBase();
+  try {
+    writeReadyProject(base);
+    writeDecision(base, { decision: "research", source: "workflow-preferences" });
+    writeAllDimensionBlockers(base);
+
+    const state = resolveDeepProjectSetupState(deepPrefs, base);
+    assert.deepEqual({ status: state.status, stage: state.stage }, { status: "complete", stage: null });
+    const decision = readDecision(base);
+    assert.equal(decision.decision, "skip");
+    assert.equal(decision.source, "workflow-preferences");
+    assert.equal(decision.previous_source, "workflow-preferences");
+    assert.equal(decision.reason, "legacy-workflow-research-default");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deep setup policy: missing and malformed markers repair to default skip", () => {
+  const missingBase = makeBase();
+  const malformedBase = makeBase();
+  try {
+    writeReadyProject(missingBase);
+    const missingState = resolveDeepProjectSetupState(deepPrefs, missingBase);
+    assert.deepEqual({ status: missingState.status, stage: missingState.stage }, { status: "complete", stage: null });
+    assert.equal(readDecision(missingBase).reason, "missing-default-repair");
+
+    writeReadyProject(malformedBase);
+    writeDecision(malformedBase, "{");
+    const malformedState = resolveDeepProjectSetupState(deepPrefs, malformedBase);
+    assert.deepEqual({ status: malformedState.status, stage: malformedState.stage }, { status: "complete", stage: null });
+    assert.equal(readDecision(malformedBase).reason, "malformed-default-repair");
+  } finally {
+    rmSync(missingBase, { recursive: true, force: true });
+    rmSync(malformedBase, { recursive: true, force: true });
+  }
+});
+
+test("deep setup policy: explicit research can dispatch, block, or complete", () => {
+  const pendingBase = makeBase();
+  const blockedBase = makeBase();
+  const completeBase = makeBase();
+  try {
+    writeReadyProject(pendingBase);
+    writeDecision(pendingBase, { decision: "research", source: "research-decision" });
+    const pending = resolveDeepProjectSetupState(deepPrefs, pendingBase);
+    assert.deepEqual({ status: pending.status, stage: pending.stage }, { status: "pending", stage: "project-research" });
+
+    writeReadyProject(blockedBase);
+    writeDecision(blockedBase, { decision: "research", source: "user" });
+    writeAllDimensionBlockers(blockedBase);
+    const blocked = resolveDeepProjectSetupState(deepPrefs, blockedBase);
+    assert.deepEqual({ status: blocked.status, stage: blocked.stage }, { status: "blocked", stage: "project-research" });
+
+    writeReadyProject(completeBase);
+    writeDecision(completeBase, { decision: "research", source: "research-decision" });
+    mkdirSync(join(completeBase, ".gsd", "research"), { recursive: true });
+    for (const name of ["STACK.md", "FEATURES.md", "ARCHITECTURE.md"]) {
+      writeFileSync(join(completeBase, ".gsd", "research", name), "# done\n");
+    }
+    writeFileSync(join(completeBase, ".gsd", "research", "PITFALLS-BLOCKER.md"), "# blocked\n");
+    const complete = resolveDeepProjectSetupState(deepPrefs, completeBase);
+    assert.deepEqual({ status: complete.status, stage: complete.stage }, { status: "complete", stage: null });
+    assert.equal(existsSync(join(completeBase, ".gsd", "runtime", "research-project-inflight")), false);
+  } finally {
+    rmSync(pendingBase, { recursive: true, force: true });
+    rmSync(blockedBase, { recursive: true, force: true });
+    rmSync(completeBase, { recursive: true, force: true });
+  }
+});
+
+
+test("resolveDeepProjectSetupState: self-heals missing workflow_prefs_captured when downstream artifacts are valid", () => {
+  const base = makeBase();
+  try {
+    // PREFERENCES.md missing the captured flag — simulating drift after manual
+    // edit / merge conflict / partial write.
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      "---\nplanning_depth: deep\n---\n",
+    );
+    writeFileSync(join(base, ".gsd", "PROJECT.md"), validProject);
+    writeFileSync(join(base, ".gsd", "REQUIREMENTS.md"), validRequirements);
+    writeDecision(base, {
+      decision: "skip",
+      decided_at: new Date().toISOString(),
+      source: "workflow-preferences",
+      reason: "deterministic-default",
+    });
+
+    const state = resolveDeepProjectSetupState(deepPrefs, base);
+
+    assert.equal(state.status, "complete", "should self-heal to complete, not return pending");
+    const restored = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+    assert.match(restored, /workflow_prefs_captured:\s*true/, "captured flag should be restored on disk");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("resolveDeepProjectSetupState: still pending when downstream artifacts are NOT valid", () => {
+  const base = makeBase();
+  try {
+    // PREFERENCES.md missing flag AND PROJECT.md missing — genuine setup-incomplete.
+    writeFileSync(
+      join(base, ".gsd", "PREFERENCES.md"),
+      "---\nplanning_depth: deep\n---\n",
+    );
+    // No PROJECT.md, no REQUIREMENTS.md, no research-decision.json.
+
+    const state = resolveDeepProjectSetupState(deepPrefs, base);
+
+    assert.equal(state.status, "pending", "genuine incomplete setup must still pend");
+    assert.equal(state.stage, "workflow-preferences", "stage points at the missing flag");
+    const original = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+    assert.doesNotMatch(original, /workflow_prefs_captured:\s*true/, "flag not added when self-heal does not apply");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/derive-state-crossval.test.ts

@@ -20,7 +20,7 @@ import {
   insertSlice,
   insertTask,
 } from '../gsd-db.ts';
-import { migrateHierarchyToDb } from '../md-importer.ts';
+import { migrateFromMarkdown, migrateHierarchyToDb } from '../md-importer.ts';
 import type { GSDState } from '../types.ts';
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
@@ -479,12 +479,13 @@ skills_used: []
 
       // Step 2: Migrate markdown to DB
       openDatabase(':memory:');
-      const counts = migrateHierarchyToDb(base);
+      const counts = migrateFromMarkdown(base);
 
       // Verify migration populated correctly
-      assert.ok(counts.milestones >= 1, 'G-roundtrip: migrated milestones');
-      assert.ok(counts.slices >= 2, 'G-roundtrip: migrated slices');
-      assert.ok(counts.tasks >= 3, 'G-roundtrip: migrated tasks');
+      assert.ok(counts.hierarchy.milestones >= 1, 'G-roundtrip: migrated milestones');
+      assert.ok(counts.hierarchy.slices >= 2, 'G-roundtrip: migrated slices');
+      assert.ok(counts.hierarchy.tasks >= 3, 'G-roundtrip: migrated tasks');
+      assert.equal(counts.requirements, 3, 'G-roundtrip: migrated requirements');
 
       // Step 3: Get DB-backed state
       invalidateStateCache();

package/src/resources/extensions/gsd/tests/derive-state-db-disk-reconcile.test.ts

@@ -1,10 +1,9 @@
 /**
  * derive-state-db-disk-reconcile.test.ts — #2416
  *
- * After migration to DB-backed state, milestones that exist on disk
- * (in .gsd/milestones/) but were never imported into the DB become
- * invisible to deriveStateFromDb(). This test verifies that
- * deriveStateFromDb reconciles disk milestones with DB milestones.
+ * DB-authoritative state: milestones that exist only as markdown projections
+ * are not imported by deriveStateFromDb(). Explicit migration/import is the
+ * only markdown-to-DB path.
  */
 
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
@@ -17,7 +16,6 @@ import {
   closeDatabase,
   insertMilestone,
   insertSlice,
-  insertTask,
 } from "../gsd-db.ts";
 import { createTestContext } from "./test-helpers.ts";
 
@@ -58,7 +56,7 @@ const ROADMAP_CONTENT = `# M002: Disk-Only Milestone
 `;
 
 async function main(): Promise<void> {
-  console.log("\n=== #2416: deriveStateFromDb reconciles disk milestones ===");
+  console.log("\n=== deriveStateFromDb does not reconcile disk milestones ===");
 
   // Set up: M001 in DB, M002 on disk only
   const base = createFixtureBase();
@@ -81,12 +79,9 @@ async function main(): Promise<void> {
     invalidateStateCache();
     const state = await deriveStateFromDb(base);
 
-    // M002 should be visible in the registry
+    // M002 is disk-only and should not be visible in DB-backed state.
     const m002Entry = state.registry.find((m) => m.id === "M002");
-    assertTrue(
-      m002Entry !== undefined,
-      "M002 (disk-only milestone) should appear in state.registry (#2416)",
-    );
+    assertEq(m002Entry, undefined, "M002 disk-only milestone should not appear in DB-backed state");
 
     // M001 should still be in the registry
     const m001Entry = state.registry.find((m) => m.id === "M001");
@@ -95,24 +90,14 @@ async function main(): Promise<void> {
       "M001 (DB milestone) should still appear in state.registry",
     );
 
-    // The active milestone should be M002 (since M001 is complete)
-    assertTrue(
-      state.activeMilestone !== null,
-      "There should be an active milestone",
-    );
-    if (state.activeMilestone) {
-      assertEq(
-        state.activeMilestone.id,
-        "M002",
-        "Active milestone should be M002 (disk-only, not complete) (#2416)",
-      );
-    }
+    assertEq(state.activeMilestone, null, "No active milestone should be inferred from disk-only markdown");
+    assertEq(state.phase, "complete", "DB-only complete milestone drives complete state");
   } finally {
     closeDatabase();
     cleanup(base);
   }
 
-  console.log("\n=== #4974: summary-only disk milestones keep parsed title ===");
+    console.log("\n=== summary-only disk milestones are not imported ===");
 
   {
     const summaryOnlyBase = createFixtureBase();
@@ -132,20 +117,7 @@ async function main(): Promise<void> {
       const state = await deriveStateFromDb(summaryOnlyBase);
       const m002Entry = state.registry.find((m) => m.id === "M002");
 
-      assertTrue(
-        m002Entry !== undefined,
-        "M002 summary-only disk milestone should appear in state.registry (#4974)",
-      );
-      assertEq(
-        m002Entry?.title,
-        "Summary-Only Milestone",
-        "M002 summary-only disk milestone should use parsed SUMMARY title (#4974)",
-      );
-      assertEq(
-        m002Entry?.status,
-        "complete",
-        "M002 summary-only disk milestone should reconcile as complete (#4974)",
-      );
+      assertEq(m002Entry, undefined, "M002 summary-only disk milestone should not appear without explicit import");
     } finally {
       closeDatabase();
       cleanup(summaryOnlyBase);