gsd-pi 2.72.0 → 2.73.0-dev.27730dc

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');
+});

package/src/resources/extensions/gsd/tests/prompt-loader-working-directory.test.ts

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt normalizes workingDirectory backslashes for bash-friendly prompts (#4048)", () => {
+  const prompt = loadPrompt("research-milestone", {
+    milestoneId: "M001",
+    milestoneTitle: "Windows path fix",
+    workingDirectory: "C:\\Dev\\NB\\TR",
+    inlinedContext: "context",
+    skillActivation: "skill activation",
+    skillDiscoveryMode: "off",
+    skillDiscoveryInstructions: " disabled",
+  });
+
+  assert.match(prompt, /Your working directory is `C:\/Dev\/NB\/TR`/);
+  assert.doesNotMatch(prompt, /C:\\Dev\\NB\\TR/);
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -0,0 +1,97 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  getPendingGate,
+  resetWriteGateState,
+  shouldBlockContextArtifactSave,
+} from "../bootstrap/write-gate.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-depth-gate-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
+  const dir = makeTempDir("manual");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi);
+
+  const questionId = "depth_verification_M001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  const toolCallHandlers = handlers.get("tool_call");
+  const toolResultHandlers = handlers.get("tool_result");
+  assert.ok(toolCallHandlers?.length, "tool_call handler should be registered");
+  assert.ok(toolResultHandlers?.length, "tool_result handler should be registered");
+
+  for (const handler of toolCallHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+    });
+  }
+
+  assert.equal(getPendingGate(), questionId, "gate should be set even without guided-flow state");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    true,
+    "milestone context should still be blocked before confirmation",
+  );
+
+  for (const handler of toolResultHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming the depth question should clear the pending gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    false,
+    "question-id milestone inference should unlock the matching milestone context write",
+  );
+});

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -0,0 +1,41 @@
+/**
+ * stale-slice-rows.test.ts — #3658
+ *
+ * Verify that state.ts contains slice-level status reconciliation that
+ * updates stale DB rows (status "pending") when disk artifacts (SUMMARY)
+ * prove the slice is complete. Without this, the dependency resolver builds
+ * doneSliceIds from stale DB rows and downstream slices stay blocked.
+ */
+
+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 sourceFile = join(__dirname, "..", "state.ts");
+
+describe("stale slice row reconciliation (#3658)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports updateSliceStatus from gsd-db", () => {
+    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
+  });
+
+  test("checks isStatusDone before reconciling slice rows", () => {
+    assert.match(source, /isStatusDone\(dbSlice\.status\)/);
+  });
+
+  test("resolves SUMMARY file to detect completed slices on disk", () => {
+    assert.match(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
+  });
+
+  test("calls updateSliceStatus to reconcile stale rows", () => {
+    assert.match(source, /updateSliceStatus\(mid,\s*dbSlice\.id,\s*["']complete["']\)/);
+  });
+
+  test("references issue #3599 in reconciliation comment", () => {
+    assert.match(source, /#3599/);
+  });
+});

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Regression tests for subagent model preference wiring.
+ *
+ * Fixes: subagent_model config in reactive_execution was validated and stored
+ * but never passed through to subagent dispatch instruction strings, so the
+ * executing agent autonomously chose "sonnet" instead of the configured model.
+ *
+ * Issue: gsd-build/gsd-2#4078
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { validatePreferences } from "../preferences-validation.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+
+// ─── Preference Validation ────────────────────────────────────────────────
+
+test("reactive_execution: subagent_model is preserved in validated preferences", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "claude-opus-4-6",
+    },
+  });
+  assert.equal(result.errors.length, 0);
+  assert.equal(
+    result.preferences.reactive_execution?.subagent_model,
+    "claude-opus-4-6",
+    "subagent_model should be preserved through validation",
+  );
+});
+
+test("reactive_execution: subagent_model rejects empty string", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "",
+    } as any,
+  });
+  assert.ok(
+    result.errors.some((e) => e.includes("subagent_model")),
+    "empty subagent_model should produce a validation error",
+  );
+});
+
+// ─── Structural: Prompt Builders Accept subagentModel ────────────────────
+
+test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
+  assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildReactiveExecutePrompt should accept a subagentModel parameter",
+  );
+});
+
+test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
+  assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
+  );
+});
+
+test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
+  assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildGateEvaluatePrompt should accept a subagentModel parameter",
+  );
+});
+
+// ─── Structural: Instruction Strings Inject Model ────────────────────────
+
+test("buildReactiveExecutePrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildReactiveExecutePrompt body should reference subagentModel",
+  );
+  // The instruction line must be dynamic (not a plain string literal)
+  assert.ok(
+    !fnBody.includes('"Use this as the prompt for a `subagent` call:"'),
+    "instruction should not be a plain static string — model must be injectable",
+  );
+});
+
+test("buildParallelResearchSlicesPrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildParallelResearchSlicesPrompt body should reference subagentModel",
+  );
+});
+
+test("buildGateEvaluatePrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildGateEvaluatePrompt body should reference subagentModel",
+  );
+});
+
+// ─── Structural: Dispatch Wires Model to Prompt Builders ─────────────────
+
+test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
+  // Find the reactive-execute dispatch rule
+  const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
+  assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
+  const ruleBlock = dispatchSrc.slice(ruleStart, ruleStart + 1000);
+  assert.ok(
+    ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
+    "reactive-execute rule should resolve and pass the subagent model",
+  );
+});
+
+test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
+  const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
+  assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
+  // The call site should pass a model argument (not just 4 args)
+  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  assert.ok(
+    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
+    "buildParallelResearchSlicesPrompt call should include model argument",
+  );
+});
+
+test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
+  const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
+  assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
+  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  assert.ok(
+    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
+    "buildGateEvaluatePrompt call should include model argument",
+  );
+});
+
+// ─── Integration: Prompt Output Contains Model String ────────────────────
+
+test("buildReactiveExecutePrompt: output contains model string when subagentModel provided", async (t) => {
+  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(join(gsd, "tasks"), { recursive: true });
+
+  writeFileSync(
+    join(gsd, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "**Goal:** Verify model injection",
+      "**Demo:** Model appears in subagent prompt",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Task One** `est:15m`",
+      "  Do something.",
+      "",
+    ].join("\n"),
+  );
+
+  writeFileSync(
+    join(gsd, "tasks", "T01-PLAN.md"),
+    [
+      "# T01: Task One",
+      "",
+      "## Description",
+      "Do something.",
+      "",
+      "## Inputs",
+      "",
+      "- `src/config.json` — Config",
+      "",
+      "## Expected Output",
+      "",
+      "- `src/out.ts` — Result",
+    ].join("\n"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "M001", "Test Milestone", "S01", "Test Slice",
+    ["T01"], repo, "claude-opus-4-6",
+  );
+
+  assert.ok(
+    prompt.includes('model: "claude-opus-4-6"'),
+    `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
+  );
+});
+
+test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
+  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-none-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(join(gsd, "tasks"), { recursive: true });
+
+  writeFileSync(
+    join(gsd, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "**Goal:** Verify no model when omitted",
+      "**Demo:** No model string",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Task One** `est:15m`",
+      "  Do something.",
+      "",
+    ].join("\n"),
+  );
+
+  writeFileSync(
+    join(gsd, "tasks", "T01-PLAN.md"),
+    [
+      "# T01: Task One",
+      "",
+      "## Description",
+      "Do something.",
+      "",
+      "## Inputs",
+      "",
+      "- `src/config.json` — Config",
+      "",
+      "## Expected Output",
+      "",
+      "- `src/out.ts` — Result",
+    ].join("\n"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "M001", "Test Milestone", "S01", "Test Slice",
+    ["T01"], repo,
+    // no subagentModel
+  );
+
+  assert.ok(
+    !prompt.includes('with model:'),
+    "Prompt should not contain model instruction when subagentModel is omitted",
+  );
+});

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -180,6 +180,14 @@ export function renderSummaryContent(
   milestoneId: string,
   evidence?: Array<{ command: string; exitCode?: number; exit_code?: number; verdict: string; durationMs?: number; duration_ms?: number }>,
 ): string {
+  // If the task already has a fully rendered summary (written by handleCompleteTask's
+  // renderSummaryMarkdown), use it as-is. That content already includes frontmatter,
+  // heading, and all sections. Re-wrapping it inside a second frontmatter/heading
+  // envelope produces double frontmatter and duplicate sections.
+  if (taskRow.full_summary_md && taskRow.full_summary_md.trimStart().startsWith("---")) {
+    return taskRow.full_summary_md;
+  }
+
   // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
   const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
     ? taskRow.key_files.map(f => `  - ${f}`).join("\n")

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -548,13 +548,39 @@ export function removeWorktree(
   }
 }
 
-/** Paths to skip in all worktree diffs (internal/runtime artifacts). */
-const SKIP_PATHS = [".gsd/worktrees/", ".gsd/runtime/", ".gsd/activity/"];
-const SKIP_EXACT = [".gsd/STATE.md", ".gsd/auto.lock", ".gsd/metrics.json"];
+/**
+ * Paths to skip in all worktree diffs (internal/runtime artifacts).
+ *
+ * NOTE: These arrays must stay synchronized with GSD_RUNTIME_PATTERNS in gitignore.ts.
+ * That file is the canonical source of truth for runtime ignore patterns.
+ * This module uses a split representation (paths/exact/prefixes) for efficient matching.
+ */
+const SKIP_PATHS = [
+  ".gsd/worktrees/",
+  ".gsd/runtime/",
+  ".gsd/activity/",
+  ".gsd/forensics/",
+  ".gsd/parallel/",
+  ".gsd/journal/",
+];
+const SKIP_EXACT = [
+  ".gsd/STATE.md",
+  ".gsd/auto.lock",
+  ".gsd/metrics.json",
+  ".gsd/state-manifest.json",
+  ".gsd/doctor-history.jsonl",
+  ".gsd/event-log.jsonl",
+];
+/** File prefixes to skip (for wildcard patterns like completed-units*.json, gsd.db*). */
+const SKIP_PREFIXES = [
+  ".gsd/completed-units",
+  ".gsd/gsd.db",
+];
 
 function shouldSkipPath(filePath: string): boolean {
   if (SKIP_PATHS.some(p => filePath.startsWith(p))) return true;
   if (SKIP_EXACT.includes(filePath)) return true;
+  if (SKIP_PREFIXES.some(p => filePath.startsWith(p))) return true;
   return false;
 }