gsd-pi 3.0.0-dev.2e8b124f7 → 3.0.0-dev.6c9a50fd0

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -970,7 +970,11 @@ test("hasImplementationArtifacts does not backfill untagged commits before miles
     });
 
     const result = hasImplementationArtifacts(base, "M001");
-    assert.equal(result, "absent", "pre-milestone commits must not be attributed to the milestone");
+    assert.equal(
+      result,
+      "unknown",
+      "integration self-diff should remain unknown when pre-milestone commits cannot be attributed",
+    );
     assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
   } finally {
     cleanup(base);
@@ -1007,7 +1011,11 @@ test("hasImplementationArtifacts does not backfill unrelated untagged implementa
     execFileSync("git", ["commit", "-m", "feat: unrelated work"], { cwd: base, stdio: "ignore" });
 
     const result = hasImplementationArtifacts(base, "M001");
-    assert.equal(result, "absent", "backfill must require overlap with completed task file hints");
+    assert.equal(
+      result,
+      "unknown",
+      "integration self-diff should remain unknown when unrelated untagged commits cannot be attributed",
+    );
     assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
   } finally {
     cleanup(base);
@@ -1126,7 +1134,7 @@ test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB stat
   }
 });
 
-test("hasImplementationArtifacts does not claim Sxx/Tyy commit trailers across milestones when ownership points elsewhere", () => {
+test("hasImplementationArtifacts returns unknown when GSD-Task trailer cannot be bound to milestone ownership evidence", () => {
   const base = makeGitBase();
   try {
     writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
@@ -1159,17 +1167,11 @@ test("hasImplementationArtifacts does not claim Sxx/Tyy commit trailers across m
       { cwd: base, stdio: "ignore" },
     );
 
-    const m001Result = hasImplementationArtifacts(base, "M001");
-    const m002Result = hasImplementationArtifacts(base, "M002");
-    assert.equal(
-      m001Result,
-      "absent",
-      "Sxx/Tyy commit trailers owned by M002 must not be attributed to M001",
-    );
+    const result = hasImplementationArtifacts(base, "M001");
     assert.equal(
-      m002Result,
-      "present",
-      "the owning milestone should still claim the implementation-bearing commit",
+      result,
+      "unknown",
+      "integration self-diff should not conclude absent when S01/T01 cannot be bound to M001",
     );
   } finally {
     cleanup(base);
@@ -1193,8 +1195,8 @@ test("hasImplementationArtifacts ignores malformed milestone IDs in commit-messa
     const result = hasImplementationArtifacts(base, "M001(");
     assert.equal(
       result,
-      "absent",
-      "malformed milestone IDs must not bind implementation commits through message scanning",
+      "unknown",
+      "malformed milestone IDs must not force an absent classification when ownership cannot be proven",
     );
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/auto-workers.test.ts

@@ -13,6 +13,7 @@ import {
   heartbeatAutoWorker,
   markWorkerCrashed,
   markWorkerStopping,
+  markWorkerStoppingByPid,
   getActiveAutoWorkers,
   getAutoWorker,
 } from "../db/auto-workers.ts";
@@ -71,6 +72,18 @@ test("markWorkerStopping flips status to stopping", (t) => {
   assert.equal(row.status, "stopping");
 });
 
+test("markWorkerStoppingByPid flips matching active row to stopping", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  const pid = getAutoWorker(id)!.pid;
+  markWorkerStoppingByPid(base, pid);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "stopping");
+});
+
 test("markWorkerCrashed flips status to crashed", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

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

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { invalidateAllCaches } from '../cache.ts';
 import { parseUnitId } from "../unit-id.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, insertAssessment } from "../gsd-db.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
 
@@ -503,6 +503,49 @@ describe("complete-milestone", () => {
     }
   });
 
+  test("handleCompleteMilestone refuses closeout when latest validation verdict is needs-attention (#5661)", async () => {
+    const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
+    const base = createFixtureBase();
+    const mid = "M001";
+    const dbPath = join(base, ".gsd", "gsd.db");
+    try {
+      openDatabase(dbPath);
+      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
+      insertAssessment({
+        path: join(".gsd", "milestones", mid, `${mid}-VALIDATION.md`),
+        milestoneId: mid,
+        status: "needs-attention",
+        scope: "milestone-validation",
+        fullContent: "---\nverdict: needs-attention\nremediation_round: 1\n---\n\n# Validation\nNeeds attention.",
+      });
+
+      const result = await handleCompleteMilestone({
+        milestoneId: mid,
+        title: "Test Milestone",
+        oneLiner: "Test",
+        narrative: "Test narrative",
+        successCriteriaResults: "Results",
+        definitionOfDoneResults: "Done",
+        requirementOutcomes: "Outcomes",
+        keyDecisions: [],
+        keyFiles: [],
+        lessonsLearned: [],
+        followUps: "",
+        deviations: "",
+        verificationPassed: true,
+      }, base);
+
+      assert.ok("error" in result, "non-pass validation verdict should block completion");
+      assert.match((result as { error: string }).error, /needs-attention/i);
+      assert.match((result as { error: string }).error, /Only verdict=pass permits closeout/i);
+    } finally {
+      try { closeDatabase(); } catch { /* */ }
+      cleanup(base);
+    }
+  });
+
   test("deriveState completing-milestone integration", async () => {
     const { deriveState, isMilestoneComplete } = await import("../state.ts");
     const { invalidateAllCaches: invalidateAllCachesDynamic } = await import("../cache.ts");
@@ -655,6 +698,13 @@ describe("complete-milestone", () => {
       insertMilestone({ id: mid, title: "Empty Enrichment", status: "active" });
       insertSlice({ id: "S01", milestoneId: mid, title: "Slice", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task", status: "complete" });
+      insertAssessment({
+        path: join(".gsd", "milestones", mid, `${mid}-VALIDATION.md`),
+        milestoneId: mid,
+        status: "pass",
+        scope: "milestone-validation",
+        fullContent: "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nValidated.",
+      });
 
       const result = await handleCompleteMilestone({
         milestoneId: mid,

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

@@ -13,6 +13,7 @@ import {
   getSlice,
   updateSliceStatus,
   getSliceTasks,
+  setSliceSummaryMd,
   SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteSlice } from '../tools/complete-slice.ts';
@@ -407,6 +408,60 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-slice: backfills omitted requirements from rendered summary
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-slice: backfills omitted requirements from rendered summary ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+
+  insertMilestone({ id: 'M001' });
+  insertSlice({ id: 'S01', milestoneId: 'M001' });
+  insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
+
+  const seedParams = makeValidSliceParams();
+  const seeded = await handleCompleteSlice(seedParams, basePath);
+  assertTrue(!('error' in seeded), 'seed completion should succeed');
+  if ('error' in seeded) {
+    cleanupDir(basePath);
+    cleanup(dbPath);
+    throw new Error('seed completion unexpectedly failed');
+  }
+
+  const seededSummary = fs.readFileSync(seeded.summaryPath, 'utf-8');
+  transaction(() => {
+    updateSliceStatus('M001', 'S01', 'pending', undefined);
+    setSliceSummaryMd('M001', 'S01', seededSummary, '');
+  });
+
+  const backfillParams = makeValidSliceParams();
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsAdvanced;
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsValidated;
+  delete (backfillParams as Partial<CompleteSliceParams>).requirementsInvalidated;
+  const backfilled = await handleCompleteSlice(backfillParams as CompleteSliceParams, basePath);
+  assertTrue(!('error' in backfilled), 'backfill completion should succeed');
+  if (!('error' in backfilled)) {
+    const summary = fs.readFileSync(backfilled.summaryPath, 'utf-8');
+    assertMatch(summary, /## Requirements Advanced/, 'summary should include advanced requirements heading');
+    assertMatch(summary, /- R001 — Handler validates task completion/, 'advanced requirement should be backfilled from summary markdown');
+
+    const sliceAfterBackfill = getSlice('M001', 'S01');
+    assertTrue(sliceAfterBackfill !== null, 'slice should exist after backfill');
+    assertMatch(
+      sliceAfterBackfill!.full_summary_md,
+      /- R001 — Handler validates task completion/,
+      'DB full_summary_md should persist the backfilled advanced requirement',
+    );
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-slice: PROJECT refresh uses DB-backed artifact tool.
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -11,12 +11,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";
+import type { AutoSession } from "../auto/session.ts";
 import type { GSDState } from "../types.ts";
+import { enableDebug, disableDebug, getDebugLogPath } from "../debug-logger.ts";
 
 function makeState(overrides: Partial<GSDState> = {}): GSDState {
   return {
@@ -42,6 +44,27 @@ function makeContext(basePath: string, stateOverrides?: Partial<GSDState>): Disp
   };
 }
 
+function makeContextFor(
+  basePath: string,
+  mid: string,
+  sid: string,
+  tid: string,
+  session?: Partial<AutoSession>,
+): DispatchContext {
+  return {
+    basePath,
+    mid,
+    midTitle: "Test Milestone",
+    state: makeState({
+      activeMilestone: { id: mid, title: "Test Milestone" },
+      activeSlice: { id: sid, title: "Second Slice" },
+      activeTask: { id: tid, title: "First Task" },
+    }),
+    prefs: undefined,
+    session: session as AutoSession | undefined,
+  };
+}
+
 // ─── Scaffold helpers ──────────────────────────────────────────────────────
 
 function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
@@ -118,6 +141,57 @@ 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: executing recovery checks active milestone worktree task plans before re-dispatching plan-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-6192-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M002");
+  mkdirSync(worktreeRoot, { recursive: true });
+  writeFileSync(join(worktreeRoot, ".git"), "gitdir: /tmp/fake-worktree-gitdir\n");
+  scaffoldMilestoneContext(worktreeRoot, "M002");
+  scaffoldSlicePlan(worktreeRoot, "M002", "S03");
+  scaffoldTaskPlan(worktreeRoot, "M002", "S03", "T01");
+
+  const ctx = makeContext(tmp);
+  const result = await resolveDispatch(ctx);
+
+  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.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
+    `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
+test("dispatch: active session worktree task plan wins over missing original-root task plan", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-worktree-artifact-root-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M004");
+  scaffoldSlicePlan(tmp, "M004", "S02");
+
+  const worktreeRoot = join(tmp, ".gsd", "worktrees", "M004");
+  mkdirSync(worktreeRoot, { recursive: true });
+  scaffoldMilestoneContext(worktreeRoot, "M004");
+  scaffoldSlicePlan(worktreeRoot, "M004", "S02");
+  scaffoldTaskPlan(worktreeRoot, "M004", "S02", "T01");
+
+  const ctx = makeContextFor(tmp, "M004", "S02", "T01", {
+    basePath: worktreeRoot,
+    originalBasePath: tmp,
+    currentMilestoneId: "M004",
+  });
+  const result = await resolveDispatch(ctx);
+
+  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.ok(result.action === "dispatch" && result.unitId === "M004/S02/T01",
+    `unitId should be M004/S02/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+});
+
 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.
@@ -138,3 +212,39 @@ test("dispatch: plan-slice recovery loop — second call after plan-slice still
   assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
     "should keep dispatching plan-slice until task plans appear");
 });
+
+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.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-6194-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldMilestoneContext(tmp, "M002");
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  enableDebug(tmp);
+  t.after(() => disableDebug());
+
+  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!.projectionArtifactExists, false, "projection task plan is genuinely absent");
+  assert.equal(typeof entry!.expectedTaskPlanPath, "string");
+  assert.equal(typeof entry!.projectionTaskPlanPath, "string");
+});

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -31,6 +31,7 @@ import {
   openDatabase,
   closeDatabase,
   insertMilestone,
+  insertAssessment,
   insertSlice,
   insertTask,
   getTask,
@@ -280,6 +281,16 @@ function makeMilestoneParams(milestoneId: string): Record<string, unknown> {
   };
 }
 
+function insertPassingMilestoneValidation(milestoneId: string): void {
+  insertAssessment({
+    path: `.gsd/milestones/${milestoneId}/${milestoneId}-VALIDATION.md`,
+    milestoneId,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "# Validation\n\nverdict: PASS",
+  });
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -424,6 +435,7 @@ describe("state-machine-live-validation", () => {
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Impl", status: "complete" });
       insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Test", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Impl", status: "complete" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok(!("error" in result), `expected success, got: ${JSON.stringify(result)}`);
@@ -528,6 +540,7 @@ describe("state-machine-live-validation", () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -542,6 +555,7 @@ describe("state-machine-live-validation", () => {
       insertSlice({ id: "S02", milestoneId: "M001", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);
@@ -555,6 +569,7 @@ describe("state-machine-live-validation", () => {
       // Slice marked complete but task is still pending — simulates inconsistent state
       insertSlice({ id: "S01", milestoneId: "M001", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertPassingMilestoneValidation("M001");
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
       assert.ok("error" in result);

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
+import { _handlePausedSessionResumeRecoveryForTest } from "../auto.ts";
 import { assessInterruptedSession } from "../interrupted-session.ts";
 import {
   openDatabase,
@@ -186,6 +187,43 @@ test("direct /gsd auto source only resumes paused-session metadata for recoverab
   assert.ok(source.includes('|| !!freshStartAssessment.lock'));
 });
 
+test("direct /gsd auto skips paused-session replay when recovered unit already completed", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      [
+        "# S01: Test Slice",
+        "",
+        "## Tasks",
+        "",
+        "- [ ] **T01: First task** `est:1h`",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.\n", "utf-8");
+
+    const state = {
+      pausedSessionFile: join(base, ".gsd", "activity", "paused-session.jsonl"),
+      currentUnit: { type: "plan-slice", id: "M001/S01" },
+      pausedUnitType: null,
+      pausedUnitId: null,
+      pendingCrashRecovery: null,
+    };
+
+    const result = _handlePausedSessionResumeRecoveryForTest(base, state);
+    assert.equal(result.skippedReplay, true);
+    assert.equal(state.pausedSessionFile, null);
+    assert.equal(state.pendingCrashRecovery, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("auto module imports successfully after interrupted-session changes", async () => {
   const mod = await import(`../auto.ts?ts=${Date.now()}-${Math.random()}`);
   assert.equal(typeof mod.startAuto, "function");

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync, renameSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync, renameSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -228,4 +228,31 @@ test('validateProjectId accepts valid values', () => {
     }
 });
 
+test('ensureGsdSymlink prefers marker directory when marker/computed identities diverge and both have state (#5685)', () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-split-brain-")));
+    run("git init -b main", repo);
+    run('git config user.name "Pi Test"', repo);
+    run('git config user.email "pi@example.com"', repo);
+    writeFileSync(join(repo, "README.md"), "# Split Brain Test\n", "utf-8");
+    run("git add README.md", repo);
+    run('git commit -m "init"', repo);
+
+    const computedPath = externalGsdRoot(repo);
+    mkdirSync(computedPath, { recursive: true });
+    writeFileSync(join(computedPath, "computed-state.txt"), "computed\n", "utf-8");
+
+    const markerId = "marker-state-id";
+    const markerPath = join(stateDir, "projects", markerId);
+    mkdirSync(markerPath, { recursive: true });
+    writeFileSync(join(markerPath, "marker-state.txt"), "marker\n", "utf-8");
+    writeFileSync(join(repo, ".gsd-id"), `${markerId}\n`, "utf-8");
+
+    const resolved = ensureGsdSymlink(repo);
+    assert.deepStrictEqual(resolved, markerPath, "marker-backed state directory is preferred in split-brain condition");
+    assert.deepStrictEqual(realpathSync(join(repo, ".gsd")), realpathSync(markerPath), ".gsd symlink resolves to marker-backed state directory");
+    assert.deepStrictEqual(readFileSync(join(repo, ".gsd-id"), "utf-8").trim(), markerId, ".gsd-id marker persists the marker-backed identity");
+
+    rmSync(repo, { recursive: true, force: true });
+});
+
 });

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

@@ -25,6 +25,9 @@ import {
   isSessionLockHeld,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { registerAutoWorker, getAutoWorker } from "../db/auto-workers.ts";
+import { normalizeRealPath } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -94,6 +97,38 @@ describe('session-lock-regression', async () => {
     }
   }
 
+  // ─── 2b. Dead lock PID is marked stopping in workers table ────────────
+  console.log('\n=== 2b. dead lock PID marks worker stopping ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      openDatabase(join(base, ".gsd", "gsd.db"));
+      const projectRoot = normalizeRealPath(base);
+      const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+      const deadPid = 99999;
+      writeFileSync(join(gsdRoot(base), "auto.lock"), JSON.stringify({
+        pid: deadPid,
+        startedAt: new Date().toISOString(),
+        unitType: "starting",
+        unitId: "bootstrap",
+        unitStartedAt: new Date().toISOString(),
+      }));
+      // Align worker PID with stale lock metadata.
+      _getAdapter()?.prepare("UPDATE workers SET pid = :pid WHERE worker_id = :id")
+        .run({ ":pid": deadPid, ":id": workerId });
+
+      const result = acquireSessionLock(base);
+      assert.ok(result.acquired, "acquire recovers stale lock");
+      assert.equal(getAutoWorker(workerId)?.status, "stopping");
+      releaseSessionLock(base);
+    } finally {
+      try { closeDatabase(); } catch { /* noop */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   // ─── 3. updateSessionLock preserves lock data ─────────────────────────
   console.log('\n=== 3. updateSessionLock writes metadata ===');
   {

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -7,12 +7,20 @@ import assert from "node:assert/strict";
 import {
   _hasEmptyAgentEndContent,
   _handleSessionSwitchAgentEnd,
+  handleAgentEnd,
   isBareClaudeCodeStreamAbortPlaceholder,
   isClaudeCodeSessionSwitchAbortMessage,
 } from "../bootstrap/agent-end-recovery.js";
+import { _setAutoActiveForTest } from "../auto.js";
 import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js";
+import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.js";
 import type { ErrorContext } from "../auto/types.js";
 
+test.afterEach(() => {
+  _setAutoActiveForTest(false);
+  _resetPendingResolve();
+});
+
 test("user-abort message during session-switch is dropped (not propagated as cancellation)", () => {
   // The Anthropic SDK emits this exact string when newSession() aborts an
   // in-flight stream during a unit-to-unit session transition. Before the fix
@@ -113,6 +121,34 @@ test("late bare Claude Code stream-aborted placeholder is classified as internal
   );
 });
 
+test("mid-unit bare Claude Code stream-aborted placeholder resolves the unit", async () => {
+  // A placeholder without an active session-switch grace window belongs to the
+  // current unit. Resolving it prevents auto-mode from hanging while still
+  // allowing the next unit to run.
+  const results: unknown[] = [];
+  const warnings: string[] = [];
+  _setAutoActiveForTest(true);
+  _setCurrentResolve((result) => results.push(result));
+
+  const event = {
+    messages: [{
+      stopReason: "aborted",
+      content: [{ type: "text", text: "Claude Code stream aborted by caller" }],
+    }],
+  };
+
+  await handleAgentEnd({} as any, event, {
+    ui: {
+      notify: (message: string, level: string) => {
+        if (level === "warning") warnings.push(message);
+      },
+    },
+  } as any);
+
+  assert.deepEqual(results, [{ status: "completed", event }]);
+  assert.deepEqual(warnings, ["Claude Code stream aborted mid-unit (no diagnostic). Continuing."]);
+});
+
 test("typed session-transition abort events are classified as internal", () => {
   assert.equal(
     shouldIgnoreAgentEndForActiveUnit({
@@ -205,6 +241,8 @@ test("missing agent_end content is classified as empty abort content", () => {
   assert.equal(_hasEmptyAgentEndContent(undefined), true);
   assert.equal(_hasEmptyAgentEndContent(null), true);
   assert.equal(_hasEmptyAgentEndContent([]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "" }]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "   " }]), true);
   assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "partial" }]), false);
 });