gsd-pi 2.82.0 → 3.0.0

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-db.test.ts

@@ -37,6 +37,7 @@ import {
   checkpointDatabase,
   refreshOpenDatabaseFromDisk,
   tryCreateMemoriesFts,
+  _isLikelyWslDrvFsPathForTest,
 } from '../gsd-db.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
 
@@ -345,6 +346,16 @@ describe('gsd-db', () => {
     });
   });
 
+  test('gsd-db: detects WSL DrvFs mount paths for conservative pragmas', () => {
+    withPlatform('linux', () => {
+      assert.equal(_isLikelyWslDrvFsPathForTest('/mnt/d/code/project/.gsd/gsd.db'), true);
+      assert.equal(_isLikelyWslDrvFsPathForTest('/tmp/gsd.db'), false);
+    });
+    withPlatform('darwin', () => {
+      assert.equal(_isLikelyWslDrvFsPathForTest('/mnt/d/code/project/.gsd/gsd.db'), false);
+    });
+  });
+
   test('gsd-db: transaction rollback on error', () => {
     openDatabase(':memory:');
 

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/gsdroot-worktree-detection.test.ts

@@ -3,7 +3,7 @@
  *
  * gsdRoot() must return the canonical project .gsd directory when basePath
  * is inside a .gsd/worktrees/<name>/ structure. Worktree-local .gsd folders
- * are legacy projection roots only; runtime state is DB-authoritative at the
+ * are projection roots; runtime/control state stays DB-authoritative at the
  * project .gsd.
  *
  * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
@@ -21,7 +21,7 @@ import { mkdtempSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
-import { gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
+import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
 
 describe("gsdRoot() worktree detection (#2594)", () => {
   let projectRoot: string;
@@ -76,6 +76,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
     assert.equal(resolveGsdPathContract(worktreeBase).worktreeGsd, worktreeGsd);
+    assert.equal(gsdProjectionRoot(worktreeBase), worktreeGsd);
   });
 
   test("returns project .gsd when worktree .gsd does not exist yet", () => {
@@ -89,6 +90,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
   });
 
   test("returns project .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
@@ -116,6 +118,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
       projectGsd,
       `Expected canonical project .gsd (${projectGsd}), got ${gsdResult}`,
     );
+    assert.equal(gsdProjectionRoot(worktreeBase), join(worktreeBase, ".gsd"));
 
     // Cleanup worktree
     spawnSync("git", ["worktree", "remove", "--force", worktreeBase], {

package/src/resources/extensions/gsd/tests/guided-discuss-project-prompt-rendering.test.ts

@@ -34,6 +34,8 @@ test("guided project prompt renders compact interview and artifact guidance", as
   assert.match(prompt, /depth_verification_project_confirm/);
   assert.match(prompt, /artifact_type: "PROJECT"/);
   assert.match(prompt, /omit `milestone_id`/);
+  assert.match(prompt, /do not write the projection directly/i);
+  assert.doesNotMatch(prompt, /then write `.gsd\/PROJECT\.md`/);
   assert.match(prompt, /Do NOT use `artifact_type: "CONTEXT"` and do NOT pass `milestone_id: "PROJECT"`/);
   assert.match(prompt, /\*\*Complexity:\*\* simple/);
   assert.match(prompt, /\*\*Complexity:\*\* complex/);

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -0,0 +1,106 @@
+// GSD-2 — Guided workflow dispatch project-root tests.
+// Verifies smart entry dispatch uses the explicit project root instead of cwd.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  _dispatchWorkflowForTest,
+  resolveGuidedDispatchProjectRoot,
+} from "../guided-flow.ts";
+
+test("guided dispatch falls back to cwd only when no project root is supplied", () => {
+  const cwd = process.cwd();
+  assert.equal(resolveGuidedDispatchProjectRoot(), cwd);
+  assert.equal(resolveGuidedDispatchProjectRoot("/tmp/explicit-root"), "/tmp/explicit-root");
+});
+
+test("guided dispatch passes the explicit project root through model and compatibility checks", async () => {
+  const explicitRoot = mkdtempSync(join(tmpdir(), "gsd-guided-root-explicit-"));
+  const otherRoot = mkdtempSync(join(tmpdir(), "gsd-guided-root-cwd-"));
+  const workflowPath = join(explicitRoot, "GSD-WORKFLOW.md");
+  const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+  const originalCwd = process.cwd();
+  const seen = {
+    prefsRoot: "",
+    modelRoot: "",
+    compatibilityRoot: "",
+    sent: false,
+  };
+
+  const ctx = {
+    model: { provider: "local-provider" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+    },
+    ui: {
+      notify: () => {},
+    },
+  };
+
+  const pi = {
+    getActiveTools: () => ["gsd_plan_slice"],
+    setActiveTools: () => {},
+    sendMessage: () => {
+      seen.sent = true;
+    },
+  };
+
+  try {
+    writeFileSync(workflowPath, "# Workflow\n", "utf-8");
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    process.chdir(otherRoot);
+
+    await _dispatchWorkflowForTest(
+      pi as any,
+      "Plan the slice.",
+      "gsd-run",
+      ctx as any,
+      "plan-slice",
+      {
+        basePath: explicitRoot,
+        deps: {
+          loadPreferences: (projectRoot?: string) => {
+            seen.prefsRoot = projectRoot ?? "";
+            return { preferences: {} } as any;
+          },
+          selectModel: async (
+            _ctx: unknown,
+            _pi: unknown,
+            _unitType: string,
+            _unitId: string,
+            projectRoot: string,
+          ) => {
+            seen.modelRoot = projectRoot;
+            return { routing: null, appliedModel: null };
+          },
+          getTransportSupportError: (
+            _provider: string | undefined,
+            _requiredTools: string[],
+            options?: { projectRoot?: string },
+          ) => {
+            seen.compatibilityRoot = options?.projectRoot ?? "";
+            return null;
+          },
+        },
+      },
+    );
+
+    assert.equal(seen.prefsRoot, explicitRoot);
+    assert.equal(seen.modelRoot, explicitRoot);
+    assert.equal(seen.compatibilityRoot, explicitRoot);
+    assert.equal(seen.sent, true);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalWorkflowPath === undefined) {
+      delete process.env.GSD_WORKFLOW_PATH;
+    } else {
+      process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+    }
+    rmSync(explicitRoot, { recursive: true, force: true });
+    rmSync(otherRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -21,6 +21,15 @@ import {
   checkAutoStartAfterDiscuss,
 } from "../guided-flow.ts";
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+  };
+}
+
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
 describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () => {
@@ -34,13 +43,11 @@ describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () =
     const projectB = "/projects/beta";
 
     setPendingAutoStart(projectA, {
-      basePath: projectA,
-      milestoneId: "M001-aaa111",
+      ...pendingInput(projectA, "M001-aaa111"),
     });
 
     setPendingAutoStart(projectB, {
-      basePath: projectB,
-      milestoneId: "M002-bbb222",
+      ...pendingInput(projectB, "M002-bbb222"),
     });
 
     // Both sessions should be retrievable
@@ -55,8 +62,8 @@ describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () =
     const projectA = "/projects/alpha";
     const projectB = "/projects/beta";
 
-    setPendingAutoStart(projectA, { basePath: projectA, milestoneId: "M001-aaa111" });
-    setPendingAutoStart(projectB, { basePath: projectB, milestoneId: "M002-bbb222" });
+    setPendingAutoStart(projectA, pendingInput(projectA, "M001-aaa111"));
+    setPendingAutoStart(projectB, pendingInput(projectB, "M002-bbb222"));
 
     // Clear only projectA
     clearPendingAutoStart(projectA);
@@ -72,8 +79,8 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId(basePath) returns correct milestone for each project", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
-    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
+    setPendingAutoStart("/proj/b", pendingInput("/proj/b", "M002"));
 
     assert.equal(getDiscussionMilestoneId("/proj/a"), "M001");
     assert.equal(getDiscussionMilestoneId("/proj/b"), "M002");
@@ -81,8 +88,8 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId() without basePath returns null when multiple sessions exist", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
-    setPendingAutoStart("/proj/b", { basePath: "/proj/b", milestoneId: "M002" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
+    setPendingAutoStart("/proj/b", pendingInput("/proj/b", "M002"));
 
     // Without a key, the function should not blindly return the first entry
     const result = getDiscussionMilestoneId();
@@ -92,7 +99,7 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 
   test("getDiscussionMilestoneId() without basePath returns the milestone when only one session", () => {
-    setPendingAutoStart("/proj/a", { basePath: "/proj/a", milestoneId: "M001" });
+    setPendingAutoStart("/proj/a", pendingInput("/proj/a", "M001"));
 
     // With only one session, backward compat — return it
     const result = getDiscussionMilestoneId();
@@ -129,3 +136,44 @@ test("checkAutoStartAfterDiscuss ignores missing manifest for single-milestone d
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry when multiple sessions exist", () => {
+  const projectA = mkdtempSync(join(tmpdir(), "gsd-auto-start-project-a-"));
+  const projectB = mkdtempSync(join(tmpdir(), "gsd-auto-start-project-b-"));
+
+  function writeReadyArtifacts(base: string, milestoneId: string): void {
+    const gsdDir = join(base, ".gsd");
+    const milestoneDir = join(gsdDir, "milestones", milestoneId);
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(gsdDir, "PROJECT.md"), `# Project\n\n| ${milestoneId} | Milestone | active |\n`);
+    writeFileSync(join(gsdDir, "STATE.md"), "# State\n");
+    writeFileSync(join(milestoneDir, `${milestoneId}-CONTEXT.md`), "# Context\n");
+  }
+
+  try {
+    clearPendingAutoStart();
+    writeReadyArtifacts(projectA, "M001");
+    writeReadyArtifacts(projectB, "M002");
+    setPendingAutoStart(projectA, {
+      basePath: projectA,
+      milestoneId: "M001",
+      ctx: { ui: { notify: () => undefined } } as any,
+      pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+    });
+    setPendingAutoStart(projectB, {
+      basePath: projectB,
+      milestoneId: "M002",
+      ctx: { ui: { notify: () => undefined } } as any,
+      pi: { setActiveTools: () => undefined, getActiveTools: () => [] } as any,
+    });
+
+    assert.equal(checkAutoStartAfterDiscuss(), false, "ambiguous pending sessions should not auto-start");
+    assert.equal(checkAutoStartAfterDiscuss(projectB), true, "explicit basePath should select projectB");
+    assert.equal(getDiscussionMilestoneId(projectA), "M001", "projectA should remain pending");
+    assert.equal(getDiscussionMilestoneId(projectB), null, "projectB should be cleared after start");
+  } finally {
+    clearPendingAutoStart();
+    rmSync(projectA, { recursive: true, force: true });
+    rmSync(projectB, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/guided-flow.test.ts

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+test("guided milestone discussion callsites pass workingDirectory to loadPrompt", () => {
+  const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+  const calls = [...source.matchAll(/loadPrompt\("guided-discuss-milestone",\s*\{([\s\S]*?)\}\)/g)];
+
+  assert.equal(calls.length, 6, "all guided-flow guided-discuss-milestone callsites should be covered");
+  for (const call of calls) {
+    assert.match(
+      call[1] ?? "",
+      /\bworkingDirectory:\s*basePath\b/,
+      "guided-discuss-milestone prompts need workingDirectory so template validation does not crash",
+    );
+  }
+});

package/src/resources/extensions/gsd/tests/guided-tool-contract.test.ts

@@ -0,0 +1,65 @@
+// GSD-2 — Guided Unit Tool Contract tests.
+// Verifies guided workflow turns use manifest tool policy without auto-mode state.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  clearGuidedUnitContext,
+  getGuidedUnitContext,
+  setGuidedUnitContext,
+} from "../guided-unit-context.ts";
+
+test("guided Unit context applies Tool Contract policy when auto-mode has no current Unit", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-guided-tool-contract-"));
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  };
+
+  try {
+    clearGuidedUnitContext();
+    registerHooks(pi as any, []);
+    setGuidedUnitContext(basePath, "plan-slice");
+
+    let blockResult: { block?: boolean; reason?: string } | undefined;
+    for (const handler of handlers.get("tool_call") ?? []) {
+      const result = await handler({
+        toolName: "edit",
+        input: {
+          path: join(basePath, "src", "main.ts"),
+        },
+      }, { cwd: basePath });
+      if (result?.block) {
+        blockResult = result;
+        break;
+      }
+    }
+
+    assert.equal(blockResult?.block, true);
+    assert.match(blockResult?.reason ?? "", /plan-slice|ToolsPolicy|not allowed|blocked/i);
+  } finally {
+    clearGuidedUnitContext();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("guided Unit context can be cleared by project root", () => {
+  clearGuidedUnitContext();
+  setGuidedUnitContext("/project/a", "plan-slice");
+  setGuidedUnitContext("/project/b", "complete-slice");
+
+  clearGuidedUnitContext("/project/a");
+
+  assert.equal(getGuidedUnitContext("/project/a"), null);
+  assert.equal(getGuidedUnitContext("/project/b")?.unitType, "complete-slice");
+  clearGuidedUnitContext();
+});

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

@@ -45,7 +45,7 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
 
     // Match only the actual dispatchWorkflow call — comments in the body
     // may mention "plan-milestone" as part of the fix rationale.
-    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([\s\S]*?,\s*"([^"]+)"\s*,\s*\{\s*basePath\s*\}\s*\)/g)];
     assert.strictEqual(
       dispatchMatches.length,
       1,
@@ -65,15 +65,15 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
       "single-milestone ready-phrase section must be present",
     );
-    // All four required artifacts must appear as checkboxes, not a prose list.
+    // All four required outcomes must appear as checkboxes, not a prose list.
     for (const artifact of [
-      "`.gsd/PROJECT.md`",
-      "`.gsd/REQUIREMENTS.md`",
+      "PROJECT artifact",
+      "REQUIREMENTS artifact",
       "`{{contextPath}}`",
       "`gsd_plan_milestone`",
     ]) {
       assert.ok(
-        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        new RegExp(`- \\[ \\] [^\\n]*${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
         `single-milestone pre-condition must include a checkbox for ${artifact}`,
       );
     }
@@ -103,8 +103,8 @@ describe("headless milestone bootstrap — parity with interactive flow", () =>
       "multi-milestone ready-phrase section must be present",
     );
     for (const artifact of [
-      "`.gsd/PROJECT.md`",
-      "`.gsd/REQUIREMENTS.md`",
+      "PROJECT artifact",
+      "REQUIREMENTS artifact",
       "`gsd_plan_milestone`",
       "`.gsd/DISCUSSION-MANIFEST.json`",
     ]) {

package/src/resources/extensions/gsd/tests/hook-model-resolution.test.ts

@@ -92,6 +92,11 @@ test("resolveModelId: returns undefined for unknown model", () => {
   assert.equal(match, undefined);
 });
 
+test("resolveModelId: returns undefined for missing model ID", () => {
+  const match = resolveModelId(undefined, AVAILABLE_MODELS, "anthropic");
+  assert.equal(match, undefined);
+});
+
 test("resolveModelId: returns undefined for unknown provider/model combo", () => {
   const match = resolveModelId("fakeprovider/fake-model", AVAILABLE_MODELS, undefined);
   assert.equal(match, undefined);

package/src/resources/extensions/gsd/tests/infra-error.test.ts

@@ -9,11 +9,11 @@ import { isInfrastructureError, INFRA_ERROR_CODES } from "../auto/infra-errors.j
 test("INFRA_ERROR_CODES contains the expected codes", () => {
   for (const code of [
     "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE",
-    "EAGAIN", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+    "EAGAIN", "ENOBUFS", "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
   ]) {
     assert.ok(INFRA_ERROR_CODES.has(code), `missing ${code}`);
   }
-  assert.equal(INFRA_ERROR_CODES.size, 10, "unexpected extra codes");
+  assert.equal(INFRA_ERROR_CODES.size, 11, "unexpected extra codes");
 });
 
 // ── isInfrastructureError: code property detection ───────────────────────────

package/src/resources/extensions/gsd/tests/infra-errors-cooldown.test.ts

@@ -5,6 +5,8 @@ import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  INFRA_ERROR_CODES,
+  isInfrastructureError,
   isTransientCooldownError,
   getCooldownRetryAfterMs,
   MAX_COOLDOWN_RETRIES,
@@ -13,6 +15,13 @@ import {
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
+describe("infra error classification", () => {
+  test("ENOBUFS is treated as infrastructure exhaustion", () => {
+    assert.equal(INFRA_ERROR_CODES.has("ENOBUFS"), true);
+    assert.equal(isInfrastructureError(Object.assign(new Error("spawnSync git ENOBUFS"), { code: "ENOBUFS" })), "ENOBUFS");
+  });
+});
+
 describe("infra-errors cooldown constants", () => {
   test("COOLDOWN_FALLBACK_WAIT_MS is a positive number greater than the 30s rate-limit backoff", () => {
     assert.ok(typeof COOLDOWN_FALLBACK_WAIT_MS === "number");

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();

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

@@ -446,6 +446,26 @@ node_modules/
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
       assert.deepStrictEqual(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
     });
+
+    test('stranded_lock_directory still reports when worker lookup fails', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+      const { openDatabase, _getAdapter, closeDatabase } = await import("../../gsd-db.ts");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.exec("DROP TABLE workers");
+
+      try {
+        const detect = await runGSDDoctor(dir);
+        const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+        assert.ok(strandedIssues.length > 0, "reports stranded lock directory even when active worker lookup fails");
+      } finally {
+        closeDatabase();
+      }
+    });
     } else {
     }