gsd-pi 2.81.0 → 2.82.0-dev.ed17d078d

package/src/resources/extensions/gsd/tests/decisions-stop-table-writes.test.ts

@@ -0,0 +1,348 @@
+// ADR-013 Phase 6 cutover (Stage 3) — destructive lock-in.
+//
+// After this stage, new decisions written via gsd_save_decision land ONLY in
+// the memories table. The decisions table receives no new rows; its existing
+// rows remain for backwards-compat reads until #5756 drops the table.
+//
+// Tests cover five properties:
+//   1. New saveDecisionToDb call does NOT insert into the decisions table
+//   2. The new decision DOES appear as a memory row with sourceDecisionId
+//   3. The rendered DECISIONS.md projection includes the new decision
+//   4. Pre-existing decisions-table rows are untouched
+//   5. Decision IDs are monotonic across both surfaces (max of either + 1)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getAdapter,
+  closeDatabase,
+  insertDecision,
+  openDatabase,
+} from "../gsd-db.ts";
+import { saveDecisionToDb } from "../db-writer.ts";
+import {
+  getAllDecisionsFromMemories,
+  queryDecisions,
+} from "../context-store.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-decisions-stage3-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function countDecisionRows(): number {
+  const adapter = _getAdapter();
+  if (!adapter) return 0;
+  const row = adapter
+    .prepare("SELECT COUNT(*) as n FROM decisions")
+    .get() as { n: number };
+  return row.n;
+}
+
+function seedLegacyDecision(args: {
+  id: string;
+  when_context: string;
+  scope: string;
+  decision: string;
+  choice: string;
+  rationale: string;
+  superseded_by?: string | null;
+}): void {
+  insertDecision({
+    id: args.id,
+    when_context: args.when_context,
+    scope: args.scope,
+    decision: args.decision,
+    choice: args.choice,
+    rationale: args.rationale,
+    revisable: "Yes",
+    made_by: "agent",
+    superseded_by: args.superseded_by ?? null,
+  });
+}
+
+// ─── Core invariants ────────────────────────────────────────────────────────
+
+test("saveDecisionToDb no longer writes to the decisions table", async () => {
+  const base = makeTmpBase();
+  try {
+    const before = countDecisionRows();
+    assert.equal(before, 0);
+
+    await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Stage 3 destructive: memories-only writes",
+        choice: "Drop the upsertDecision call",
+        rationale: "Cutover step required by ADR-013 Phase 6",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const after = countDecisionRows();
+    assert.equal(after, 0, "decisions table must remain empty after Stage 3 save");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("saveDecisionToDb writes the new decision into memories with sourceDecisionId", async () => {
+  const base = makeTmpBase();
+  try {
+    const { id } = await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Use atomic file writes",
+        choice: "atomicWriteSync",
+        rationale: "crash-safe markdown projections",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const fromMemories = getAllDecisionsFromMemories();
+    assert.equal(fromMemories.length, 1);
+    assert.equal(fromMemories[0]?.id, id);
+    assert.equal(fromMemories[0]?.decision, "Use atomic file writes");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("DECISIONS.md projection includes the memory-only decision", async () => {
+  const base = makeTmpBase();
+  try {
+    await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Adopt SQLite",
+        choice: "better-sqlite3",
+        rationale: "synchronous + native",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const md = readFileSync(join(base, ".gsd", "DECISIONS.md"), "utf-8");
+    assert.match(md, /\| D001 \|/);
+    assert.match(md, /Adopt SQLite/);
+    assert.match(md, /# Decisions Register/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Existing decisions table is preserved ──────────────────────────────────
+
+test("pre-existing decisions-table rows are untouched by Stage 3 saves", async () => {
+  const base = makeTmpBase();
+  try {
+    // Seed two legacy decisions directly into the table — simulates a
+    // pre-cutover project.
+    seedLegacyDecision({
+      id: "D001",
+      when_context: "M001 historical",
+      scope: "M001",
+      decision: "Legacy decision one",
+      choice: "A",
+      rationale: "r1",
+    });
+    seedLegacyDecision({
+      id: "D002",
+      when_context: "M001 historical",
+      scope: "M001",
+      decision: "Legacy decision two",
+      choice: "B",
+      rationale: "r2",
+    });
+    assert.equal(countDecisionRows(), 2);
+
+    // New save via the cutover path.
+    await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "Post-cutover decision",
+        choice: "C",
+        rationale: "r3",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    // Decisions table unchanged.
+    assert.equal(countDecisionRows(), 2);
+
+    // Legacy reads still see the pre-existing rows.
+    const fromLegacy = queryDecisions();
+    assert.equal(fromLegacy.length, 2);
+    assert.deepEqual(
+      fromLegacy.map((d) => d.id).sort(),
+      ["D001", "D002"],
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Cross-surface ID monotonicity ─────────────────────────────────────────
+
+test("decision IDs are monotonic across legacy table + memory surfaces", async () => {
+  const base = makeTmpBase();
+  try {
+    // Pre-cutover project with D001..D005 in the legacy table (no memory
+    // backfill yet — simulates an upgrade that hasn't run backfill).
+    for (let i = 1; i <= 5; i++) {
+      seedLegacyDecision({
+        id: `D${String(i).padStart(3, "0")}`,
+        when_context: "historical",
+        scope: "M001",
+        decision: `Decision ${i}`,
+        choice: "x",
+        rationale: "y",
+      });
+    }
+    assert.equal(countDecisionRows(), 5);
+
+    // First Stage 3 save: must pick the next-after-table ID.
+    const a = await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "First post-cutover",
+        choice: "A",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(a.id, "D006", "first cutover save must follow the legacy table max (D005 -> D006)");
+
+    // Second save: must pick the next-after-memory ID.
+    const b = await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "Second post-cutover",
+        choice: "B",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(b.id, "D007", "second cutover save must follow memory max (D006 -> D007)");
+
+    // Decisions table still has only the original five.
+    assert.equal(countDecisionRows(), 5);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("next-ID falls back to D001 when both surfaces are empty", async () => {
+  const base = makeTmpBase();
+  try {
+    const { id } = await saveDecisionToDb(
+      {
+        when_context: "M001",
+        scope: "M001",
+        decision: "First ever",
+        choice: "A",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(id, "D001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("next-ID skips beyond memory-only entries when the legacy table is empty", async () => {
+  const base = makeTmpBase();
+  try {
+    // Three memory-only saves on a fresh project.
+    const a = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "A", choice: "1", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+    const b = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "B", choice: "2", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+    const c = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "C", choice: "3", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+
+    assert.deepEqual([a.id, b.id, c.id], ["D001", "D002", "D003"]);
+    assert.equal(countDecisionRows(), 0, "no decisions-table writes despite three saves");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Defensive: malformed structured_fields don't break next-ID ────────────
+
+test("malformed structuredFields in memories are silently skipped during next-ID computation", async () => {
+  const base = makeTmpBase();
+  try {
+    // Insert a memory with broken JSON in structured_fields. The next-ID
+    // logic must not throw.
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter
+      .prepare(
+        "INSERT INTO memories (id, category, content, confidence, created_at, updated_at, structured_fields) VALUES ('mem-broken', 'architecture', 'oops', 0.5, datetime('now'), datetime('now'), '{\"sourceDecisionId\":\"D999\"')",
+      )
+      .run();
+
+    const { id } = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "Survivor", choice: "x", rationale: "y", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+
+    // Broken JSON for D999 doesn't parse, so the surfaced max stays at 0.
+    // The new save must still produce a valid sequential ID.
+    assert.equal(id, "D001");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -273,7 +273,16 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildLifecycle: () => ({}) as any,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+        }) as any,
       },
       {
         classification: "none",
@@ -378,7 +387,16 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildLifecycle: () => ({}) as any,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+        }) as any,
       },
       {
         classification: "none",

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for complete-milestone dispatch guards.
+
 /**
  * dispatch-complete-milestone-guard.test.ts — #4324
  */
@@ -74,3 +77,44 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.equal(result?.unitId, "M001");
   });
 });
+
+describe("complete phase dispatch guard (#5683)", () => {
+  let base = "";
+  const rule = DISPATCH_RULES.find((candidate) => candidate.name === "complete → stop");
+  assert.ok(rule, "complete phase terminal rule should exist");
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("dispatches complete-milestone when derived state is complete but DB milestone is still open", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "in_progress" });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
+  });
+
+  test("stops when derived state is complete and DB milestone is closed", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.reason, "All milestones complete.");
+  });
+});

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

@@ -14,6 +14,7 @@ import {
 import {
   saveDecisionToDb,
 } from '../db-writer.ts';
+import { getAllDecisionsFromMemories } from '../context-store.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -31,11 +32,14 @@ function cleanupDir(dir: string): void {
   } catch { /* swallow */ }
 }
 
-/** Query all decisions from the DB ordered by seq. */
+/**
+ * Query all decisions. ADR-013 Stage 3 (PR #5755): decisions are written
+ * exclusively to memories; this helper returns the same Decision shape the
+ * previous SELECT * FROM decisions produced so the assertions below stay
+ * one-line lookups.
+ */
 function queryAllDecisions(): Array<Record<string, unknown>> {
-  const adapter = _getAdapter();
-  if (!adapter) return [];
-  return adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
+  return getAllDecisionsFromMemories().map((d) => ({ ...d }));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -14,7 +14,6 @@ import {
   isDbAvailable,
   upsertRequirement,
   getRequirementById,
-  getDecisionById,
   _getAdapter,
   insertArtifact,
 } from '../gsd-db.ts';
@@ -26,6 +25,7 @@ import {
   nextDecisionId,
   nextRequirementId,
 } from '../db-writer.ts';
+import { getAllDecisionsFromMemories } from '../context-store.ts';
 import type { Requirement } from '../types.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -73,12 +73,16 @@ describe('gsd-tools', () => {
 
       assert.deepStrictEqual(result.id, 'D001', 'First decision should be D001');
 
-      // Verify DB row exists
-      const row = getDecisionById('D001');
-      assert.ok(row !== null, 'Decision D001 should exist in DB');
-      assert.deepStrictEqual(row!.scope, 'architecture', 'Decision scope should match');
-      assert.deepStrictEqual(row!.decision, 'Use SQLite for metadata', 'Decision text should match');
-      assert.deepStrictEqual(row!.choice, 'SQLite', 'Decision choice should match');
+      // ADR-013 Stage 3: decisions land in memories, not the legacy decisions
+      // table. Verify the memory row carries the same content.
+      const memoryDecisions = getAllDecisionsFromMemories();
+      assert.equal(memoryDecisions.length, 1, 'one memory row exists after save');
+      const memDecision = memoryDecisions[0];
+      assert.ok(memDecision, 'memory decision exists after save');
+      assert.equal(memDecision.id, 'D001');
+      assert.deepStrictEqual(memDecision.scope, 'architecture', 'memory decision scope should match');
+      assert.deepStrictEqual(memDecision.decision, 'Use SQLite for metadata', 'memory decision text should match');
+      assert.deepStrictEqual(memDecision.choice, 'SQLite', 'memory decision choice should match');
 
       // Verify DECISIONS.md was generated
       const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');

package/src/resources/extensions/gsd/tests/header-renderer.test.ts

@@ -0,0 +1,40 @@
+// Project/App: GSD-2
+// File Purpose: Visual contract tests for the GSD watch header renderer.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { stripVTControlCharacters } from "node:util";
+import { renderHeaderLines } from "../watch/header-renderer.ts";
+import { splashPalette } from "../watch/splash-palette.ts";
+
+function rgbPattern(hex: string): RegExp {
+  const cleaned = hex.replace("#", "");
+  const r = Number.parseInt(cleaned.slice(0, 2), 16);
+  const g = Number.parseInt(cleaned.slice(2, 4), 16);
+  const b = Number.parseInt(cleaned.slice(4, 6), 16);
+  return new RegExp(`\\x1b\\[38;2;${r};${g};${b}m`);
+}
+
+test("renderHeaderLines uses the command-center splash layout", () => {
+  const lines = renderHeaderLines(
+    {
+      model: "claude-sonnet-4-6",
+      provider: "anthropic",
+      directory: "~/Github/gsd-2",
+      branch: "feat/tui-refresh",
+      mcpServers: ["context7"],
+    },
+    120,
+  );
+
+  const raw = lines.join("\n");
+  const plain = stripVTControlCharacters(raw);
+
+  assert.match(raw, rgbPattern(splashPalette.border), "logo and divider should use the recommended olive border");
+  assert.match(raw, rgbPattern(splashPalette.accent), "header accents should use the recommended blue");
+  assert.match(plain, /Project Console/);
+  assert.match(plain, /\/gsd start/);
+  assert.match(plain, /\/gsd templates/);
+  assert.match(plain, /claude-sonnet-4-6/);
+  assert.match(plain, /Context7 ✓/);
+});

package/src/resources/extensions/gsd/tests/headless-milestone-parity.test.ts

@@ -85,6 +85,11 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /Do not announce the ready phrase as something you are "about to" do/.test(section),
       "single-milestone pre-condition must include the 'do not announce intent' guard",
     );
+    assert.ok(/Next steps:/.test(section), "single-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(section), "single-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(section), "single-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(section), "single-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(section), "single-milestone handoff must mention /gsd notifications");
   });
 
   test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
@@ -113,5 +118,10 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /gates_completed === total/.test(multiSection),
       "multi-milestone pre-condition must still enforce gates_completed === total",
     );
+    assert.ok(/Next steps:/.test(multiSection), "multi-milestone handoff must include next steps");
+    assert.ok(/\/gsd auto/.test(multiSection), "multi-milestone handoff must mention /gsd auto");
+    assert.ok(/\/gsd status/.test(multiSection), "multi-milestone handoff must mention /gsd status");
+    assert.ok(/\/gsd visualize/.test(multiSection), "multi-milestone handoff must mention /gsd visualize");
+    assert.ok(/\/gsd notifications/.test(multiSection), "multi-milestone handoff must mention /gsd notifications");
   });
 });

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests for the GSD health widget state and footer hint rendering.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
@@ -9,6 +12,7 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
+import { HEALTH_WIDGET_ACTIVE_HINTS } from "../health-widget.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 
 function makeTempDir(prefix: string): string {
@@ -75,13 +79,11 @@ test("buildHealthLines: none state shows single onboarding line pointing at /gsd
   assert.match(lines[0]!, /\/gsd/);
 });
 
-test("buildHealthLines: initialized state shows single setup line pointing at /gsd", (t) => {
+test("buildHealthLines: initialized state shows concise initialized line", (t) => {
   const lines = buildHealthLines(activeData({ projectState: "initialized" }));
   assert.equal(lines.length, 1, "renders exactly one line");
   assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
-  // Distinct from "none" — must mention initialized/setup language and /gsd.
-  assert.match(lines[0]!, /\/gsd/);
-  assert.match(lines[0]!, /initiali[sz]ed|setup/i);
+  assert.equal(lines[0], "  GSD  Project Initialized");
 });
 
 test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
@@ -91,6 +93,14 @@ test("buildHealthLines: active state with ledger-driven spend shows spent summar
   assert.match(lines[0]!, /Spent: 42\.0¢/);
 });
 
+test("health widget active hints include visualization and notifications", () => {
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd auto to run/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd status for overview/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd visualize to inspect/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd notifications for history/);
+  assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd help/);
+});
+
 test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
   const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
   assert.equal(lines.length, 1);

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

@@ -1,3 +1,4 @@
+// GSD-2 doctor git integration tests
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 /**
@@ -761,6 +762,49 @@ describe('doctor-git', async () => {
       assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
     });
 
+    test('stale_uncommitted_changes (skips snapshot when tracked changes contain conflict markers)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      writeFileSync(join(dir, "README.md"), [
+        "# test",
+        "<<<<<<< Updated upstream",
+        "modified content",
+        "=======",
+        "stashed content",
+        ">>>>>>> Stashed changes",
+        "",
+      ].join("\n"));
+
+      const commitsBefore = run("git rev-list --count HEAD", dir);
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      const conflictIssues = fixed.issues.filter(
+        i => i.code === ("conflict_markers_in_tracked_files" as typeof i.code),
+      );
+
+      assert.equal(conflictIssues.length, 1, "detects conflict markers before snapshotting");
+      assert.equal(conflictIssues[0]?.severity, "error", "conflict marker issue blocks automation");
+      assert.equal(conflictIssues[0]?.fixable, false, "conflict marker issue requires manual resolution");
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("gsd snapshot skipped")),
+        "fix reports skipped snapshot",
+      );
+
+      const commitsAfter = run("git rev-list --count HEAD", dir);
+      assert.equal(commitsAfter, commitsBefore, "no snapshot commit is created");
+      assert.equal(run("git diff --cached --name-only", dir), "", "no files are staged");
+      assert.match(run("git status --short", dir), /M README\.md/m, "tracked file remains modified");
+    });
+
     // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──
     test('stale_uncommitted_changes (no false positive on recent commit)', async () => {
       const dir = createRepoWithActiveMilestone();