@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -69,9 +69,12 @@ function makeContextFor(
 // ─── Scaffold helpers ──────────────────────────────────────────────────────
 
 function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
-  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  // Flat-phase: phases/NN-slug/NN-MM-PLAN.md
+  const phaseNum = parseInt(mid.match(/^M0*(\d+)/i)?.[1] || '1', 10);
+  const planNum = parseInt(sid.match(/^S0*(\d+)/i)?.[1] || '1', 10);
+  const dir = join(basePath, ".gsd", "phases", `${String(phaseNum).padStart(2, '0')}-test`);
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${sid}-PLAN.md`), [
+  writeFileSync(join(dir, `${String(phaseNum).padStart(2, '0')}-${String(planNum).padStart(2, '0')}-PLAN.md`), [
     `# ${sid}: Third Slice`,
     "",
     "## Tasks",
@@ -82,35 +85,66 @@ function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
 }
 
 function scaffoldMilestoneContext(basePath: string, mid: string): void {
+  const phaseNum = parseInt(mid.match(/^M0*(\d+)/i)?.[1] || '1', 10);
+  const dir = join(basePath, ".gsd", "phases", `${String(phaseNum).padStart(2, '0')}-test`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${String(phaseNum).padStart(2, '0')}-CONTEXT.md`), [
+    `# ${mid}: Test Milestone`,
+    "",
+    "Context for dispatch recovery tests.",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldLegacyMilestoneContext(basePath: string, mid: string): void {
   const dir = join(basePath, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
   writeFileSync(join(dir, `${mid}-CONTEXT.md`), [
     `# ${mid}: Test Milestone`,
     "",
-    "Context for dispatch recovery tests.",
+    "Context for legacy dispatch recovery tests.",
     "",
   ].join("\n"));
 }
 
-function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+function scaffoldLegacySlicePlan(basePath: string, mid: string, sid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(join(dir, "tasks"), { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), [
+    `# ${sid}: Legacy Slice`,
+    "",
+    "## Tasks",
+    "- T01: Do something",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldLegacyTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
   const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
   mkdirSync(dir, { recursive: true });
   writeFileSync(join(dir, `${tid}-PLAN.md`), [
-    `# ${tid}: Do something`,
+    `# ${tid}: First Task`,
     "",
-    "## Steps",
-    "- [ ] Step 1",
+    "Implement the task.",
     "",
   ].join("\n"));
 }
 
+function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+  // Flat-phase: no per-task plan files. This is a no-op — tasks live as
+  // checkboxes inside the slice plan. Kept for backward-compat with tests
+  // that call it; does nothing in flat-phase.
+}
+
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
 test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
-  // Slice plan exists with tasks, but tasks/ directory is empty
+  // Slice plan exists with tasks. In flat-phase, tasks are checkboxes inside
+  // the slice plan (no per-task files), so this is the NORMAL state — dispatch
+  // should proceed to execute-task, not recover with plan-slice.
   scaffoldMilestoneContext(tmp, "M002");
   scaffoldSlicePlan(tmp, "M002", "S03");
 
@@ -118,10 +152,9 @@ test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909"
   const result = await resolveDispatch(ctx);
 
   assert.equal(result.action, "dispatch", "should dispatch, not stop");
-  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
-    `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
-  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
-    `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  // Flat-phase: tasks embedded in slice plan → execute-task (not plan-slice recovery)
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task (tasks in slice plan), got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
 });
 
 test("dispatch: closed milestone is not implicitly recovered or reopened", async (t) => {
@@ -153,7 +186,10 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
 
   scaffoldMilestoneContext(tmp, "M002");
   scaffoldSlicePlan(tmp, "M002", "S03");
-  scaffoldTaskPlan(tmp, "M002", "S03", "T01");
+  // Flat-phase: tasks are checkboxes inside the slice plan (no per-task PLAN files).
+  // scaffoldTaskPlan is intentionally NOT called here — creating a milestones/ dir
+  // as a side effect would confuse milestonesDir() into treating this as a legacy
+  // layout, breaking slice plan resolution and causing discuss-milestone dispatch.
 
   const ctx = makeContext(tmp);
   const result = await resolveDispatch(ctx);
@@ -165,6 +201,115 @@ test("dispatch: present task plan proceeds to execute-task normally", async (t)
     `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
+test("dispatch: missing legacy task plan recovery increments a per-slice retry counter", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-retry-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>(),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+    `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
+    `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 1);
+});
+
+test("dispatch: missing legacy task plan recovery stops when retry counter is exhausted", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-stop-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>([["M002/S03", 2]]),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "stop");
+  assert.ok(result.action === "stop");
+  assert.equal(result.level, "error");
+  assert.match(result.reason, /Missing task-plan recovery failed 2 times for M002\/S03/);
+  assert.match(result.reason, /manual intervention required/);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+});
+
+test("dispatch: present legacy task plan clears missing-plan recovery retry counter", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-clear-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+  scaffoldLegacyTaskPlan(tmp, "M002", "S03", "T01");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>([["M002/S03", 1]]),
+    preExecRetryCount: new Map<string, number>([["M002/S03", 2]]),
+  };
+  const result = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+  assert.equal(session.preExecRetryCount.get("M002/S03"), 2,
+    "pre-exec retry counter must not be cleared when task plan is present");
+});
+
+test("dispatch: missing-task-plan recovery loop terminates even when the shared pre-exec key is reset between rounds (#1087)", async (t) => {
+  // The recovery rule re-dispatches plan-slice with unitId "${mid}/${sid}".
+  // That regenerated plan-slice carries the same currentUnit.id, and on a
+  // pre-execution pass the post-unit hook deletes that key from
+  // preExecRetryCount (auto-post-unit.ts). Missing per-task PLAN projection
+  // files do not fail pre-exec checks, so the regenerated plan-slice typically
+  // passes and that delete fires every cycle. If recovery shared
+  // preExecRetryCount, its counter would be wiped to 0 each round and the loop
+  // would never reach the cap. Here we simulate that reset between rounds and
+  // assert the dedicated counter still climbs to MAX and stops.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-1087-loop-term-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldLegacyMilestoneContext(tmp, "M002");
+  scaffoldLegacySlicePlan(tmp, "M002", "S03");
+
+  const session = {
+    missingTaskPlanRetryCount: new Map<string, number>(),
+    preExecRetryCount: new Map<string, number>(),
+  };
+
+  // Round 1: missing task plan → recover (counter 0 → 1).
+  const r1 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice",
+    `round 1 should re-dispatch plan-slice, got: ${r1.action === "dispatch" ? r1.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 1);
+
+  // The regenerated plan-slice passes its post-unit pre-exec check, deleting
+  // the shared "${mid}/${sid}" key from preExecRetryCount.
+  session.preExecRetryCount.delete("M002/S03");
+
+  // Round 2: still missing → recover (counter 1 → 2), unaffected by the reset.
+  const r2 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
+    `round 2 should re-dispatch plan-slice, got: ${r2.action === "dispatch" ? r2.unitType : "(stop)"}`);
+  assert.equal(session.missingTaskPlanRetryCount.get("M002/S03"), 2);
+
+  session.preExecRetryCount.delete("M002/S03");
+
+  // Round 3: cap reached → stop. The loop terminates despite the resets.
+  const r3 = await resolveDispatch(makeContextFor(tmp, "M002", "S03", "T01", session));
+  assert.equal(r3.action, "stop");
+  assert.ok(r3.action === "stop" && r3.level === "error");
+  assert.match(r3.reason, /Missing task-plan recovery failed 2 times for M002\/S03/);
+  assert.equal(session.missingTaskPlanRetryCount.has("M002/S03"), false);
+});
+
 test("dispatch: session milestone mismatch stops before missing-task-plan recovery", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-session-milestone-mismatch-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
@@ -280,8 +425,9 @@ test("dispatch: artifact checks trust active session basePath even when original
 });
 
 test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async (t) => {
-  // Simulate: plan-slice ran but T01-PLAN.md is still missing (e.g. agent crashed mid-write).
-  // Dispatch should still re-dispatch plan-slice, not hard-stop.
+  // Flat-phase: tasks are checkboxes inside the slice plan, so there are no
+  // per-task plan files to be "missing". Dispatch should go to execute-task
+  // (the normal flow), not plan-slice recovery.
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-loop-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
@@ -291,19 +437,22 @@ test("dispatch: plan-slice recovery loop — second call after plan-slice still
   const ctx = makeContext(tmp);
   const r1 = await resolveDispatch(ctx);
   assert.equal(r1.action, "dispatch");
-  assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice");
+  assert.ok(r1.action === "dispatch" && r1.unitType === "execute-task",
+    "flat-phase: should dispatch execute-task (tasks in slice plan)");
 
-  // Still no task plan written — dispatch again
+  // Second dispatch should also go to execute-task (idempotent)
   const r2 = await resolveDispatch(ctx);
   assert.equal(r2.action, "dispatch");
-  assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
-    "should keep dispatching plan-slice until task plans appear");
+  assert.ok(r2.action === "dispatch" && r2.unitType === "execute-task",
+    "should keep dispatching execute-task");
 });
 
 test("dispatch: missing task plan recovery logs root/worktree diagnostic when debug enabled — issue #6194", async (t) => {
-  // The diagnostic exists to surface root/worktree artifact-path mismatches
-  // when the recovery rule fires. It must report the paths that were checked
-  // so a stuck session can be traced — not just that recovery happened.
+  // Flat-phase: tasks are embedded in the slice plan, so the recovery rule
+  // (which fires when per-task plan files are missing) doesn't apply.
+  // The diagnostic log entry is only produced in the legacy layout.
+  // This test verifies the normal flat-phase dispatch path doesn't crash
+  // with debug enabled.
   const tmp = mkdtempSync(join(tmpdir(), "gsd-6194-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));
 
@@ -315,25 +464,8 @@ test("dispatch: missing task plan recovery logs root/worktree diagnostic when de
 
   const ctx = makeContext(tmp);
   const result = await resolveDispatch(ctx);
-  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
-    "recovery rule must fire for the diagnostic to be exercised");
-
-  const logPath = getDebugLogPath();
-  assert.ok(logPath, "debug log path should be set while debug is enabled");
-
-  const entry = readFileSync(logPath!, "utf8")
-    .trim()
-    .split("\n")
-    .filter(Boolean)
-    .map((line) => JSON.parse(line) as Record<string, unknown>)
-    .find((e) => e.event === "dispatch-missing-task-plan-recovery");
-
-  assert.ok(entry, "diagnostic event should be logged when recovery fires in debug mode");
-  assert.equal(entry!.basePathUsedForArtifactChecks, tmp);
-  assert.equal(entry!.artifactExists, false, "task plan is genuinely absent");
-  assert.equal(entry!.expectedTaskPlanExists, false, "expected task plan is genuinely absent");
-  assert.equal(entry!.projectionArtifactExists, false, "projection task plan is genuinely absent");
-  assert.equal(entry!.hasRootWorktreeMismatch, false, "root/worktree mismatch should be false in single-root scenario");
-  assert.equal(typeof entry!.expectedTaskPlanPath, "string");
-  assert.equal(typeof entry!.projectionTaskPlanPath, "string");
+  // Flat-phase: dispatch goes to execute-task (tasks in slice plan)
+  assert.ok(result.action === "dispatch",
+    "should dispatch without crashing in debug mode");
+  // Flat-phase: no recovery diagnostic entry expected (tasks in slice plan)
 });

package/src/resources/extensions/gsd/tests/dispatch-rule-coverage.test.ts

@@ -232,7 +232,7 @@ test("dispatch-rule-coverage: planning boundary without planner handoff → rese
   assertMatch(
     match,
     {
-      ruleName: "planning (no research, not S01) → research-slice",
+      ruleName: "planning (no research) → research-slice",
       action: "dispatch",
       unitType: "research-slice",
     },
@@ -240,6 +240,31 @@ test("dispatch-rule-coverage: planning boundary without planner handoff → rese
   );
 });
 
+test("dispatch-rule-coverage: S01 still researches when only milestone research exists", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-s01-research-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "ROADMAP", "# Roadmap\n");
+  writeMilestoneFile(tmp, "M001", "RESEARCH", "# Milestone Research\n");
+
+  const state = makeState({
+    phase: "planning",
+    activeSlice: { id: "S01", title: "First Slice" },
+    nextAction: "Plan slice S01 (First Slice).",
+  });
+  const match = await findFirstMatch(makeCtx(tmp, state));
+  assertMatch(
+    match,
+    {
+      ruleName: "planning (no research) → research-slice",
+      action: "dispatch",
+      unitType: "research-slice",
+    },
+    "S01 missing slice research despite milestone research",
+  );
+});
+
 test("dispatch-rule-coverage: executing with task plan present → execute-task", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-exec-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -44,6 +44,11 @@ export function resolve(specifier, context, nextResolve) {
   } else if (specifier.startsWith("@earendil-works/pi-agent-core/") || specifier.startsWith("@gsd/pi-agent-core/")) {
     const subpath = specifier.replace(/^@[^/]+\/pi-agent-core\//, "").replace(/\.js$/, ".ts");
     specifier = new URL(`packages/pi-agent-core/src/${subpath}`, ROOT).href;
+  } else if (specifier === "@gsd/agent-core") {
+    specifier = new URL("packages/gsd-agent-core/src/index.ts", ROOT).href;
+  } else if (specifier.startsWith("@gsd/agent-core/")) {
+    const subpath = specifier.replace(/^@gsd\/agent-core\//, "").replace(/\.js$/, ".ts");
+    specifier = new URL(`packages/gsd-agent-core/src/${subpath}`, ROOT).href;
   } else if (specifier === "@gsd/native") {
     specifier = new URL("packages/native/src/index.ts", ROOT).href;
   } else if (specifier.startsWith("@gsd/native/")) {
@@ -115,6 +120,8 @@ export function load(url, context, nextLoad) {
     url = url.replace('/dist/index.js', '/src/index.ts');
   } else if (url.includes('/packages/pi-agent-core/dist/index.js')) {
     url = url.replace('/dist/index.js', '/src/index.ts');
+  } else if (url.includes('/packages/gsd-agent-core/dist/')) {
+    url = url.replace('/dist/', '/src/').replace(/\.js$/, '.ts');
   } else if (url.includes('/packages/pi-tui/dist/index.js')) {
     url = url.replace('/dist/index.js', '/src/index.ts');
   }

package/src/resources/extensions/gsd/tests/doctor-forensics-db-open-regression.test.ts

@@ -1,10 +1,18 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { closeDatabase } from "../gsd-db.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  getHierarchyCompletionCounts,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
 import { buildForensicReport } from "../forensics.ts";
 import { handleDoctor } from "../commands-handlers.ts";
 import { withCommandCwd } from "../commands/context.ts";
@@ -23,6 +31,66 @@ test("#5194 forensics opens DB before computing completion counts", async (t) =>
   assert.equal(report.dbCompletionCounts?.tasksTotal, 0);
 });
 
+test("#968 completion counts use fixed aggregate queries and canonical closed statuses", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-forensics-counts-"));
+  const dbPath = join(base, "gsd.db");
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(dbPath);
+
+  insertMilestone({ id: "M001", status: "complete" });
+  insertMilestone({ id: "M002", status: "active" });
+  insertMilestone({ id: "M003", status: "closed" });
+
+  insertSlice({ milestoneId: "M001", id: "S01", status: "done" });
+  insertSlice({ milestoneId: "M001", id: "S02", status: "pending" });
+  insertSlice({ milestoneId: "M002", id: "S01", status: "skipped" });
+  insertSlice({ milestoneId: "M003", id: "S01", status: "active" });
+
+  insertTask({ milestoneId: "M001", sliceId: "S01", id: "T01", status: "complete" });
+  insertTask({ milestoneId: "M001", sliceId: "S01", id: "T02", status: "done" });
+  insertTask({ milestoneId: "M001", sliceId: "S02", id: "T01", status: "skipped" });
+  insertTask({ milestoneId: "M002", sliceId: "S01", id: "T01", status: "closed" });
+  insertTask({ milestoneId: "M002", sliceId: "S01", id: "T02", status: "pending" });
+  insertTask({ milestoneId: "M003", sliceId: "S01", id: "T01", status: "active" });
+
+  const adapter = _getAdapter()!;
+  const originalPrepare = adapter.prepare.bind(adapter);
+  const preparedSql: string[] = [];
+  adapter.prepare = (sql) => {
+    preparedSql.push(sql);
+    return originalPrepare(sql);
+  };
+
+  assert.deepEqual(getHierarchyCompletionCounts(), {
+    milestones: 2,
+    milestonesTotal: 3,
+    slices: 2,
+    slicesTotal: 4,
+    tasks: 4,
+    tasksTotal: 6,
+  });
+
+  assert.equal(preparedSql.length, 3);
+  assert.ok(preparedSql.every((sql) => /COUNT\(\*\)/i.test(sql)));
+  assert.doesNotMatch(preparedSql.join("\n"), /SELECT\s+\*/i);
+});
+
+test("#968 forensics completion counts do not re-query slices and tasks", () => {
+  const source = readFileSync(join(process.cwd(), "src/resources/extensions/gsd/forensics.ts"), "utf-8");
+  const start = source.indexOf("function getDbCompletionCounts()");
+  const end = source.indexOf("// ─── Anomaly Detectors", start);
+  assert.notEqual(start, -1);
+  assert.notEqual(end, -1);
+  const body = source.slice(start, end);
+
+  assert.match(body, /getHierarchyCompletionCounts\(\)/);
+  assert.doesNotMatch(body, /getAllMilestones|getMilestoneSlices|getSliceTasks/);
+});
+
 test("#5194 doctor command does not emit false db_unavailable when gsd.db exists", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-db-open-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

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

@@ -0,0 +1,149 @@
+// Project/App: gsd-pi
+// File Purpose: Doctor attempts safe conflict auto-resolution before hard-blocking auto-mode (#849).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { closeDatabase } from "../gsd-db.js";
+
+function runGit(args: string[], cwd: string): void {
+  execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+}
+
+function tryGit(args: string[], cwd: string): void {
+  try {
+    runGit(args, cwd);
+  } catch {
+    // Expected to fail for conflicting merges — the conflict state is what we want.
+  }
+}
+
+function makeRepoWithConflict(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-autoresolve-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  mkdirSync(join(base, "src"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "STATE.md"), "base state\n", "utf-8");
+  writeFileSync(join(base, "src", "app.js"), "base app\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+
+  runGit(["checkout", "-b", "feature"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "feature state\n", "utf-8");
+  writeFileSync(join(base, "src", "app.js"), "feature app\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: feature edits"], base);
+
+  runGit(["checkout", "main"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "main state\n", "utf-8");
+  writeFileSync(join(base, "src", "app.js"), "main app\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: main edits"], base);
+
+  // Conflicting merge — leaves unmerged paths + MERGE_HEAD.
+  tryGit(["merge", "feature"], base);
+  return base;
+}
+
+test.after(() => {
+  closeDatabase();
+});
+
+test("doctor auto-resolves safe .gsd/ conflicts and only blocks on manual paths", async (t) => {
+  const base = makeRepoWithConflict();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const report = await runGSDDoctor(base, { isolationMode: "none" });
+
+  const conflictIssue = report.issues.find((issue) => issue.code === "unresolved_git_conflicts");
+  assert.ok(conflictIssue, "manual conflict should still be reported");
+  assert.match(conflictIssue!.message, /src\/app\.js/, "manual path should be listed");
+  assert.doesNotMatch(
+    conflictIssue!.message,
+    /\.gsd\/STATE\.md/,
+    "safe .gsd/ path should have been auto-resolved out of the conflict list",
+  );
+});
+
+test("doctor clears conflicts entirely when all unmerged paths are safe", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-autoresolve-safe-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "STATE.md"), "base\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+
+  runGit(["checkout", "-b", "feature"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "feature\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: edit"], base);
+
+  runGit(["checkout", "main"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "main\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: edit"], base);
+
+  tryGit(["merge", "feature"], base);
+
+  const report = await runGSDDoctor(base, { isolationMode: "none" });
+
+  assert.ok(
+    !report.issues.some((issue) => issue.code === "unresolved_git_conflicts"),
+    "no manual conflicts should remain after safe auto-resolve",
+  );
+  assert.ok(
+    !existsSync(join(base, ".git", "MERGE_HEAD")),
+    "merge-state markers should be cleared in the same pass",
+  );
+});
+
+test("doctor --dry-run does not mutate git state when safe conflicts are present", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-autoresolve-dryrun-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "STATE.md"), "base\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+
+  runGit(["checkout", "-b", "feature"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "feature\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: edit"], base);
+
+  runGit(["checkout", "main"], base);
+  writeFileSync(join(base, ".gsd", "STATE.md"), "main\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "feat: edit"], base);
+
+  tryGit(["merge", "feature"], base);
+
+  // dry-run must not mutate git state even when all conflicts are safe
+  const report = await runGSDDoctor(base, { dryRun: true, isolationMode: "none" });
+
+  // MERGE_HEAD must still exist — dry-run is read-only
+  assert.ok(
+    existsSync(join(base, ".git", "MERGE_HEAD")),
+    "dry-run must not clear merge-state markers",
+  );
+  // The conflict should still be reported (unresolved paths are reported as-is)
+  assert.ok(
+    report.issues.some((issue) => issue.code === "unresolved_git_conflicts"),
+    "dry-run should still report the conflict without resolving it",
+  );
+});