gsd-pi 2.72.0-dev.de4c4b3 → 2.73.0

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

@@ -15,6 +15,7 @@ import {
   getRequirementById,
   getActiveDecisions,
   getActiveRequirements,
+  getTask,
   transaction,
   _getAdapter,
   _resetProvider,
@@ -43,6 +44,16 @@ function cleanup(dbPath: string): void {
   }
 }
 
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const original = process.platform;
+  Object.defineProperty(process, 'platform', { value: platform });
+  try {
+    return fn();
+  } finally {
+    Object.defineProperty(process, 'platform', { value: original });
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // gsd-db tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -279,6 +290,26 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: mmap stays disabled on darwin file-backed DBs', () => {
+    const darwinDbPath = tempDbPath();
+    withPlatform('darwin', () => {
+      openDatabase(darwinDbPath);
+      const adapter = _getAdapter()!;
+      const mmap = adapter.prepare('PRAGMA mmap_size').get();
+      assert.deepStrictEqual(mmap?.['mmap_size'], 0, 'darwin should leave mmap_size disabled');
+      cleanup(darwinDbPath);
+    });
+
+    const linuxDbPath = tempDbPath();
+    withPlatform('linux', () => {
+      openDatabase(linuxDbPath);
+      const adapter = _getAdapter()!;
+      const mmap = adapter.prepare('PRAGMA mmap_size').get();
+      assert.deepStrictEqual(mmap?.['mmap_size'], 67108864, 'non-darwin should still enable mmap_size');
+      cleanup(linuxDbPath);
+    });
+  });
+
   test('gsd-db: transaction rollback on error', () => {
     openDatabase(':memory:');
 
@@ -329,6 +360,79 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test('gsd-db: recreates missing verification evidence dedup index after removing duplicate rows', () => {
+    const dbPath = tempDbPath();
+    openDatabase(dbPath);
+
+    let adapter = _getAdapter()!;
+    adapter.prepare("INSERT INTO milestones (id, created_at) VALUES (?, '')").run('M001');
+    adapter.prepare("INSERT INTO slices (milestone_id, id, created_at) VALUES (?, ?, '')").run('M001', 'S01');
+    adapter.prepare("INSERT INTO tasks (milestone_id, slice_id, id) VALUES (?, ?, ?)").run('M001', 'S01', 'T01');
+    adapter.exec('DROP INDEX IF EXISTS idx_verification_evidence_dedup');
+
+    const insertEvidence = adapter.prepare(
+      `INSERT INTO verification_evidence (
+        task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    insertEvidence.run('T01', 'S01', 'M001', 'npm test', 1, 'fail', 125, '2026-04-12T00:00:00.000Z');
+    insertEvidence.run('T01', 'S01', 'M001', 'npm test', 1, 'fail', 125, '2026-04-12T00:00:01.000Z');
+    insertEvidence.run('T01', 'S01', 'M001', 'npm run lint', 0, 'pass', 90, '2026-04-12T00:00:02.000Z');
+
+    closeDatabase();
+
+    assert.equal(openDatabase(dbPath), true, 'openDatabase should repair legacy duplicate evidence rows');
+
+    adapter = _getAdapter()!;
+    const countRow = adapter.prepare(
+      `SELECT count(*) as cnt
+       FROM verification_evidence
+       WHERE task_id = ? AND slice_id = ? AND milestone_id = ? AND command = ? AND verdict = ?`,
+    ).get('T01', 'S01', 'M001', 'npm test', 'fail');
+    assert.equal(countRow?.['cnt'], 1, 'duplicate verification evidence rows should be deduplicated before index creation');
+
+    const indexRow = adapter.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_verification_evidence_dedup'",
+    ).get();
+    assert.equal(indexRow?.['name'], 'idx_verification_evidence_dedup', 'dedup index should be recreated on reopen');
+
+    cleanup(dbPath);
+  });
+
+  test('gsd-db: rowToTask tolerates legacy comma-separated task arrays', () => {
+    openDatabase(':memory:');
+
+    const adapter = _getAdapter()!;
+    adapter.prepare("INSERT INTO milestones (id, created_at) VALUES (?, '')").run('M001');
+    adapter.prepare("INSERT INTO slices (milestone_id, id, created_at) VALUES (?, ?, '')").run('M001', 'S01');
+    adapter.prepare(
+      `INSERT INTO tasks (
+        milestone_id, slice_id, id, key_files, key_decisions, files, inputs, expected_output
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      'M001',
+      'S01',
+      'T01',
+      '[]',
+      '[]',
+      'tests/test_verify.py, config.yaml, configs/roster_2026-05-11.yaml',
+      'tests/test_verify.py',
+      'reports/summary.md, artifacts/output.json',
+    );
+
+    const task = getTask('M001', 'S01', 'T01');
+    assert.ok(task, 'task should load successfully from DB');
+    assert.deepEqual(task?.files, [
+      'tests/test_verify.py',
+      'config.yaml',
+      'configs/roster_2026-05-11.yaml',
+    ]);
+    assert.deepEqual(task?.inputs, ['tests/test_verify.py']);
+    assert.deepEqual(task?.expected_output, ['reports/summary.md', 'artifacts/output.json']);
+
+    closeDatabase();
+  });
+
   test('gsd-db: query wrappers return null/empty when DB unavailable', () => {
     // Ensure DB is closed
     closeDatabase();
@@ -347,15 +451,13 @@ describe('gsd-db', () => {
     assert.deepStrictEqual(ar, [], 'getActiveRequirements returns [] when DB closed');
   });
 
-  test('gsd-db: wasDbOpenAttempted tracks openDatabase calls', () => {
-    // wasDbOpenAttempted should return true once openDatabase has been called
-    // (previous tests in this suite already called openDatabase, so the flag is set)
+  test('gsd-db: closeDatabase resets wasDbOpenAttempted after an intentional close', () => {
+    openDatabase(':memory:');
     assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should be true after openDatabase was called');
 
-    // Verify the flag persists even after closeDatabase
     closeDatabase();
     assert.ok(!isDbAvailable(), 'DB should not be available after close');
-    assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should remain true after closeDatabase');
+    assert.ok(!wasDbOpenAttempted(), 'wasDbOpenAttempted should reset after closeDatabase');
   });
 
   // ─── Final Report ──────────────────────────────────────────────────────────

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

@@ -248,23 +248,25 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    13,
-    "exactly 13 runtime exclusion paths"
+    15,
+    "exactly 15 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
+    ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json",
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm",
-    ".gsd/gsd.db-wal",
+    ".gsd/gsd.db*",
     ".gsd/journal/",
     ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
   ];
 

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -427,3 +427,66 @@ test("formatDoctorFindings shows findings with appropriate icons", () => {
   assert.ok(output.includes("1 warning"));
   assert.ok(output.includes("1 fixed"));
 });
+
+// ─── Regression #3891 — alibaba-coding-plan missing from PROVIDER_REGISTRY ───────
+//
+// Before this fix, `alibaba-coding-plan` was not in PROVIDER_REGISTRY, causing
+// `/gsd keys add alibaba-coding-plan` to silently fail (provider not found).
+// alibaba-dashscope is the new standalone provider added in the same PR.
+
+test("regression #3891 — alibaba-coding-plan is in PROVIDER_REGISTRY", () => {
+  const provider = findProvider("alibaba-coding-plan");
+  assert.ok(provider, "alibaba-coding-plan must be in PROVIDER_REGISTRY for /gsd keys add to work");
+  assert.equal(provider.id, "alibaba-coding-plan");
+  assert.equal(provider.category, "llm");
+  assert.equal(provider.envVar, "ALIBABA_API_KEY");
+});
+
+test("alibaba-dashscope is in PROVIDER_REGISTRY", () => {
+  const provider = findProvider("alibaba-dashscope");
+  assert.ok(provider, "alibaba-dashscope must be in PROVIDER_REGISTRY for /gsd keys add to work");
+  assert.equal(provider.id, "alibaba-dashscope");
+  assert.equal(provider.category, "llm");
+  assert.equal(provider.envVar, "DASHSCOPE_API_KEY");
+});
+
+test("alibaba-coding-plan and alibaba-dashscope are separate providers (different env vars)", () => {
+  const codingPlan = findProvider("alibaba-coding-plan");
+  const dashscope = findProvider("alibaba-dashscope");
+  assert.ok(codingPlan, "alibaba-coding-plan must exist");
+  assert.ok(dashscope, "alibaba-dashscope must exist");
+  assert.notEqual(
+    codingPlan.envVar,
+    dashscope.envVar,
+    "alibaba-coding-plan and alibaba-dashscope must use different env vars",
+  );
+});
+
+test("getAllKeyStatuses includes alibaba-coding-plan", () => {
+  const auth = makeAuth();
+  const statuses = getAllKeyStatuses(auth);
+  const found = statuses.find((s) => s.provider.id === "alibaba-coding-plan");
+  assert.ok(found, "getAllKeyStatuses must include alibaba-coding-plan");
+});
+
+test("getAllKeyStatuses includes alibaba-dashscope", () => {
+  const auth = makeAuth();
+  const statuses = getAllKeyStatuses(auth);
+  const found = statuses.find((s) => s.provider.id === "alibaba-dashscope");
+  assert.ok(found, "getAllKeyStatuses must include alibaba-dashscope");
+});
+
+test("getAllKeyStatuses detects DASHSCOPE_API_KEY for alibaba-dashscope (failure path: missing key shows not configured)", () => {
+  const saved = process.env.DASHSCOPE_API_KEY;
+  delete process.env.DASHSCOPE_API_KEY;
+  try {
+    const auth = makeAuth();
+    const statuses = getAllKeyStatuses(auth);
+    const found = statuses.find((s) => s.provider.id === "alibaba-dashscope");
+    assert.ok(found);
+    assert.equal(found.configured, false);
+    assert.equal(found.source, "none");
+  } finally {
+    if (saved !== undefined) process.env.DASHSCOPE_API_KEY = saved;
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Regression tests for memory pressure monitoring (#3331) and
+ * stuck detection persistence (#3704) in auto/loop.ts.
+ */
+
+import { describe, 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 loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
+
+describe("memory pressure monitoring (#3331)", () => {
+  test("checkMemoryPressure function exists", () => {
+    assert.match(loopSource, /function checkMemoryPressure/);
+  });
+
+  test("MEMORY_PRESSURE_THRESHOLD constant is defined", () => {
+    assert.match(loopSource, /MEMORY_PRESSURE_THRESHOLD\s*=\s*0\.\d+/);
+  });
+
+  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
+    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
+  });
+
+  test("memory pressure triggers graceful stopAuto", () => {
+    assert.match(loopSource, /mem\.pressured/);
+    assert.match(loopSource, /Stopping gracefully to prevent OOM/);
+  });
+});
+
+describe("stuck detection persistence (#3704)", () => {
+  test("loadStuckState function exists", () => {
+    assert.match(loopSource, /function loadStuckState/);
+  });
+
+  test("saveStuckState function exists", () => {
+    assert.match(loopSource, /function saveStuckState/);
+  });
+
+  test("loopState initialized from persisted state", () => {
+    assert.match(loopSource, /loadStuckState\(s\.basePath\)/);
+  });
+
+  test("stuck state saved after each iteration", () => {
+    assert.match(loopSource, /saveStuckState\(s\.basePath,\s*loopState\)/);
+  });
+
+  test("stuck state file path uses runtime directory", () => {
+    assert.match(loopSource, /stuck-state\.json/);
+  });
+});

package/src/resources/extensions/gsd/tests/plan-milestone-artifact-verification.test.ts

@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { verifyExpectedArtifact } from "../auto-recovery.ts";
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-milestone-artifact-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeRoadmap(base: string, milestoneId: string, content: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, `${milestoneId}-ROADMAP.md`), content, "utf-8");
+}
+
+test("#3405: plan-milestone roadmap stub does not count as a verified artifact", () => {
+  const base = createFixtureBase();
+  try {
+    writeRoadmap(base, "M001", [
+      "# M001: Placeholder",
+      "",
+      "**Vision:** Stub only.",
+      "",
+      "## Slices",
+      "",
+      "_TBD_",
+      "",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-milestone", "M001", base);
+    assert.equal(result, false, "zero-slice roadmap stubs must fail verification");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("#3405: plan-milestone roadmap with real slices still passes artifact verification", () => {
+  const base = createFixtureBase();
+  try {
+    writeRoadmap(base, "M001", [
+      "# M001: Real roadmap",
+      "",
+      "**Vision:** Real work.",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-milestone", "M001", base);
+    assert.equal(result, true, "real roadmap slices should keep passing verification");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -0,0 +1,34 @@
+/**
+ * Regression test for #3869: normal post-unit flow should rebuild STATE.md
+ * before syncing worktree state back to the project root.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
+
+test("auto-post-unit imports rebuildState", () => {
+  assert.ok(
+    source.includes('import { rebuildState } from "./doctor.js";'),
+    "auto-post-unit.ts should import rebuildState from doctor.ts",
+  );
+});
+
+test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
+  const fnStart = source.indexOf("export async function postUnitPreVerification");
+  assert.ok(fnStart > 0, "postUnitPreVerification should exist");
+
+  const section = source.slice(fnStart, fnStart + 8000);
+  const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
+  const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
+
+  assert.ok(rebuildIdx > 0, "postUnitPreVerification should rebuild STATE.md after unit completion");
+  assert.ok(syncIdx > 0, "postUnitPreVerification should sync worktree state back to the project root");
+  assert.ok(
+    rebuildIdx < syncIdx,
+    "STATE.md rebuild should happen before worktree sync so synced state is fresh",
+  );
+});

package/src/resources/extensions/gsd/tests/preferences-formatting.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Tests for formatSkillRef — pure formatting logic for skill references
+ * in the system prompt. Moved from preferences-skills.ts to preferences-types.ts
+ * to break the preferences ↔ preferences-skills circular dependency.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { formatSkillRef } from "../preferences-types.ts";
+import type { SkillResolution } from "../preferences-types.ts";
+
+function makeResolutions(entries: [string, Partial<SkillResolution>][]): Map<string, SkillResolution> {
+  const map = new Map<string, SkillResolution>();
+  for (const [key, partial] of entries) {
+    map.set(key, {
+      original: partial.original ?? key,
+      resolvedPath: partial.resolvedPath ?? null,
+      method: partial.method ?? "unresolved",
+    });
+  }
+  return map;
+}
+
+describe("formatSkillRef", () => {
+  test("marks unresolved references with a warning", () => {
+    const resolutions = makeResolutions([
+      ["my-skill", { method: "unresolved" }],
+    ]);
+    const result = formatSkillRef("my-skill", resolutions);
+    assert.match(result, /my-skill/);
+    assert.match(result, /not found/);
+  });
+
+  test("marks unknown references (not in map) with a warning", () => {
+    const resolutions = new Map<string, SkillResolution>();
+    const result = formatSkillRef("unknown-skill", resolutions);
+    assert.match(result, /unknown-skill/);
+    assert.match(result, /not found/);
+  });
+
+  test("returns bare ref for absolute-path resolution", () => {
+    const resolutions = makeResolutions([
+      ["/home/user/skills/SKILL.md", {
+        method: "absolute-path",
+        resolvedPath: "/home/user/skills/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("/home/user/skills/SKILL.md", resolutions);
+    assert.equal(result, "/home/user/skills/SKILL.md");
+  });
+
+  test("returns bare ref for absolute-dir resolution", () => {
+    const resolutions = makeResolutions([
+      ["/home/user/skills/my-skill", {
+        method: "absolute-dir",
+        resolvedPath: "/home/user/skills/my-skill/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("/home/user/skills/my-skill", resolutions);
+    assert.equal(result, "/home/user/skills/my-skill");
+  });
+
+  test("shows resolved path for user-skill resolution", () => {
+    const resolutions = makeResolutions([
+      ["code-review", {
+        method: "user-skill",
+        resolvedPath: "/home/user/.claude/skills/code-review/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("code-review", resolutions);
+    assert.match(result, /code-review/);
+    assert.match(result, /\.claude\/skills\/code-review\/SKILL\.md/);
+  });
+
+  test("shows resolved path for project-skill resolution", () => {
+    const resolutions = makeResolutions([
+      ["lint-fix", {
+        method: "project-skill",
+        resolvedPath: "/repo/.gsd/skills/lint-fix/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("lint-fix", resolutions);
+    assert.match(result, /lint-fix/);
+    assert.match(result, /\.gsd\/skills\/lint-fix\/SKILL\.md/);
+  });
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -10,10 +10,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   validatePreferences,
   applyModeDefaults,
   getIsolationMode,
+  loadEffectiveGSDPreferences,
   parsePreferencesMarkdown,
   _resetParseWarningFlag,
 } from "../preferences.ts";
@@ -501,6 +505,55 @@ test("experimental.rtk parses correctly from preferences markdown", () => {
   assert.equal(prefs!.experimental?.rtk, true);
 });
 
+test("loadEffectiveGSDPreferences preserves experimental prefs across global+project merge", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "preferences.md"),
+      [
+        "---",
+        "version: 1",
+        "experimental:",
+        "  rtk: true",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "git:",
+        "  isolation: none",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.experimental?.rtk, true);
+    assert.equal(loaded!.preferences.git?.isolation, "none");
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("experimental.rtk defaults to off in new project preferences", () => {
   // No experimental key → feature is disabled
   const content = "---\nversion: 1\n---\n";

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -5,7 +5,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { renderPlanContent, renderRoadmapContent } from '../workflow-projections.ts';
+import { renderPlanContent, renderRoadmapContent, renderSummaryContent } from '../workflow-projections.ts';
 import type { SliceRow, TaskRow } from '../gsd-db.ts';
 
 // ─── Helpers ─────────────────────────────────────────────────────────────
@@ -172,3 +172,98 @@ test('renderRoadmapContent: slice with status "pending" shows ⬜', () => {
 
   assert.ok(content.includes('⬜'), 'pending slice should show ⬜');
 });
+
+// ─── renderSummaryContent: double-frontmatter regression ─────────────────
+
+test('renderSummaryContent: uses full_summary_md as-is when it contains frontmatter', () => {
+  const existingSummary = [
+    '---',
+    'id: T01',
+    'parent: S01',
+    'milestone: M001',
+    'key_files:',
+    '  - src/thing.ts',
+    'verification_result: passed',
+    'completed_at: 2026-01-01T00:00:00Z',
+    'blocker_discovered: false',
+    '---',
+    '',
+    '# T01: Did the thing',
+    '',
+    '**One-liner summary**',
+    '',
+    '## What Happened',
+    '',
+    'Narrative content here.',
+    '',
+    '## Deviations',
+    '',
+    'None.',
+    '',
+  ].join('\n');
+
+  const task = makeTaskRow({
+    id: 'T01',
+    status: 'complete',
+    title: 'Did the thing',
+    one_liner: 'One-liner summary',
+    narrative: 'Narrative content here.',
+    full_summary_md: existingSummary,
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Must NOT produce double frontmatter
+  const frontmatterCount = (result.match(/^---$/gm) || []).length;
+  assert.equal(frontmatterCount, 2, `Expected exactly 2 frontmatter delimiters (one block), got ${frontmatterCount}`);
+
+  // Must NOT produce double H1 heading
+  const h1Count = (result.match(/^# T01:/gm) || []).length;
+  assert.equal(h1Count, 1, `Expected exactly 1 H1 heading, got ${h1Count}`);
+
+  // Content should match the full_summary_md exactly
+  assert.equal(result, existingSummary);
+});
+
+test('renderSummaryContent: synthesizes from DB columns when full_summary_md is empty', () => {
+  const task = makeTaskRow({
+    id: 'T01',
+    status: 'complete',
+    title: 'Did the thing',
+    one_liner: 'One-liner summary',
+    narrative: 'Built the feature.',
+    full_summary_md: '',
+    deviations: 'Deviated slightly.',
+    known_issues: 'None.',
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Should have exactly one frontmatter block
+  const frontmatterCount = (result.match(/^---$/gm) || []).length;
+  assert.equal(frontmatterCount, 2, 'Should have one frontmatter block (2 delimiters)');
+
+  // Should contain synthesized sections
+  assert.ok(result.includes('## What Happened'), 'Should have What Happened section');
+  assert.ok(result.includes('Built the feature.'), 'Should use narrative for content');
+  assert.ok(result.includes('## Deviations'), 'Should have Deviations section');
+  assert.ok(result.includes('Deviated slightly.'), 'Should include deviation text');
+});
+
+test('renderSummaryContent: synthesizes when full_summary_md has no frontmatter', () => {
+  const task = makeTaskRow({
+    id: 'T02',
+    status: 'complete',
+    title: 'Partial summary',
+    narrative: 'Did some work.',
+    full_summary_md: 'Just a plain text summary with no frontmatter.',
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Should synthesize with proper frontmatter since the stored md lacks it
+  assert.ok(result.startsWith('---'), 'Should start with frontmatter');
+  assert.ok(result.includes('id: T02'), 'Should have task ID in frontmatter');
+  assert.ok(result.includes('## What Happened'), 'Should have What Happened section');
+  assert.ok(result.includes('Did some work.'), 'Should use narrative');
+});