gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.98b44dc

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

@@ -7,6 +7,7 @@ import {
   resolveAgentEnd,
   runUnit,
   autoLoop,
+  detectStuck,
   _resetPendingResolve,
   _setActiveSession,
   isSessionSwitchInFlight,
@@ -37,9 +38,6 @@ function makeMockSession(opts?: {
   const session = {
     active: true,
     verbose: false,
-    sessionSwitchInFlight: false,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     cmdCtx: {
       newSession: () => {
         opts?.onNewSessionStart?.(session);
@@ -96,7 +94,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event = makeEvent();
 
   // Start runUnit — it will create the promise and send a message,
@@ -108,7 +105,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
     "task",
     "T01",
     "do stuff",
-    undefined,
   );
 
   // Give the microtask queue a tick so runUnit reaches the await
@@ -122,44 +118,35 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   assert.deepEqual(result.event, event);
 });
 
-test("resolveAgentEnd queues event when no promise is pending", () => {
+test("resolveAgentEnd drops event when no promise is pending", () => {
   _resetPendingResolve();
-  const s = makeMockSession();
-  _setActiveSession(s);
 
-  // Should not throw — queues the event for the next runUnit
+  // Should not throw — event is dropped (logged as warning)
   assert.doesNotThrow(() => {
     resolveAgentEnd(makeEvent());
   });
-  assert.equal(s.pendingAgentEndQueue.length, 1, "event should be queued");
 });
 
-test("double resolveAgentEnd only resolves once (second is queued)", async () => {
+test("double resolveAgentEnd only resolves once (second is dropped)", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event1 = makeEvent([{ id: 1 }]);
   const event2 = makeEvent([{ id: 2 }]);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 10));
 
   // First resolve — should work
   resolveAgentEnd(event1);
 
-  // Second resolve — should be queued (no pending promise)
+  // Second resolve — should be dropped (no pending resolver)
   assert.doesNotThrow(() => {
     resolveAgentEnd(event2);
   });
-  assert.equal(
-    s.pendingAgentEndQueue.length,
-    1,
-    "second event should be queued",
-  );
 
   const result = await resultPromise;
   assert.equal(result.status, "completed");
@@ -174,7 +161,7 @@ test("runUnit returns cancelled when session creation fails", async () => {
   const pi = makeMockPi();
   const s = makeMockSession({ newSessionThrows: "connection refused" });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -190,7 +177,7 @@ test("runUnit returns cancelled when session creation times out", async () => {
   // Session returns cancelled: true (simulates the timeout race outcome)
   const s = makeMockSession({ newSessionResult: { cancelled: true } });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -205,35 +192,31 @@ test("runUnit returns cancelled when s.active is false before sendMessage", asyn
   const s = makeMockSession();
   s.active = false;
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(pi.calls.length, 0);
 });
 
-test("runUnit only arms pendingResolve after newSession completes", async () => {
+test("runUnit only arms resolve after newSession completes", async () => {
   _resetPendingResolve();
 
   let sawSwitchFlag = false;
-  let sawPendingResolve: unknown = "unset";
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession({
     newSessionDelayMs: 20,
-    onNewSessionStart: (session) => {
-      sawSwitchFlag = session.sessionSwitchInFlight;
-      sawPendingResolve = session.pendingResolve;
+    onNewSessionStart: () => {
+      sawSwitchFlag = isSessionSwitchInFlight();
     },
   });
-  _setActiveSession(s);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 30));
 
   assert.equal(sawSwitchFlag, true, "session switch guard should be active during newSession");
-  assert.equal(sawPendingResolve, null, "pendingResolve should not be armed before newSession completes");
   assert.equal(isSessionSwitchInFlight(), false, "session switch guard should clear after newSession settles");
 
   resolveAgentEnd(makeEvent());
@@ -275,24 +258,23 @@ test("auto-loop.ts contains a while keyword", () => {
   );
 });
 
-test("auto-loop.ts one-shot pattern: pendingResolve is nulled before calling resolver", () => {
+test("auto-loop.ts one-shot pattern: _currentResolve is nulled before calling resolver", () => {
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
   // The one-shot pattern requires: save ref, null the variable, then call
-  // Look for the pattern: s.pendingResolve = null appearing before r(
   const resolveBlock = src.slice(
     src.indexOf("export function resolveAgentEnd"),
     src.indexOf("export function resolveAgentEnd") + 600,
   );
-  const nullIdx = resolveBlock.indexOf("pendingResolve = null");
+  const nullIdx = resolveBlock.indexOf("_currentResolve = null");
   const callIdx = resolveBlock.indexOf("r({");
-  assert.ok(nullIdx > 0, "should null pendingResolve in resolveAgentEnd");
+  assert.ok(nullIdx > 0, "should null _currentResolve in resolveAgentEnd");
   assert.ok(callIdx > 0, "should call resolver in resolveAgentEnd");
   assert.ok(
     nullIdx < callIdx,
-    "pendingResolve should be nulled before calling the resolver (one-shot)",
+    "_currentResolve should be nulled before calling the resolver (one-shot)",
   );
 });
 
@@ -462,8 +444,6 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     pendingQuickTasks: [],
     sidecarQueue: [],
     autoModeStartModel: null,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     unitDispatchCount: new Map<string, number>(),
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
@@ -1063,7 +1043,7 @@ test("handleAgentEnd in auto.ts is a thin wrapper calling resolveAgentEnd", () =
 
 // ── Stuck counter tests ──────────────────────────────────────────────────────
 
-test("stuck counter: stops when deriveState returns same unit 5 consecutive times", async () => {
+test("stuck detection: stops when sliding window detects same unit 3 consecutive times", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1098,20 +1078,15 @@ test("stuck counter: stops when deriveState returns same unit 5 consecutive time
 
   const loopPromise = autoLoop(ctx, pi, s, deps);
 
-  // The loop will dispatch the same unit each iteration. On iteration 1, sameUnitCount
-  // starts at 0 and the unit key is set. On iterations 2-5, sameUnitCount increments.
-  // At sameUnitCount=5 (iteration 6), stopAuto is called.
-  // Each iteration requires resolving an agent_end event.
-  // But the stuck counter fires BEFORE runUnit, so we only need to resolve 4 times
-  // (iterations 1-4 each run a unit, iteration 5 increments to 5 and stops).
-
-  // Actually: iteration 1 sets lastDerivedUnit (sameUnitCount=0).
-  // Iteration 2: derivedKey === lastDerivedUnit → sameUnitCount=1.
-  // Iteration 3: sameUnitCount=2. Iteration 4: sameUnitCount=3.
-  // Iteration 5: sameUnitCount=4. Iteration 6: sameUnitCount=5 → stop.
-  // So we need to resolve 5 agent_end events (iterations 1-5 each run a unit).
+  // Sliding window: iteration 1 pushes [A], iteration 2 pushes [A,A],
+  // iteration 3 pushes [A,A,A] → Rule 2 fires (3 consecutive) → Level 1 recovery.
+  // Level 1 invalidates caches and continues. Iteration 4 pushes [A,A,A,A] →
+  // Rule 2 fires again → Level 2 hard stop.
+  // Iterations 1-3 each run a unit (3 resolves needed). Iteration 3 triggers
+  // Level 1 (cache invalidation + continue). Iteration 4 triggers Level 2 (stop
+  // before runUnit), so no 4th resolve needed.
 
-  for (let i = 0; i < 5; i++) {
+  for (let i = 0; i < 3; i++) {
     await new Promise((r) => setTimeout(r, 30));
     resolveAgentEnd(makeEvent());
   }
@@ -1126,17 +1101,13 @@ test("stuck counter: stops when deriveState returns same unit 5 consecutive time
     stopReason.includes("Stuck"),
     `stop reason should mention 'Stuck', got: ${stopReason}`,
   );
-  assert.ok(
-    stopReason.includes("execute-task"),
-    "stop reason should include unitType",
-  );
   assert.ok(
     stopReason.includes("M001/S01/T01"),
     "stop reason should include unitId",
   );
 });
 
-test("stuck counter: resets when deriveState returns a different unit", async () => {
+test("stuck detection: window resets recovery when deriveState returns a different unit", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1197,10 +1168,11 @@ test("stuck counter: resets when deriveState returns a different unit", async ()
 
   await loopPromise;
 
-  // The counter should have reset when T02 was derived — no stuck stop
+  // Level 1 recovery fires on iteration 3 (cache invalidation + continue),
+  // then iteration 4 derives T02 — no Level 2 hard stop.
   assert.ok(
     !stopCalled,
-    "stopAuto should NOT have been called — counter reset on unit change",
+    "stopAuto should NOT have been called — different unit broke stuck pattern",
   );
   assert.ok(
     deriveCallCount >= 4,
@@ -1208,7 +1180,7 @@ test("stuck counter: resets when deriveState returns a different unit", async ()
   );
 });
 
-test("stuck counter: does not increment during verification retry", async () => {
+test("stuck detection: does not push to window during verification retry", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -1270,10 +1242,10 @@ test("stuck counter: does not increment during verification retry", async () =>
   await loopPromise;
 
   // Even though same unit was derived 4 times, verification retries should
-  // not count, so stuck counter should not have fired
+  // not push to the sliding window, so stuck detection should not have fired
   assert.ok(
     !stopReason.includes("Stuck"),
-    `stuck counter should not fire during verification retries, got: ${stopReason}`,
+    `stuck detection should not fire during verification retries, got: ${stopReason}`,
   );
   assert.equal(
     verifyCallCount,
@@ -1282,24 +1254,106 @@ test("stuck counter: does not increment during verification retry", async () =>
   );
 });
 
-test("stuck counter: logs debug output with stuck-detected phase", () => {
-  // Structural test: verify the auto-loop.ts source contains both
-  // stuck-detected and stuck-counter-reset debug log phases
+// ── detectStuck unit tests ────────────────────────────────────────────────────
+
+test("detectStuck: returns null for fewer than 2 entries", () => {
+  assert.equal(detectStuck([]), null);
+  assert.equal(detectStuck([{ key: "A" }]), null);
+});
+
+test("detectStuck: Rule 1 — same error twice in a row", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: file not found" },
+    { key: "A", error: "ENOENT: file not found" },
+  ]);
+  assert.ok(result?.stuck, "should detect same error repeated");
+  assert.ok(result?.reason.includes("Same error repeated"));
+});
+
+test("detectStuck: Rule 1 — different errors do not trigger", () => {
+  const result = detectStuck([
+    { key: "A", error: "ENOENT: file not found" },
+    { key: "A", error: "EACCES: permission denied" },
+  ]);
+  assert.equal(result, null);
+});
+
+test("detectStuck: Rule 2 — same unit 3 consecutive times", () => {
+  const result = detectStuck([
+    { key: "execute-task/M001/S01/T01" },
+    { key: "execute-task/M001/S01/T01" },
+    { key: "execute-task/M001/S01/T01" },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result?.reason.includes("3 consecutive times"));
+});
+
+test("detectStuck: Rule 2 — 2 consecutive does not trigger", () => {
+  assert.equal(detectStuck([
+    { key: "A" },
+    { key: "A" },
+  ]), null);
+});
+
+test("detectStuck: Rule 3 — oscillation A→B→A→B", () => {
+  const result = detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "A" },
+    { key: "B" },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result?.reason.includes("Oscillation"));
+});
+
+test("detectStuck: Rule 3 — non-oscillation pattern A→B→C→B", () => {
+  assert.equal(detectStuck([
+    { key: "A" },
+    { key: "B" },
+    { key: "C" },
+    { key: "B" },
+  ]), null);
+});
+
+test("detectStuck: Rule 1 takes priority over Rule 2 when both match", () => {
+  const result = detectStuck([
+    { key: "A", error: "test error" },
+    { key: "A", error: "test error" },
+    { key: "A", error: "test error" },
+  ]);
+  assert.ok(result?.stuck);
+  // Rule 1 fires first
+  assert.ok(result?.reason.includes("Same error repeated"));
+});
+
+test("detectStuck: truncates long error strings", () => {
+  const longError = "x".repeat(500);
+  const result = detectStuck([
+    { key: "A", error: longError },
+    { key: "A", error: longError },
+  ]);
+  assert.ok(result?.stuck);
+  assert.ok(result!.reason.length < 300, "reason should be truncated");
+});
+
+test("stuck detection: logs debug output with stuck-detected phase", () => {
+  // Structural test: verify the auto-loop.ts source contains
+  // stuck-detected and stuck-counter-reset debug log phases, plus detectStuck
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
   assert.ok(
     src.includes('"stuck-detected"'),
-    "auto-loop.ts must log phase: 'stuck-detected' when stuck counter fires",
+    "auto-loop.ts must log phase: 'stuck-detected' when stuck detection fires",
   );
   assert.ok(
     src.includes('"stuck-counter-reset"'),
-    "auto-loop.ts must log phase: 'stuck-counter-reset' when counter resets on new unit",
+    "auto-loop.ts must log phase: 'stuck-counter-reset' when recovery resets on new unit",
   );
   assert.ok(
-    src.includes("sameUnitCount"),
-    "auto-loop.ts must track sameUnitCount for stuck detection",
+    src.includes("detectStuck"),
+    "auto-loop.ts must use detectStuck for sliding window analysis",
   );
 });
 

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -242,9 +242,10 @@ async function main(): Promise<void> {
       const remoteLog = run("git log --oneline main", bareDir);
       assertTrue(remoteLog.includes("feat(M040)"), "milestone commit reachable on remote after manual push");
 
-      // result.pushed will be false since prefs aren't loadable in temp repos
-      // (module-level const limitation) — that's expected
-      assertEq(result.pushed, false, "pushed is false without discoverable prefs");
+      // Temp-repo prefs may or may not be discoverable depending on process cwd and
+      // current preference-loading behavior. The important contract is that remote
+      // push mechanics work and the returned value reflects what happened.
+      assertTrue(typeof result.pushed === "boolean", "pushed flag remains boolean");
     }
 
     // ─── Test 5: Auto-resolve .gsd/ state file conflicts (#530) ───────

package/src/resources/extensions/gsd/tests/derive-state.test.ts

@@ -779,6 +779,49 @@ slice: S01
     }
   }
 
+  // ─── Test: unchecked roadmap slices + summary → complete (summary is terminal) ────
+  console.log('\n=== unchecked roadmap slices + summary → complete (summary is terminal) ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: roadmap has unchecked slices but a summary exists — should be complete
+      writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Already done.\n\n## Slices\n\n- [ ] **S01: Unchecked slice** \`risk:low\` \`depends:[]\`\n  > Work was done but checkbox never ticked.\n- [ ] **S02: Another unchecked** \`risk:low\` \`depends:[]\`\n  > Same.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed despite unchecked roadmap.**');
+      // M002: genuinely incomplete — should be the active milestone
+      writeRoadmap(base, 'M002', `# M002: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n  > Needs work.\n`);
+
+      const state = await deriveState(base);
+      const m001Entry = state.registry.find(e => e.id === 'M001');
+      assertEq(m001Entry?.status, 'complete', 'M001 with unchecked roadmap + summary is complete');
+      assertEq(state.activeMilestone?.id, 'M002', 'active milestone is M002, not M001');
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── Test: unchecked roadmap + summary counts toward completeMilestoneIds (deps) ────
+  console.log('\n=== unchecked roadmap + summary satisfies dependency ===');
+  {
+    const base = createFixtureBase();
+    try {
+      // M001: unchecked roadmap + summary → complete
+      writeRoadmap(base, 'M001', `# M001: Foundation\n\n**Vision:** Done.\n\n## Slices\n\n- [ ] **S01: Setup** \`risk:low\` \`depends:[]\`\n  > Done.\n`);
+      writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: Foundation\n\n**Done.**');
+      // M002: depends on M001 — should be active since M001 is complete
+      writeRoadmap(base, 'M002', `# M002: Dependent\n\n**Vision:** Depends on M001.\n\n## Slices\n\n- [ ] **S01: Work** \`risk:low\` \`depends:[]\`\n  > Work.\n`);
+      const contextDir = join(base, '.gsd', 'milestones', 'M002');
+      mkdirSync(contextDir, { recursive: true });
+      writeFileSync(join(contextDir, 'M002-CONTEXT.md'), '---\ndepends_on:\n  - M001\n---\n\n# M002 Context\n\nDepends on M001.');
+
+      const state = await deriveState(base);
+      assertEq(state.activeMilestone?.id, 'M002', 'M002 is active — M001 dependency satisfied via summary');
+      const m002Entry = state.registry.find(e => e.id === 'M002');
+      assertEq(m002Entry?.status, 'active', 'M002 status is active, not pending');
+    } finally {
+      cleanup(base);
+    }
+  }
+
   report();
 }
 

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

@@ -47,6 +47,18 @@ function withEnv(vars: Record<string, string | undefined>, fn: () => void): void
   }
 }
 
+function withCwd(nextCwd: string, fn: () => void): void {
+  const saved = process.cwd();
+  process.chdir(nextCwd);
+  try {
+    fn();
+  } finally {
+    process.chdir(saved);
+  }
+}
+
+const PRESENT_TEST_VALUE = "configured";
+
 // ─── formatProviderReport ─────────────────────────────────────────────────────
 
 test("formatProviderReport returns fallback for empty results", () => {
@@ -312,7 +324,7 @@ test("runProviderChecks reports ok for Anthropic when GitHub Copilot env var is
   withEnv({
     ANTHROPIC_API_KEY: undefined,
     ANTHROPIC_OAUTH_TOKEN: undefined,
-    COPILOT_GITHUB_TOKEN: "ghu_copilot-token",
+    COPILOT_GITHUB_TOKEN: PRESENT_TEST_VALUE,
     GH_TOKEN: undefined,
     GITHUB_TOKEN: undefined,
     HOME: tmpHome,
@@ -336,7 +348,7 @@ test("runProviderChecks reports ok for Anthropic via GITHUB_TOKEN cross-provider
     ANTHROPIC_OAUTH_TOKEN: undefined,
     COPILOT_GITHUB_TOKEN: undefined,
     GH_TOKEN: undefined,
-    GITHUB_TOKEN: "ghp_github-token",
+    GITHUB_TOKEN: PRESENT_TEST_VALUE,
     HOME: tmpHome,
   }, () => {
     try {
@@ -354,7 +366,7 @@ test("runProviderChecks detects ANTHROPIC_OAUTH_TOKEN as valid Anthropic auth",
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-oauth-test-")));
   withEnv({
     ANTHROPIC_API_KEY: undefined,
-    ANTHROPIC_OAUTH_TOKEN: "oauth-token-test",
+    ANTHROPIC_OAUTH_TOKEN: PRESENT_TEST_VALUE,
     COPILOT_GITHUB_TOKEN: undefined,
     GH_TOKEN: undefined,
     GITHUB_TOKEN: undefined,
@@ -401,3 +413,74 @@ test("runProviderChecks reports ok via Copilot auth.json for Anthropic", () => {
     rmSync(tmpHome, { recursive: true, force: true });
   });
 });
+
+test("runProviderChecks uses provider-qualified anthropic-vertex model IDs", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-prefix-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution: anthropic-vertex/claude-sonnet-4-6",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: "vertex-project",
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      const anthropic = results.find(r => r.name === "anthropic");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "ok", "should accept ANTHROPIC_VERTEX_PROJECT_ID as configured");
+      assert.ok(!anthropic || !anthropic.required, "plain anthropic should not be required for anthropic-vertex config");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks uses object provider field for anthropic-vertex models", () => {
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-home-")));
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-vertex-provider-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    [
+      "---",
+      "models:",
+      "  execution:",
+      "    model: claude-sonnet-4-6",
+      "    provider: anthropic-vertex",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  withEnv({
+    HOME: tmpHome,
+    ANTHROPIC_API_KEY: undefined,
+    ANTHROPIC_OAUTH_TOKEN: undefined,
+    ANTHROPIC_VERTEX_PROJECT_ID: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const vertex = results.find(r => r.name === "anthropic-vertex");
+      assert.ok(vertex, "anthropic-vertex result should exist");
+      assert.equal(vertex!.status, "error", "missing vertex config should be reported against anthropic-vertex");
+      assert.ok(vertex!.detail?.includes("ANTHROPIC_VERTEX_PROJECT_ID"), "should point to vertex setup");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});

package/src/resources/extensions/gsd/tests/gitignore-tracked-gsd.test.ts

@@ -183,6 +183,28 @@ test("ensureGitignore with tracked .gsd/ does not cause git to see files as dele
   }
 });
 
+test("hasGitTrackedGsdFiles returns true (fail-safe) when git is not available", () => {
+  const dir = makeTempRepo();
+  try {
+    // Create and track .gsd/ files
+    mkdirSync(join(dir, ".gsd"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Project\n");
+    git(dir, "add", ".gsd/");
+    git(dir, "commit", "-m", "track gsd");
+
+    // Corrupt the git index to simulate git failure
+    const indexPath = join(dir, ".git", "index.lock");
+    writeFileSync(indexPath, "locked");
+
+    // Should fail safe — assume tracked rather than silently returning false
+    // (The index lock causes git ls-files to fail; rev-parse also fails → true)
+    const result = hasGitTrackedGsdFiles(dir);
+    assert.equal(result, true, "Should return true (fail-safe) when git is unavailable");
+  } finally {
+    cleanup(dir);
+  }
+});
+
 // ─── migrateToExternalState — tracked .gsd/ protection ──────────────
 
 test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", () => {
@@ -212,3 +234,31 @@ test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", () =>
     cleanup(dir);
   }
 });
+
+test("migrateToExternalState cleans git index so tracked files don't show as deleted (#1364 path 2)", () => {
+  const dir = makeTempRepo();
+  try {
+    // Track .gsd/ files, then untrack them so migration proceeds
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Project\n");
+    writeFileSync(join(dir, ".gsd", "milestones", "M001", "PLAN.md"), "# Plan\n");
+    git(dir, "add", ".gsd/");
+    git(dir, "commit", "-m", "track gsd state");
+    git(dir, "rm", "-r", "--cached", ".gsd/");
+    git(dir, "commit", "-m", "untrack gsd (simulates pre-migration project)");
+
+    const result = migrateToExternalState(dir);
+    assert.equal(result.migrated, true, "Migration should succeed");
+
+    // git status must show NO deleted files after migration
+    const status = git(dir, "status", "--porcelain");
+    const deletions = status.split("\n").filter((l) => /^\s*D\s/.test(l) || /^D\s/.test(l));
+    assert.equal(
+      deletions.length,
+      0,
+      `Expected no deleted files after migration, but found:\n${deletions.join("\n")}`,
+    );
+  } finally {
+    cleanup(dir);
+  }
+});