gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.42ef05fbe

package/src/resources/extensions/gsd/tests/commands-ship-eval-warn.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Unit tests for the pre-ship eval-review soft-warning helper.
+ *
+ * The helper `checkSliceEvalReview` is a pure-data classifier called by
+ * `handleShip` for each slice in the active milestone. It must:
+ *   - return `absent` on missing file (no exception, no throw)
+ *   - tolerate a TOCTOU race where the file is deleted between
+ *     resolution and read (regression: prior parser would have crashed on this race)
+ *   - report `malformed` on schema-invalid frontmatter (no crash)
+ *   - report `ok` with verdict + overall_score on a valid frontmatter
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { checkSliceEvalReview } from "../commands-ship.js";
+import { _clearGsdRootCache, resolveSliceFile } from "../paths.js";
+
+describe("checkSliceEvalReview", () => {
+  let basePath: string;
+  let sliceDir: string;
+
+  beforeEach(() => {
+    basePath = join(tmpdir(), `gsd-ship-eval-${randomUUID()}`);
+    sliceDir = join(basePath, ".gsd", "milestones", "M001", "slices", "S07");
+    mkdirSync(sliceDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    _clearGsdRootCache();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  function writeEvalReview(filename: string, content: string): string {
+    const path = join(sliceDir, filename);
+    writeFileSync(path, content, "utf-8");
+    return path;
+  }
+
+  function happyFrontmatter(overrides: Record<string, string> = {}): string {
+    const fields = {
+      schema: "eval-review/v1",
+      verdict: "PRODUCTION_READY",
+      coverage_score: "85",
+      infrastructure_score: "80",
+      overall_score: "83",
+      generated: "2026-04-28T14:00:00Z",
+      slice: "S07",
+      milestone: "M001",
+      ...overrides,
+    };
+    const lines = ["---"];
+    for (const [k, v] of Object.entries(fields)) lines.push(`${k}: ${v}`);
+    lines.push("gaps: []");
+    lines.push("counts:");
+    lines.push("  blocker: 0");
+    lines.push("  major: 0");
+    lines.push("  minor: 0");
+    lines.push("---");
+    lines.push("");
+    lines.push("# Body — never parsed");
+    return lines.join("\n");
+  }
+
+  it("returns absent when EVAL-REVIEW.md is missing", async () => {
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "absent");
+    assert.equal(result.sliceId, "S07");
+  });
+
+  it("returns ok with verdict and overall_score when frontmatter is valid (PRODUCTION_READY path)", async () => {
+    writeEvalReview("S07-EVAL-REVIEW.md", happyFrontmatter());
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "ok");
+    if (result.kind === "ok") {
+      assert.equal(result.verdict, "PRODUCTION_READY");
+      assert.equal(result.overall_score, 83);
+    }
+  });
+
+  it("returns ok with NOT_IMPLEMENTED verdict (warning path)", async () => {
+    writeEvalReview(
+      "S07-EVAL-REVIEW.md",
+      happyFrontmatter({
+        verdict: "NOT_IMPLEMENTED",
+        coverage_score: "10",
+        infrastructure_score: "20",
+        overall_score: "14",
+      }),
+    );
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "ok");
+    if (result.kind === "ok") {
+      assert.equal(result.verdict, "NOT_IMPLEMENTED");
+      assert.equal(result.overall_score, 14);
+    }
+  });
+
+  it("returns malformed with a JSON-Pointer when verdict is invalid (regression: malformed verdicts must not parse silently)", async () => {
+    writeEvalReview("S07-EVAL-REVIEW.md", happyFrontmatter({ verdict: "MOSTLY_OK" }));
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "malformed");
+    if (result.kind === "malformed") {
+      assert.ok(result.pointer.includes("verdict"), `pointer should reference verdict, got ${result.pointer}`);
+    }
+  });
+
+  it("returns malformed when the file has no frontmatter delimiters at all", async () => {
+    writeEvalReview("S07-EVAL-REVIEW.md", "# Just a body, no frontmatter");
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "malformed");
+  });
+
+  it("returns malformed when the YAML is syntactically broken inside the frontmatter block", async () => {
+    writeEvalReview("S07-EVAL-REVIEW.md", "---\nfoo: : bar\n---\n");
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "malformed");
+  });
+
+  it("treats a TOCTOU race (file deleted after resolution but before read) as absent without throwing (regression: TOCTOU race must surface as absent, not throw)", async () => {
+    const path = writeEvalReview("S07-EVAL-REVIEW.md", happyFrontmatter());
+    // Warm the directory-listing cache used inside resolveSliceFile so the
+    // resolver still sees the file by name on the next call. Then delete the
+    // file. The subsequent checkSliceEvalReview call resolves a path that
+    // points to a missing file — exactly the race a prior existsSync +
+    // readFileSync sequence panicked on.
+    const resolved = resolveSliceFile(basePath, "M001", "S07", "EVAL-REVIEW");
+    assert.equal(resolved, path);
+    unlinkSync(path);
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "absent");
+  });
+
+  it("does NOT trigger a malformed verdict on bodies with prose, tables, or numbered lists (regression: body is never parsed)", async () => {
+    const body = [
+      "",
+      "## Gap Analysis",
+      "1. first numbered item that the previous parser would have grabbed",
+      "2. second numbered item",
+      "",
+      "| dim | sev |",
+      "|---|---|",
+      "| metrics | major |",
+      "",
+      "Some prose paragraph describing the audit.",
+    ].join("\n");
+    writeEvalReview("S07-EVAL-REVIEW.md", happyFrontmatter() + body);
+    const result = await checkSliceEvalReview(basePath, "M001", "S07");
+    assert.equal(result.kind, "ok");
+  });
+});

package/src/resources/extensions/gsd/tests/context-budget.test.ts

@@ -199,6 +199,18 @@ describe("context-budget: resolveExecutorContextWindow", () => {
     assert.equal(result, 128_000);
   });
 
+  it("uses conservative effective context for configured claude-code models", () => {
+    const registry = makeRegistry([
+      makeModel("claude-sonnet-4-6", "claude-code", 1_000_000),
+    ]);
+    const prefs: MinimalPreferences = {
+      models: { execution: "claude-code/claude-sonnet-4-6" },
+    };
+
+    const result = resolveExecutorContextWindow(registry, prefs);
+    assert.equal(result, 200_000);
+  });
+
   it("supports provider/model format in preferences", () => {
     const registry = makeRegistry([
       makeModel("gpt-4o", "openai", 128_000),
@@ -246,6 +258,22 @@ describe("context-budget: resolveExecutorContextWindow", () => {
     assert.equal(result, 128_000);
   });
 
+  it("uses conservative effective context for claude-code session window fallback", () => {
+    const registry = makeRegistry([]);
+    const prefs: MinimalPreferences = { models: {} };
+
+    const result = resolveExecutorContextWindow(registry, prefs, 1_000_000, "claude-code");
+    assert.equal(result, 200_000);
+  });
+
+  it("does not cap large non-claude-code session windows", () => {
+    const registry = makeRegistry([]);
+    const prefs: MinimalPreferences = { models: {} };
+
+    const result = resolveExecutorContextWindow(registry, prefs, 1_000_000, "openai");
+    assert.equal(result, 1_000_000);
+  });
+
   it("falls back to 200K when no session and no executor model", () => {
     const registry = makeRegistry([]);
     const prefs: MinimalPreferences = { models: { execution: "missing" } };

package/src/resources/extensions/gsd/tests/crash-recovery.test.ts

@@ -248,6 +248,56 @@ test("readPausedSessionMetadata handles legacy metadata without unitType/unitId"
   }
 });
 
+test("readPausedSessionMetadata drops stale discuss-milestone pseudo PROJECT metadata", () => {
+  const base = makeTmpBase();
+  try {
+    const runtimeDir = join(base, ".gsd", "runtime");
+    const pausedPath = join(runtimeDir, "paused-session.json");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(
+      pausedPath,
+      JSON.stringify({
+        milestoneId: null,
+        originalBasePath: base,
+        unitType: "discuss-milestone",
+        unitId: "PROJECT",
+      }, null, 2),
+      "utf-8",
+    );
+
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta, null);
+    assert.equal(existsSync(pausedPath), false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readPausedSessionMetadata drops stale deep setup pseudo-unit metadata", () => {
+  const base = makeTmpBase();
+  try {
+    const runtimeDir = join(base, ".gsd", "runtime");
+    const pausedPath = join(runtimeDir, "paused-session.json");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(
+      pausedPath,
+      JSON.stringify({
+        milestoneId: "WORKFLOW-PREFS",
+        originalBasePath: base,
+        unitType: "workflow-preferences",
+        unitId: "WORKFLOW-PREFS",
+      }, null, 2),
+      "utf-8",
+    );
+
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta, null);
+    assert.equal(existsSync(pausedPath), false);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("assessInterruptedSession returns none when no lock and no paused session exist", async () => {
   const base = makeTmpBase();
   try {

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

@@ -22,6 +22,7 @@ import {
   generateRequirementsMd,
   nextDecisionId,
   saveDecisionToDb,
+  saveRequirementToDb,
   updateRequirementInDb,
   saveArtifactToDb,
   extractDeferredSliceRef,
@@ -244,20 +245,24 @@ describe('db-writer', () => {
     assert.ok(md.includes('## Coverage Summary'), 'has Coverage Summary section');
   });
 
-  test('generateRequirementsMd only populated sections', () => {
-    // Only active requirements — should only have Active section
+  test('generateRequirementsMd emits empty required sections', () => {
+    // Only active requirements, but deep-mode validation requires all sections.
     const activeOnly = SAMPLE_REQUIREMENTS.filter(r => r.status === 'active');
     const md = generateRequirementsMd(activeOnly);
     assert.ok(md.includes('## Active'), 'has Active section');
-    assert.ok(!md.includes('## Validated'), 'no Validated section when no validated reqs');
-    assert.ok(!md.includes('## Deferred'), 'no Deferred section when no deferred reqs');
-    assert.ok(!md.includes('## Out of Scope'), 'no Out of Scope section when no out-of-scope reqs');
+    assert.ok(md.includes('## Validated'), 'has empty Validated section');
+    assert.ok(md.includes('## Deferred'), 'has empty Deferred section');
+    assert.ok(md.includes('## Out of Scope'), 'has empty Out of Scope section');
   });
 
   test('generateRequirementsMd empty input', () => {
     const md = generateRequirementsMd([]);
     const parsed = parseRequirementsSections(md);
     assert.deepStrictEqual(parsed.length, 0, 'empty requirements produces empty parse');
+    assert.ok(md.includes('## Active'), 'empty requirements still has Active section');
+    assert.ok(md.includes('## Validated'), 'empty requirements still has Validated section');
+    assert.ok(md.includes('## Deferred'), 'empty requirements still has Deferred section');
+    assert.ok(md.includes('## Out of Scope'), 'empty requirements still has Out of Scope section');
   });
 
   // ═══════════════════════════════════════════════════════════════════════════
@@ -541,6 +546,49 @@ describe('db-writer', () => {
     }
   });
 
+  test('saveRequirementToDb is idempotent for repeated descriptions', async () => {
+    const tmpDir = makeTmpDir();
+    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+    openDatabase(dbPath);
+
+    try {
+      const first = await saveRequirementToDb({
+        class: 'primary-user-loop',
+        status: 'active',
+        description: 'User can add a task by pressing Enter',
+        why: 'Core capture loop',
+        source: 'user',
+        primary_owner: 'M001/none yet',
+        supporting_slices: 'none',
+        validation: 'unmapped',
+      }, tmpDir);
+      const retry = await saveRequirementToDb({
+        class: 'primary-user-loop',
+        status: 'active',
+        description: '  user CAN add a task by pressing Enter  ',
+        why: 'Core capture loop, restated on retry',
+        source: 'user',
+        primary_owner: 'M001/S01',
+        supporting_slices: 'none',
+        validation: 'mapped',
+      }, tmpDir);
+
+      assert.deepStrictEqual(retry.id, first.id, 'retry save reuses existing requirement ID');
+
+      const adapter = _getAdapter();
+      const rows = adapter!
+        .prepare('SELECT id, description, primary_owner, validation FROM requirements ORDER BY id')
+        .all() as Array<Record<string, unknown>>;
+      assert.deepStrictEqual(rows.length, 1, 'semantic duplicate does not create a new row');
+      assert.deepStrictEqual(rows[0]['id'], 'R001');
+      assert.deepStrictEqual(rows[0]['primary_owner'], 'M001/S01', 'retry updates the existing row');
+      assert.deepStrictEqual(rows[0]['validation'], 'mapped', 'retry updates validation');
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
   // saveArtifactToDb Tests
   // ═══════════════════════════════════════════════════════════════════════════
@@ -631,6 +679,104 @@ describe('db-writer', () => {
     }
   });
 
+  test('saveArtifactToDb — final REQUIREMENTS renders from DB rows, ignoring caller-supplied markdown', async () => {
+    const tmpDir = makeTmpDir();
+    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+    openDatabase(dbPath);
+
+    try {
+      const canonicalRequirement: Requirement = {
+        id: 'R001',
+        class: 'primary-user-loop',
+        status: 'active',
+        description: 'User can add a task',
+        why: 'Core loop',
+        source: 'user',
+        primary_owner: 'M001/none yet',
+        supporting_slices: 'none',
+        validation: 'unmapped',
+        notes: 'canonical',
+        full_content: '',
+        superseded_by: null,
+      };
+      upsertRequirement(canonicalRequirement);
+
+      const relPath = 'REQUIREMENTS.md';
+      const filePath = path.join(tmpDir, '.gsd', relPath);
+      const bloatedInvalidContent = [
+        '# Requirements',
+        '',
+        '## Active',
+        '',
+        ...Array.from({ length: 30 }, (_, i) => [
+          `### R${String(i + 1).padStart(3, '0')} — Duplicate`,
+          '- Class: primary-user-loop',
+          '- Status: active',
+          '- Description: Duplicate retry row',
+          '- Why it matters: Retry drift',
+          '- Source: test',
+          '- Primary owning slice: M001/none yet',
+          '- Supporting slices: none',
+          '- Validation: unmapped',
+          '- Notes:',
+          '',
+        ].join('\n')),
+        '## Traceability',
+        '',
+        '## Coverage Summary',
+        '',
+      ].join('\n');
+      fs.writeFileSync(filePath, bloatedInvalidContent);
+
+      assert.ok(
+        Buffer.byteLength(generateRequirementsMd([canonicalRequirement]), 'utf-8') < Buffer.byteLength(bloatedInvalidContent, 'utf-8') * 0.5,
+        'test setup: DB-rendered content is small enough that the generic shrinkage guard would trigger',
+      );
+
+      await saveArtifactToDb({
+        path: relPath,
+        artifact_type: 'REQUIREMENTS',
+        content: bloatedInvalidContent,
+      }, tmpDir);
+
+      const writtenContent = fs.readFileSync(filePath, 'utf-8');
+      assert.ok(
+        writtenContent.includes('R001') && writtenContent.includes('User can add a task'),
+        'disk file contains DB-sourced R001 requirement',
+      );
+      assert.ok(
+        !writtenContent.includes('Duplicate retry row'),
+        'disk file does not contain caller-supplied bloated content',
+      );
+
+      const adapter = _getAdapter();
+      const reqRows = adapter!
+        .prepare('SELECT id, description FROM requirements ORDER BY id')
+        .all() as Array<Record<string, unknown>>;
+      assert.deepStrictEqual(
+        reqRows.map((row) => [row['id'], row['description']]),
+        [['R001', 'User can add a task']],
+        'artifact save does not parse markdown back into the requirements table',
+      );
+
+      const artifact = adapter!
+        .prepare('SELECT full_content FROM artifacts WHERE path = ?')
+        .get(relPath) as Record<string, unknown>;
+      const storedContent = artifact['full_content'] as string;
+      assert.ok(
+        storedContent.includes('R001') && storedContent.includes('User can add a task'),
+        'artifacts.full_content is DB-rendered output containing R001',
+      );
+      assert.ok(
+        !storedContent.includes('Duplicate retry row'),
+        'artifacts.full_content does not echo caller-supplied markdown payload',
+      );
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   test('saveArtifactToDb — allows overwrite when new content is similar size', async () => {
     const tmpDir = makeTmpDir();
     const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');

package/src/resources/extensions/gsd/tests/debug-command-handler.test.ts

@@ -136,6 +136,43 @@ describe("handleDebug lifecycle", () => {
     }
   });
 
+  test("issue-start dispatches a find_and_fix debug runner after creating the session", async () => {
+    const base = makeBase();
+    const ctx = createMockCtx();
+    const dispatched: Array<{
+      msg: { customType: string; content: string; display: boolean };
+      options: { triggerTurn: boolean };
+    }> = [];
+    const mockPi = {
+      sendMessage(
+        msg: { customType: string; content: string; display: boolean },
+        options: { triggerTurn: boolean },
+      ) {
+        dispatched.push({ msg, options });
+      },
+    };
+    const saved = process.cwd();
+    process.chdir(base);
+
+    try {
+      await handleDebug("Login fails on Safari", ctx as any, mockPi as any);
+
+      assert.equal(ctx.notifications[0].level, "info");
+      assert.match(ctx.notifications[0].message, /Debug session started: login-fails-on-safari/);
+      assert.match(ctx.notifications[0].message, /dispatchMode=find_and_fix/);
+      assert.equal(dispatched.length, 1);
+      assert.equal(dispatched[0].msg.customType, "gsd-debug-start");
+      assert.equal(dispatched[0].msg.display, false);
+      assert.equal(dispatched[0].options.triggerTurn, true);
+      assert.match(dispatched[0].msg.content, /`find_and_fix`/);
+      assert.match(dispatched[0].msg.content, /login-fails-on-safari/);
+      assert.match(dispatched[0].msg.content, /Login fails on Safari/);
+    } finally {
+      process.chdir(saved);
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
   test("list shows persisted session summaries with lifecycle metadata", async () => {
     const base = makeBase();
     const ctx = createMockCtx();