@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -238,6 +238,67 @@ function createPostExecFailureTask(): void {
   });
 }
 
+function createPostExecWarningTask(): void {
+  insertMilestone({ id: "M001" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  const srcDir = join(tempDir, "src");
+  mkdirSync(srcDir, { recursive: true });
+  writeFileSync(
+    join(srcDir, "prior.ts"),
+    "export function formatName(name: string): string { return name; }\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(srcDir, "current.ts"),
+    "export function formatName(first: string, last: string): string { return `${first} ${last}`; }\n",
+    "utf-8",
+  );
+
+  insertTask({
+    id: "T00",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Prior task",
+    status: "complete",
+    keyFiles: ["src/prior.ts"],
+    planning: {
+      description: "Prior task with original signature",
+      estimate: "1h",
+      files: ["src/prior.ts"],
+      verify: "echo pass",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task with signature warning",
+    status: "pending",
+    keyFiles: ["src/current.ts"],
+    planning: {
+      description: "Task that changes a prior function signature",
+      estimate: "1h",
+      files: ["src/current.ts"],
+      verify: "echo pass",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 1,
+  });
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("Post-execution blocking failure retry bypass", () => {
@@ -359,13 +420,8 @@ describe("Post-execution blocking failure retry bypass", () => {
     assert.ok(messages.some((m: string) => m.includes("Verification failed") && m.includes("auto-fix attempt 1/2")));
   });
 
-  test("post-exec failure notification mentions cross-task consistency", async () => {
-    // This test verifies that the notification for post-exec failures includes
-    // the appropriate message about cross-task consistency issues.
-    // The actual post-exec failure would require specific file/output state
-    // that's harder to set up in a unit test, but we can verify the code path exists.
-    
-    createBasicTask();
+  test("post-exec failure notification includes failing check details", async () => {
+    createPostExecFailureTask();
     writePreferences({
       enhanced_verification: true,
       enhanced_verification_post: true,
@@ -381,9 +437,70 @@ describe("Post-execution blocking failure retry bypass", () => {
     const vctx: VerificationContext = { s, ctx, pi };
     const result = await runPostUnitVerification(vctx, pauseAutoMock);
 
-    // The verification should pass with our simple "echo pass" task
-    // This test mainly confirms the wiring is correct
-    assert.equal(result, "continue");
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    const notifyMessages = ctx.ui.notify.mock.calls.map((c: { arguments: unknown[] }) =>
+      String(c.arguments[0])
+    );
+    assert.ok(
+      notifyMessages.some(
+        (m: string) =>
+          m.includes("Post-execution checks failed ([import] src/broken.ts:1") &&
+          m.includes("pausing for human review")
+      )
+    );
+
+    const pauseCalls = pauseAutoMock.mock.calls as Array<{ arguments: unknown[] }>;
+    const pauseCallArgs = pauseCalls[0]?.arguments[2] as
+      | { message?: string }
+      | undefined;
+    assert.ok(
+      pauseCallArgs?.message?.includes(
+        "Post-execution checks failed: [import] src/broken.ts:1"
+      )
+    );
+  });
+
+  test("strict post-exec warning pause includes warning details", async () => {
+    createPostExecWarningTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      enhanced_verification_strict: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    const notifyMessages = ctx.ui.notify.mock.calls.map((c: { arguments: unknown[] }) =>
+      String(c.arguments[0])
+    );
+    assert.ok(
+      notifyMessages.some(
+        (m: string) =>
+          m.includes("Post-execution checks failed ([signature] formatName:") &&
+          m.includes("pausing for human review")
+      )
+    );
+
+    const pauseCalls = pauseAutoMock.mock.calls as Array<{ arguments: unknown[] }>;
+    const pauseCallArgs = pauseCalls[0]?.arguments[2] as
+      | { message?: string }
+      | undefined;
+    assert.ok(
+      pauseCallArgs?.message?.includes(
+        "Post-execution checks failed: [signature] formatName:"
+      )
+    );
+    assert.ok(!pauseCallArgs?.message?.includes("unknown post-execution check failure"));
   });
 
   test("uok gate runner persists post-execution gate failures when enabled", async () => {

package/src/resources/extensions/gsd/tests/post-execution-checks.test.ts

@@ -451,6 +451,50 @@ describe("checkImportResolution", () => {
     }
   });
 
+  test("ignores generated SvelteKit $types imports", () => {
+    tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    mkdirSync(join(tempDir, "src", "routes"), { recursive: true });
+    writeFileSync(
+      join(tempDir, "src", "routes", "+page.ts"),
+      "import type { PageLoad } from './$types';\nexport const load: PageLoad = async () => ({})"
+    );
+
+    try {
+      const task = createTask({
+        id: "T01",
+        key_files: ["src/routes/+page.ts"],
+      });
+
+      const results = checkImportResolution(task, [], tempDir);
+      assert.deepEqual(results, []);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("ignores nested generated SvelteKit $types imports", () => {
+    tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    mkdirSync(join(tempDir, "src", "lib", "components"), { recursive: true });
+    writeFileSync(
+      join(tempDir, "src", "lib", "components", "RouteCard.ts"),
+      "import type { PageData } from '../../routes/blog/$types';\nexport const data = {} as PageData;"
+    );
+
+    try {
+      const task = createTask({
+        id: "T01",
+        key_files: ["src/lib/components/RouteCard.ts"],
+      });
+
+      const results = checkImportResolution(task, [], tempDir);
+      assert.deepEqual(results, []);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
   test("fails when import doesn't resolve", () => {
     tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });

package/src/resources/extensions/gsd/tests/post-unit-retry-on-orchestrator-bridge.test.ts

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mock } from "node:test";
+
+import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
+import { AutoSession } from "../auto/session.ts";
+import { checkPostUnitHooks, resetHookState, resolveHookArtifactPath } from "../post-unit-hooks.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+function writePreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    agent: arbiter
+    artifact: REVIEW-DEBATE.md
+    retry_on: NEEDS-REWORK.md
+    max_cycles: 3
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
+test("post-unit retry_on marks trigger unit as retry in orchestrator before redispatch", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-retry-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writePreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(hookDispatch, "hook should dispatch for execute-task");
+
+    const retryPath = resolveHookArtifactPath(base, "M001/S01/T01", "NEEDS-REWORK.md");
+    writeFileSync(retryPath, "rework requested", "utf-8");
+
+    const retryActiveUnit = mock.fn(async (_unit: { unitType: string; unitId: string }) => {});
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+    s.orchestration = {
+      start: async () => ({ kind: "started" }),
+      advance: async () => ({ kind: "stopped", reason: "unused" }),
+      completeActiveUnit: async () => {},
+      retryActiveUnit,
+      resume: async () => ({ kind: "resumed" }),
+      stop: async (reason: string) => ({ kind: "stopped", reason }),
+      getStatus: () => ({ phase: "running", transitionCount: 0 }),
+    };
+
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: { notify: () => {}, setStatus: () => {}, setWidget: () => {}, setFooter: () => {} },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "continue");
+    assert.equal(retryActiveUnit.mock.callCount(), 1);
+    assert.deepEqual(retryActiveUnit.mock.calls[0]?.arguments[0], {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -204,6 +204,32 @@ describe("project-relocation-recovery (#2750)", () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test("local-only repo does not warn when origin remote is missing", () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-no-origin-")));
+    initRepo(repo);
+
+    const warnings: unknown[][] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnings.push(args);
+    };
+
+    try {
+      repoIdentity(repo);
+      externalGsdRoot(repo);
+      ensureGsdSymlink(repo);
+    } finally {
+      console.warn = originalWarn;
+      rmSync(repo, { recursive: true, force: true });
+    }
+
+    assert.deepStrictEqual(
+      warnings,
+      [],
+      "missing origin must be treated as local-only repo, not a git failure",
+    );
+  });
+
   test("local-only repo recovers state via .gsd-id marker after move", () => {
     const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-local-a-")));
     initRepo(repoA);
@@ -245,6 +271,81 @@ describe("project-relocation-recovery (#2750)", () => {
     rmSync(repoB, { recursive: true, force: true });
   });
 
+  test("repoIdentity ignores stale .gsd-id after relocation migration when git remote lookup fails", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-stale-marker-a-")));
+    initRepo(repoA);
+
+    const externalA = ensureGsdSymlink(repoA);
+    mkdirSync(join(externalA, "milestones"), { recursive: true });
+    writeFileSync(join(externalA, "milestones", "M001.md"), "# Local Milestone\n", "utf-8");
+
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-stale-marker-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    const migratedExternal = externalGsdRoot(repoB);
+    const expectedIdentity = repoIdentity(repoB);
+    rmSync(join(repoB, ".git", "config"), { force: true });
+
+    const warnings: unknown[][] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnings.push(args);
+    };
+
+    try {
+      assert.strictEqual(
+        repoIdentity(repoB),
+        expectedIdentity,
+        "transient git failures must not pin identity to a stale marker",
+      );
+      assert.ok(
+        existsSync(join(migratedExternal, "milestones", "M001.md")),
+        "migrated state remains under the recovered identity",
+      );
+    } finally {
+      console.warn = originalWarn;
+      rmSync(repoB, { recursive: true, force: true });
+    }
+  });
+
+  test("externalGsdRoot syncs .gsd-id after recovering remote-backed state", () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-remote-marker-")));
+    initRepo(repo, "https://github.com/example/remote-marker.git");
+
+    const expectedIdentity = repoIdentity(repo);
+    const staleMarkerId = "stale-marker-id";
+    const staleExternal = join(stateDir, "projects", staleMarkerId);
+    mkdirSync(join(staleExternal, "milestones"), { recursive: true });
+    writeFileSync(join(staleExternal, "milestones", "M001.md"), "# Remote Milestone\n", "utf-8");
+    writeFileSync(join(repo, ".gsd-id"), `${staleMarkerId}\n`, "utf-8");
+
+    const recoveredExternal = externalGsdRoot(repo);
+    assert.strictEqual(
+      readFileSync(join(repo, ".gsd-id"), "utf-8").trim(),
+      expectedIdentity,
+      "recovery must update .gsd-id to the identity that now owns migrated state",
+    );
+
+    rmSync(join(repo, ".git", "config"), { force: true });
+
+    try {
+      assert.strictEqual(
+        repoIdentity(repo),
+        expectedIdentity,
+        "transient git failures must keep using the recovered remote-backed identity",
+      );
+      assert.ok(
+        existsSync(join(recoveredExternal, "milestones", "M001.md")),
+        "migrated state remains under the recovered remote-backed identity",
+      );
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+    }
+  });
+
   // ── Edge cases ────────────────────────────────────────────────────────
 
   test("identity remains different for repos with different remotes", () => {

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -2,6 +2,7 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
 import { showQueueReorder } from "../queue-reorder-ui.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const fakeTheme = {
   fg: (_color: string, text: string) => text,
@@ -43,6 +44,51 @@ describe("queue-reorder-ui", () => {
       const joined = lastRender.join("\n");
       assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
       assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+      assertFullOuterBorder(lastRender, 100);
+      assert.match(lastRender[0] ?? "", /^╭─ Queue Reorder /);
+      assert.match(lastRender.at(-1) ?? "", /^╰─+╯$/);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+
+  test("draws queue scroll thumb beside queue rows when completed rows are shown", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 12, configurable: true });
+
+    try {
+      const completed = [
+        { id: "M000", title: "Already done" },
+      ];
+      const pending = Array.from({ length: 8 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+      let rendered: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, () => {});
+            rendered = component.render(80);
+            return null;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, completed, pending);
+
+      const completedHeader = rendered.find(line => line.includes("Completed:"));
+      const firstQueueRow = rendered.find(line => line.includes("M001"));
+      assert.ok(completedHeader, "completed header should be rendered before queue rows");
+      assert.ok(firstQueueRow, "first queue row should be rendered");
+      assert.match(completedHeader, /│$/);
+      assert.match(firstQueueRow, /┃$/);
     } finally {
       if (originalRowsDescriptor) {
         Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -134,6 +134,72 @@ test("handleRecoverableExtensionProcessError swallows EPIPE without writing a cr
   }
 });
 
+test("handleRecoverableExtensionProcessError tolerates stderr.write throwing EPIPE (re-entry guard)", () => {
+  // process.stderr.write itself can EPIPE; safeStderr() must swallow it so the
+  // handler doesn't re-enter the EPIPE branch and loop forever.
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = (() => {
+    throw Object.assign(new Error("stderr broken pipe"), {
+      code: "EPIPE",
+      syscall: "write",
+    });
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("broken pipe"), {
+        code: "EPIPE",
+        syscall: "write",
+      }),
+    );
+    assert.equal(handled, true);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+// #181: Windows surfaces a closed pipe mid-write as `Error: write EOF` (or
+// `read EOF`) with no `code` set. Both are the same logical condition as POSIX
+// EPIPE and must be swallowed, else they escape to the uncaught-exception path
+// and crash auto-mode workers. These non-storm cases run before the storm test
+// below so the shared storm counter stays under threshold. ECONNRESET is
+// intentionally NOT in this set — see the dedicated "leaves ECONNRESET network
+// errors unhandled" test above.
+test("handleRecoverableExtensionProcessError swallows Windows 'write EOF' (no code)", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    // Mirror the real Windows error: message "write EOF", no `code`, no `syscall`.
+    const handled = handleRecoverableExtensionProcessError(new Error("write EOF"));
+    assert.equal(handled, true);
+    assert.match(stderr, /swallowed write EOF/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError swallows 'read EOF' (no code)", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(new Error("read EOF"));
+    assert.equal(handled, true);
+    assert.match(stderr, /swallowed read EOF/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
 test("handleRecoverableExtensionProcessError swallows dead transport control write errors", () => {
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
@@ -153,7 +219,16 @@ test("handleRecoverableExtensionProcessError swallows dead transport control wri
   }
 });
 
-test("handleRecoverableExtensionProcessError swallows write EOF without code", () => {
+test("handleRecoverableExtensionProcessError leaves a plain EOF-substring error unhandled", () => {
+  // Guard against over-matching: only the exact "write EOF"/"read EOF" messages
+  // are the Windows pipe-closed signature; an unrelated error must not be eaten.
+  const handled = handleRecoverableExtensionProcessError(new Error("could not write EOF marker to log"));
+  assert.equal(handled, false);
+});
+
+test("handleRecoverableExtensionProcessError exits on EPIPE storm (>100 within 10s)", () => {
+  // After the storm threshold, the pipe is gone for good — handler must exit
+  // cleanly instead of swallowing forever in a tight CPU loop.
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
   process.stderr.write = ((chunk: string | Uint8Array) => {
@@ -161,18 +236,38 @@ test("handleRecoverableExtensionProcessError swallows write EOF without code", (
     return true;
   }) as typeof process.stderr.write;
 
+  const originalExit = process.exit;
+  const exitCalls: Array<number | undefined> = [];
+  process.exit = ((code?: number) => {
+    exitCalls.push(code);
+    // Don't actually exit; just record the call.
+    return undefined as never;
+  }) as typeof process.exit;
+
   try {
-    const handled = handleRecoverableExtensionProcessError(
-      new Error("write EOF"),
+    const err = Object.assign(new Error("broken pipe"), {
+      code: "EPIPE",
+      syscall: "write",
+    });
+    // Fire well above the 100-event threshold inside the 10s window.
+    for (let i = 0; i < 150; i++) {
+      handleRecoverableExtensionProcessError(err);
+    }
+    assert.ok(
+      exitCalls.length > 0,
+      `expected process.exit to be called during EPIPE storm, got ${exitCalls.length} calls`,
     );
-    assert.equal(handled, true);
-    assert.match(stderr, /swallowed write EOF/);
+    assert.equal(exitCalls[0], 0);
+    assert.match(stderr, /EPIPE storm/);
   } finally {
     process.stderr.write = originalWrite;
+    process.exit = originalExit;
   }
 });
 
-test("handleRecoverableExtensionProcessError swallows read EOF without code", () => {
+test("handleRecoverableExtensionProcessError exits on a Windows 'write EOF' storm too (#181)", () => {
+  // The storm counter is shared across all pipe-closed encodings, so a runaway
+  // Windows `write EOF` loop must trip the same clean-exit guard as EPIPE.
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
   process.stderr.write = ((chunk: string | Uint8Array) => {
@@ -180,13 +275,23 @@ test("handleRecoverableExtensionProcessError swallows read EOF without code", ()
     return true;
   }) as typeof process.stderr.write;
 
+  const originalExit = process.exit;
+  const exitCalls: Array<number | undefined> = [];
+  process.exit = ((code?: number) => {
+    exitCalls.push(code);
+    return undefined as never;
+  }) as typeof process.exit;
+
   try {
-    const handled = handleRecoverableExtensionProcessError(
-      new Error("read EOF"),
-    );
-    assert.equal(handled, true);
-    assert.match(stderr, /swallowed read EOF/);
+    const err = new Error("write EOF");
+    for (let i = 0; i < 150; i++) {
+      handleRecoverableExtensionProcessError(err);
+    }
+    assert.ok(exitCalls.length > 0, "expected process.exit during write EOF storm");
+    assert.equal(exitCalls[0], 0);
+    assert.match(stderr, /write EOF storm/);
   } finally {
     process.stderr.write = originalWrite;
+    process.exit = originalExit;
   }
 });

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

@@ -255,4 +255,31 @@ test('ensureGsdSymlink prefers marker directory when marker/computed identities
     rmSync(repo, { recursive: true, force: true });
 });
 
+test('repoIdentity/externalGsdRoot stay marker-stable when git remote read transiently fails (#276)', () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-remote-transient-")));
+    run("git init -b main", repo);
+    run('git config user.name "Pi Test"', repo);
+    run('git config user.email "pi@example.com"', repo);
+    run('git remote add origin git@github.com:example/transient.git', repo);
+    writeFileSync(join(repo, "README.md"), "# Transient Remote Test\n", "utf-8");
+    run("git add README.md", repo);
+    run('git commit -m "init"', repo);
+
+    const stableExternal = ensureGsdSymlink(repo);
+    const stableIdentity = repoIdentity(repo);
+    assert.deepStrictEqual(externalGsdRoot(repo), stableExternal, "externalGsdRoot initially resolves canonical state directory");
+
+    const gitConfigPath = join(repo, ".git", "config");
+    const gitConfigBakPath = join(repo, ".git", "config.bak");
+    renameSync(gitConfigPath, gitConfigBakPath);
+
+    try {
+      assert.deepStrictEqual(repoIdentity(repo), stableIdentity, "repoIdentity remains anchored to .gsd-id marker during transient git remote read failure");
+      assert.deepStrictEqual(externalGsdRoot(repo), stableExternal, "externalGsdRoot remains marker-resolved during transient git remote read failure");
+    } finally {
+      renameSync(gitConfigBakPath, gitConfigPath);
+      rmSync(repo, { recursive: true, force: true });
+    }
+});
+
 });