gsd-pi 2.82.0-dev.dfbc5f58f → 2.82.0-dev.e7a7f1ed5

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/integration/git-service.test.ts

@@ -1168,6 +1168,15 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: rejects milestone branches', () => {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "milestone/M001");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "milestone branches are not recorded as integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: still records legitimate branches ────────
 
   test('Integration branch: records non-ephemeral gsd branches', () => {

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

@@ -22,6 +22,7 @@ import type { IterationContext, LoopState, PreDispatchData, IterationData } from
 import type { SessionLockStatus } from "../session-lock.js";
 import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
+import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
   insertMilestone,
@@ -160,6 +161,8 @@ function makeIC(
     pi: {
       sendMessage: () => {},
       setModel: async () => true,
+      getThinkingLevel: () => "off",
+      setThinkingLevel: () => {},
     } as any,
     s: makeSession(),
     deps,
@@ -868,6 +871,49 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
   assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01"), 2);
 });
 
+test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
+  const capture = createEventCapture();
+  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const deps = makeMockDeps(capture, {
+    selectAndApplyModel: async () => {
+      throw new ModelPolicyDispatchBlockedError("execute-task", "M001/S01/T01", []);
+    },
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+    } as any,
+  });
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+  await assert.rejects(() => runUnitPhase(ic, iterData, loopState), ModelPolicyDispatchBlockedError);
+
+  const startEvents = capture.events.filter(e => e.eventType === "unit-start");
+  assert.equal(startEvents.length, 0, "pre-dispatch validation failures must not emit unit-start");
+  assert.equal(ic.s.unitDispatchCount.get("execute-task/M001/S01/T01") ?? 0, 0, "dispatch count must not increment on pre-dispatch validation failure");
+  assert.equal(
+    readUnitRuntimeRecord(base, "execute-task", "M001/S01/T01"),
+    null,
+    "pre-dispatch validation failures must not persist a dispatched runtime record",
+  );
+});
+
 test("all events from a mock iteration have monotonically increasing seq and same flowId", async () => {
   const capture = createEventCapture();
   const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
+import { _clearGsdRootCache } from "../paths.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
+  Object.defineProperty(process, "platform", { value: platform });
+  try {
+    return fn();
+  } finally {
+    if (descriptor) {
+      Object.defineProperty(process, "platform", descriptor);
+    }
+  }
+}
+
+function realGitPath(): string {
+  const gitExecPath = execFileSync("git", ["--exec-path"], {
+    encoding: "utf-8",
+  }).trim();
+  return join(gitExecPath, process.platform === "win32" ? "git.exe" : "git");
+}
+
+function installGitShim(bin: string, probePath: string): void {
+  const shim = join(bin, "git-proxy.cjs");
+  writeFileSync(
+    shim,
+    `
+const { appendFileSync, existsSync } = require("node:fs");
+const { join } = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const realGit = ${JSON.stringify(realGitPath())};
+const probePath = ${JSON.stringify(probePath)};
+const args = process.argv.slice(2);
+
+if (args[0] === "merge" && args[1] === "--squash") {
+  const sidecars = [
+    join(process.cwd(), ".gsd", "gsd.db-wal"),
+    join(process.cwd(), ".gsd", "gsd.db-shm"),
+  ];
+  const locked = sidecars.find((path) => existsSync(path));
+  if (locked) {
+    appendFileSync(probePath, "blocked:" + locked + "\\n");
+    console.error("error: local changes would be overwritten by merge");
+    console.error("\\t" + locked);
+    process.exit(1);
+  }
+  appendFileSync(probePath, "clean\\n");
+}
+
+const result = spawnSync(realGit, args, { stdio: "inherit", env: process.env });
+process.exit(result.status ?? 1);
+`,
+    "utf-8",
+  );
+
+  if (process.platform === "win32") {
+    writeFileSync(join(bin, "git.cmd"), `@echo off\r\nnode "%~dp0git-proxy.cjs" %*\r\n`, "utf-8");
+  } else {
+    const executable = join(bin, "git");
+    writeFileSync(executable, `#!/bin/sh\nexec node "${shim}" "$@"\n`, "utf-8");
+    chmodSync(executable, 0o755);
+  }
+}
+
+function createRepo(root: string): { repo: string; worktree: string } {
+  const repo = join(root, "repo");
+  mkdirSync(repo, { recursive: true });
+  git(["init"], repo);
+  git(["config", "user.email", "test@test.com"], repo);
+  git(["config", "user.name", "Test"], repo);
+  writeFileSync(join(repo, ".gitignore"), ".gsd/\n", "utf-8");
+  writeFileSync(join(repo, "README.md"), "# test\n", "utf-8");
+  git(["add", "."], repo);
+  git(["commit", "-m", "init"], repo);
+  git(["branch", "-M", "main"], repo);
+
+  git(["checkout", "-b", "milestone/M001"], repo);
+  writeFileSync(join(repo, "feature.txt"), "milestone change\n", "utf-8");
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(join(repo, ".gsd", "gsd.db-shm"), "milestone placeholder\n", "utf-8");
+  git(["add", "feature.txt"], repo);
+  git(["add", "-f", ".gsd/gsd.db-shm"], repo);
+  git(["commit", "-m", "feat: milestone change"], repo);
+  git(["checkout", "main"], repo);
+
+  const wt = worktreePath(repo, "M001");
+  mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+  git(["worktree", "add", wt, "milestone/M001"], repo);
+  return { repo, worktree: wt };
+}
+
+test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merge", () => {
+  const savedCwd = process.cwd();
+  const originalPath = process.env.PATH ?? "";
+  const gitEnv = GIT_NO_PROMPT_ENV as NodeJS.ProcessEnv;
+  const originalGitEnvPath = gitEnv.PATH;
+  const originalHome = process.env.HOME;
+  const originalGsdHome = process.env.GSD_HOME;
+
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-db-cycle-")));
+  const fakeHome = join(root, "home");
+  const bin = join(root, "bin");
+  const probePath = join(root, "merge-probe.txt");
+  mkdirSync(fakeHome, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  installGitShim(bin, probePath);
+
+  try {
+    process.env.HOME = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    const { repo, worktree } = createRepo(root);
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+    withPlatform("win32", () => {
+      assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
+
+      process.env.PATH = `${bin}${delimiter}${originalPath}`;
+      gitEnv.PATH = process.env.PATH;
+      process.chdir(worktree);
+
+      const result = mergeMilestoneToMain(repo, "M001", "# M001: Windows DB cycle\n");
+      assert.equal(result.codeFilesChanged, true);
+    });
+
+    assert.equal(git(["show", "HEAD:feature.txt"], repo), "milestone change");
+    assert.equal(readFileSync(probePath, "utf-8"), "clean\n");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    process.env.PATH = originalPath;
+    gitEnv.PATH = originalGitEnvPath;
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    _clearGsdRootCache();
+    _resetServiceCache();
+    if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -6,13 +6,15 @@ import test from "node:test";
 
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
 import {
-  _getAdapter,
   closeDatabase,
   getAllMilestones,
+  insertMilestone,
+  insertSlice,
+  insertTask,
   getSliceTasks,
 } from "../gsd-db.ts";
 import {
-  autoImportMarkdownHierarchyIfDbMismatch,
+  checkMarkdownHierarchyAgainstDb,
   countMarkdownHierarchy,
 } from "../migration-auto-check.ts";
 import { writeGSDDirectory } from "../migrate/writer.ts";
@@ -70,7 +72,7 @@ function projectFixture(): GSDProject {
   };
 }
 
-test("migration auto-check imports markdown hierarchy when DB is empty", async () => {
+test("migration auto-check preserves empty DB and reports explicit recovery", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
@@ -79,32 +81,35 @@ test("migration auto-check imports markdown hierarchy when DB is empty", async (
     assert.equal(await ensureDbOpen(base), true);
     assert.equal(getAllMilestones().length, 0, "fresh authoritative DB starts empty");
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
-    assert.equal(result.action, "imported");
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "db-empty");
-    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
-    assert.equal(getAllMilestones().length, 1);
-    assert.equal(getSliceTasks("M001", "S01").length, 1);
+    assert.deepEqual(result.afterDb, { milestones: 0, slices: 0, tasks: 0 });
+    assert.equal(result.recoveryCommand, "gsd recover");
+    assert.match(result.message ?? "", /will not import markdown automatically/);
+    assert.equal(getAllMilestones().length, 0);
+    assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);
   }
 });
 
-test("migration auto-check repairs DB hierarchy count mismatch", async () => {
+test("migration auto-check preserves DB on hierarchy count mismatch", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
-    await autoImportMarkdownHierarchyIfDbMismatch(base);
-
-    _getAdapter()!.prepare("DELETE FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?").run("M001", "S01", "T01");
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
     assert.equal(getSliceTasks("M001", "S01").length, 0, "test fixture simulates stale DB task count");
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
-    assert.equal(result.action, "imported");
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "count-mismatch");
     assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 0 });
-    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
-    assert.equal(getSliceTasks("M001", "S01").length, 1);
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 0 });
+    assert.equal(result.recoveryCommand, "gsd recover");
+    assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);
   }
@@ -114,9 +119,12 @@ test("migration auto-check leaves matching DB hierarchy alone", async () => {
   const base = makeBase();
   try {
     await writeGSDDirectory(projectFixture(), base);
-    await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
 
-    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    const result = await checkMarkdownHierarchyAgainstDb(base);
     assert.equal(result.action, "none");
     assert.equal(result.reason, "in-sync");
     assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });

package/src/resources/extensions/gsd/tests/pending-autostart-scope.test.ts

@@ -11,6 +11,7 @@ import {
   clearPendingAutoStart,
   _getPendingAutoStart,
 } from "../guided-flow.ts";
+import type { PendingAutoStartInput } from "../pending-auto-start.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -20,6 +21,15 @@ function makeProjectDir(): string {
   return dir;
 }
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("pendingAutoStart scope pinning (C1)", () => {
@@ -38,7 +48,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("setPendingAutoStart stores a scope whose paths derive from the basePath at reservation time", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -54,8 +64,22 @@ describe("pendingAutoStart scope pinning (C1)", () => {
     assert.equal(entry.scope.stateFile(), expectedState);
   });
 
+  test("setPendingAutoStart rejects entries without ctx and pi before storing them", () => {
+    assert.throws(
+      () =>
+        setPendingAutoStart(base, {
+          basePath: base,
+          milestoneId: "M001",
+        } as PendingAutoStartInput),
+      /requires ctx and pi/,
+      "pending entries must include the handles later used by auto-start recovery",
+    );
+
+    assert.equal(_getPendingAutoStart(base), null);
+  });
+
   test("scope paths are unaffected by process.chdir after reservation", (t) => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M002" });
+    setPendingAutoStart(base, pendingInput(base, "M002"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -82,7 +106,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
 
   test("scope identityKey matches the realpath of the original basePath even with trailing slash", () => {
     const baseWithSlash = base + "/";
-    setPendingAutoStart(base, { basePath: baseWithSlash, milestoneId: "M003" });
+    setPendingAutoStart(base, pendingInput(baseWithSlash, "M003"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -96,7 +120,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("clearPendingAutoStart removes the entry", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const before = _getPendingAutoStart(base);
     assert.ok(before, "entry should exist before clear");
@@ -108,7 +132,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("_getPendingAutoStart with no basePath argument returns the sole entry", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     // No argument — should return the sole entry
     const entry = _getPendingAutoStart();

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

@@ -65,7 +65,9 @@ test("plan-slice prompt: DB-backed tool names survive template substitution", ()
   const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
   assert.ok(result.includes("gsd_plan_slice"), "gsd_plan_slice should appear in rendered prompt");
   assert.ok(result.includes("gsd_plan_task"), "gsd_plan_task should appear in rendered prompt");
+  assert.ok(result.includes("gsd_decision_save"), "structural decisions should use DB-backed decision tool");
   assert.ok(result.includes("canonical write path"), "canonical write path language should survive substitution");
+  assert.doesNotMatch(result, /append them to `.gsd\/DECISIONS\.md`/);
 });
 
 test("plan-slice prompt: compact planning gates survive template substitution", () => {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -141,3 +141,62 @@ test("category summaries expose the wizard menu surface for configured prefs", (
   assert.match(summaries.integrations, /remote: C123/);
   assert.match(summaries.verification, /1 cmd/);
 });
+
+test("models wizard offers discovered models for enabled providers", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  const choices = [
+    "Models",
+    "local (2 models)",
+    "discovered-model",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+  ];
+  const ctx = {
+    modelRegistry: {
+      getAvailable: () => [{ provider: "local", id: "baseline-model" }],
+      getAllWithDiscovered: () => [
+        { provider: "local", id: "baseline-model" },
+        { provider: "local", id: "discovered-model" },
+        { provider: "disabled", id: "hidden-model" },
+      ],
+    },
+    ui: {
+      notify() {},
+      select: async (label: string, options: string[]) => {
+        const choice = choices.shift();
+        if (!choice && label === "GSD Preferences") return "── Save & Exit ──";
+        if (!choice && options.includes("(keep current)")) return "(keep current)";
+        if (!choice && options.includes("Done")) return "Done";
+        assert.ok(choice, `Unexpected prompt: ${label}`);
+        if (choice === "Models") {
+          const modelsOption = options.find((option) => option.startsWith("Models"));
+          assert.ok(modelsOption, "Expected Models category option");
+          return modelsOption;
+        }
+        assert.ok(options.includes(choice), `"${choice}" must be offered by "${label}"`);
+        assert.ok(!options.includes("hidden-model"), "models from disabled providers must not be offered");
+        return choice;
+      },
+      input: async () => null,
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
+
+  try {
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    assert.equal(choices.length, 0, "Expected all queued wizard choices to be consumed");
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /research:\s+local\/discovered-model/);
+    assert.doesNotMatch(saved, /hidden-model/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

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

@@ -10,7 +10,12 @@ import assert from "node:assert/strict";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import {
+  MAX_TRANSIENT_AUTO_RESUMES,
+  isTerminalDeletedWorktreeProviderError,
+  resetTransientRetryState,
+  shouldDeferTransientErrorToCoreRetry,
+} from "../bootstrap/agent-end-recovery.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -399,6 +404,25 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
   ]);
 });
 
+test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/.gsd/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/src/file.ts" does not exist'),
+    false,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" failed with EACCES'),
+    false,
+  );
+});
+
 // ── resumeAutoAfterProviderDelay ────────────────────────────────────────────
 
 test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded base path", async () => {
@@ -659,3 +683,15 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
   assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });
+
+test("exhausted retry errors are not deferred back to core retry handling", () => {
+  const cls = classifyError("Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload");
+  assert.equal(cls.kind, "server");
+  assert.equal(
+    shouldDeferTransientErrorToCoreRetry(
+      cls,
+      "Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload",
+    ),
+    false,
+  );
+});

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

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { showQueueReorder } from "../queue-reorder-ui.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("queue-reorder-ui", () => {
+  test("keeps cursor visible while scrolling long queue with arrow keys (#4656)", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 20, configurable: true });
+
+    try {
+      const pending = Array.from({ length: 20 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+
+      let resolved: { order: string[]; depsToRemove: Array<{ milestone: string; dep: string }> } | null = null;
+      let lastRender: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, (value: any) => {
+              resolved = value;
+            });
+
+            for (let i = 0; i < 15; i++) component.handleInput("\u001b[B");
+            lastRender = component.render(100);
+            component.handleInput("\r");
+            return resolved;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, [], pending);
+
+      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}`);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+});