gsd-pi 2.73.1 → 2.74.0-dev.2b524c3

package/src/resources/extensions/gsd/tests/auto-post-unit-step-message.test.ts

@@ -0,0 +1,53 @@
+// GSD-2 — Tests for step-mode completion messages in auto-post-unit
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildStepCompleteMessage, STEP_COMPLETE_FALLBACK_MESSAGE } from "../auto-post-unit.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(overrides: Partial<GSDState>): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+test("buildStepCompleteMessage: milestone complete surfaces review guidance", () => {
+  const msg = buildStepCompleteMessage(makeState({ phase: "complete" }));
+  assert.match(msg, /milestone finished/);
+  assert.match(msg, /\/gsd status/);
+  assert.doesNotMatch(msg, /Next:/);
+});
+
+test("buildStepCompleteMessage: mid-flight step includes next unit label and /clear hint", () => {
+  const state = makeState({
+    phase: "executing",
+    activeSlice: { id: "S01", title: "Core" },
+    activeTask: { id: "T03", title: "Wire notify" },
+  });
+  const msg = buildStepCompleteMessage(state);
+  assert.match(msg, /Next: Execute T03: Wire notify/);
+  assert.match(msg, /\/clear/);
+  assert.match(msg, /\/gsd to continue/);
+});
+
+test("buildStepCompleteMessage: unknown phase falls back to generic continue label", () => {
+  // Cast to bypass Phase union so we exercise the default branch of describeNextUnit.
+  const state = makeState({ phase: "totally-unknown" as unknown as GSDState["phase"] });
+  const msg = buildStepCompleteMessage(state);
+  assert.match(msg, /Next: Continue/);
+  assert.match(msg, /\/clear/);
+});
+
+test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points users at /clear + /gsd", () => {
+  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/clear/);
+  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd/);
+});

package/src/resources/extensions/gsd/tests/auto-start-model-capture.test.ts

@@ -33,8 +33,12 @@ test("bootstrapAutoSession checks manual session override before preferences", (
   assert.ok(manualIdx > -1, "auto-start.ts should read session model override first");
 
   // resolveDefaultSessionModel() should still be called for fallback behavior
-  const preferredIdx = source.indexOf("const preferredModel = resolveDefaultSessionModel(");
-  assert.ok(preferredIdx > -1, "auto-start.ts should call resolveDefaultSessionModel()");
+  const preferredIdx = source.indexOf("const preferredModel = ");
+  assert.ok(preferredIdx > -1, "auto-start.ts should build preferredModel");
+  assert.ok(
+    source.indexOf("resolveDefaultSessionModel(") > -1,
+    "auto-start.ts should call resolveDefaultSessionModel()",
+  );
 
   // Session provider should be passed for bare model ID resolution
   const withProviderIdx = source.indexOf("resolveDefaultSessionModel(ctx.model?.provider)");
@@ -47,6 +51,51 @@ test("bootstrapAutoSession checks manual session override before preferences", (
     manualIdx < snapshotIdx && preferredIdx < snapshotIdx,
     "manual override and preference fallback must be resolved before building startModelSnapshot",
   );
+
+  // The validated preferred model must still appear as one of the snapshot
+  // sources so PREFERENCES.md continues to win over a stale settings.json
+  // default for built-in providers.
+  const snapshotBlock = source.slice(snapshotIdx, snapshotIdx + 400);
+  assert.ok(
+    snapshotBlock.includes("validatedPreferredModel") || snapshotBlock.includes("preferredModel"),
+    "startModelSnapshot must still consider preferredModel for built-in providers",
+  );
+});
+
+test("bootstrapAutoSession prefers session model over PREFERENCES.md when provider is custom (#4122)", () => {
+  // Custom providers (Ollama, vLLM, OpenAI-compatible proxies) live in
+  // ~/.gsd/agent/models.json, not PREFERENCES.md.  When the user picks one
+  // via /gsd model, that selection must win over any preferredModel from
+  // PREFERENCES.md, otherwise auto-mode tries to start a built-in provider
+  // the user is not logged into and pauses with "Not logged in".
+  const customCheckIdx = source.indexOf("isCustomProvider(ctx.model?.provider)");
+  assert.ok(
+    customCheckIdx > -1,
+    "auto-start.ts should call isCustomProvider() to detect custom-model sessions",
+  );
+
+  // sessionProviderIsCustom must gate preferredModel resolution so that when the
+  // session provider is custom, preferredModel is null and PREFERENCES.md is
+  // skipped entirely — the snapshot then falls through to ctx.model.
+  const gateIdx = source.indexOf("sessionProviderIsCustom");
+  assert.ok(gateIdx > -1, "auto-start.ts should bind sessionProviderIsCustom");
+
+  const preferredIdx = source.indexOf("const preferredModel = ");
+  assert.ok(preferredIdx > -1, "auto-start.ts should build preferredModel");
+
+  const preferredBlock = source.slice(preferredIdx, preferredIdx + 200);
+  assert.ok(
+    preferredBlock.includes("sessionProviderIsCustom"),
+    "preferredModel must be gated on sessionProviderIsCustom so PREFERENCES.md is skipped for custom providers",
+  );
+
+  const snapshotIdx = source.indexOf("const startModelSnapshot = ");
+  assert.ok(snapshotIdx > -1, "auto-start.ts should build startModelSnapshot");
+
+  assert.ok(
+    customCheckIdx < preferredIdx && preferredIdx < snapshotIdx,
+    "isCustomProvider() must be evaluated before preferredModel, which must be resolved before startModelSnapshot",
+  );
 });
 
 test("bootstrapAutoSession validates preferred model against live registry auth (#unconfigured-models)", () => {

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

@@ -0,0 +1,142 @@
+/**
+ * complete-milestone-false-merge.test.ts — Regression test for #4175.
+ *
+ * Before the fix, a failed complete-milestone unit could leave a stub
+ * SUMMARY blocker placeholder on disk. stopAuto's SUMMARY-presence check
+ * then treated the milestone as complete and merged the worktree branch
+ * into main — emitting a misleading metadata-only merge warning for a
+ * milestone that was never legitimately finished.
+ *
+ * The fix has three cooperating parts:
+ *   1. stopAuto uses DB status (authoritative) instead of SUMMARY presence
+ *      when the project DB is available.
+ *   2. postUnitPreVerification pauses auto-mode for complete-milestone
+ *      after retries are exhausted instead of writing a blocker placeholder.
+ *   3. recoverTimedOutUnit pauses for complete-milestone instead of
+ *      writing a blocker placeholder.
+ *
+ * This test guards all three via source inspection so a future refactor
+ * cannot silently reintroduce the false-merge path.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const gsdDir = join(import.meta.dirname, "..");
+const autoSrc = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
+const postUnitSrc = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
+const timeoutSrc = readFileSync(join(gsdDir, "auto-timeout-recovery.ts"), "utf-8");
+
+test("#4175: stopAuto uses DB status as the authoritative milestone-complete signal", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  assert.ok(
+    step4Block.includes("isDbAvailable()"),
+    "Step 4 should branch on isDbAvailable() so DB is consulted when present",
+  );
+  assert.ok(
+    step4Block.includes("getMilestone(s.currentMilestoneId)"),
+    "Step 4 should read authoritative milestone status via getMilestone()",
+  );
+  assert.ok(
+    /status\s*===\s*"complete"/.test(step4Block),
+    'Step 4 should compare the DB row status to "complete"',
+  );
+});
+
+test("#4175: stopAuto imports getMilestone from gsd-db", () => {
+  assert.ok(
+    /import\s*\{[^}]*\bgetMilestone\b[^}]*\}\s*from\s*"\.\/gsd-db\.js"/.test(autoSrc),
+    "auto.ts should import getMilestone from ./gsd-db.js",
+  );
+});
+
+test("#4175: stopAuto still falls back to SUMMARY presence when DB is unavailable", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  assert.ok(
+    step4Block.includes("resolveMilestoneFile"),
+    "Step 4 should keep SUMMARY-file resolution for DB-unavailable projects",
+  );
+  assert.ok(
+    step4Block.includes("preserveBranch"),
+    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+  );
+});
+
+test("#4175: postUnitPreVerification pauses complete-milestone after retries exhausted", () => {
+  // The pause branch must live inside the retries-exhausted block, above the
+  // writeBlockerPlaceholder call — otherwise the stub SUMMARY is still written.
+  const retriesExhaustedIdx = postUnitSrc.indexOf(
+    "if (attempt > MAX_VERIFICATION_RETRIES)",
+  );
+  assert.ok(
+    retriesExhaustedIdx !== -1,
+    "retries-exhausted guard exists in postUnitPreVerification",
+  );
+
+  const blockerCallIdx = postUnitSrc.indexOf("writeBlockerPlaceholder", retriesExhaustedIdx);
+  assert.ok(
+    blockerCallIdx !== -1,
+    "blocker placeholder call still exists for non-milestone units",
+  );
+
+  const exhaustedBlock = postUnitSrc.slice(retriesExhaustedIdx, blockerCallIdx);
+
+  assert.ok(
+    /s\.currentUnit\.type\s*===\s*"complete-milestone"/.test(exhaustedBlock),
+    "retries-exhausted block should specifically handle complete-milestone",
+  );
+  assert.ok(
+    /pauseAuto\s*\(\s*ctx\s*,\s*pi\s*\)/.test(exhaustedBlock),
+    "complete-milestone path should call pauseAuto instead of falling through",
+  );
+  // The pause branch must return so execution never reaches writeBlockerPlaceholder.
+  assert.ok(
+    /return\s+"dispatched"\s*;/.test(exhaustedBlock),
+    "complete-milestone pause branch should return before the placeholder call",
+  );
+});
+
+test("#4175: recoverTimedOutUnit pauses complete-milestone instead of writing a blocker placeholder", () => {
+  // The complete-milestone pause branch must sit immediately above the
+  // "retries exhausted" writeBlockerPlaceholder call so a failed
+  // complete-milestone never produces a stub SUMMARY. Anchor on the
+  // comment that precedes that specific placeholder call rather than the
+  // function's earlier writeBlockerPlaceholder use sites or its import.
+  // Use lastIndexOf so we find the final retries-exhausted block in
+  // recoverTimedOutUnit, not an earlier helper with the same comment.
+  const exhaustedAnchor = "Retries exhausted — write a blocker placeholder";
+  const exhaustedIdx = timeoutSrc.lastIndexOf(exhaustedAnchor);
+  assert.ok(
+    exhaustedIdx !== -1,
+    "retries-exhausted blocker-placeholder path still exists for non-milestone units",
+  );
+
+  const guardIdx = timeoutSrc.lastIndexOf(
+    'unitType === "complete-milestone"',
+    exhaustedIdx,
+  );
+  assert.ok(
+    guardIdx !== -1,
+    "complete-milestone guard should appear above the retries-exhausted placeholder call",
+  );
+
+  const guardBlock = timeoutSrc.slice(guardIdx, exhaustedIdx);
+  assert.ok(
+    /return\s+"paused"\s*;/.test(guardBlock),
+    "complete-milestone guard should return 'paused' before the placeholder call",
+  );
+  // The guard itself must not call writeBlockerPlaceholder.
+  assert.ok(
+    !guardBlock.includes("writeBlockerPlaceholder"),
+    "complete-milestone guard must not write a blocker placeholder",
+  );
+});

package/src/resources/extensions/gsd/tests/completed-at-reconcile.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Regression test for #4129: tasks.completed_at stays NULL when status is
+ * reconciled to 'complete' via the file-existence path in state.ts.
+ *
+ * Root cause: reconcileSliceTasks called
+ *   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
+ * without a completedAt timestamp, so the column stays NULL.
+ *
+ * Fix: pass new Date().toISOString() as the 5th argument.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
+
+describe("completed-at reconcile (#4129)", () => {
+  test("reconcileSliceTasks passes a completedAt timestamp when setting status to complete", () => {
+    // Before the fix, state.ts had:
+    //   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
+    // which leaves completed_at NULL in the DB.
+    // After the fix, a timestamp must be passed as the 5th argument.
+    assert.doesNotMatch(
+      stateSource,
+      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*\)/,
+      "updateTaskStatus must not be called without a completedAt timestamp when reconciling tasks to 'complete' (#4129)",
+    );
+  });
+
+  test("reconcileSliceTasks passes new Date().toISOString() as the completedAt argument", () => {
+    // Positive assertion: the fixed call must include a timestamp.
+    assert.match(
+      stateSource,
+      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*,\s*new Date\(\)\.toISOString\(\)\s*\)/,
+      "reconcileSliceTasks must pass new Date().toISOString() as completedAt when setting task status to 'complete' (#4129)",
+    );
+  });
+});

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

@@ -351,8 +351,9 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'E-blocked');
-      assert.deepStrictEqual(dbState.phase, 'blocked', 'E-blocked: phase is blocked');
-      assert.ok(dbState.blockers.length > 0, 'E-blocked: has blockers');
+      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+      assert.deepStrictEqual(dbState.phase, 'planning', 'E-blocked: phase is planning (fallback picks a slice)');
+      assert.ok(dbState.activeSlice !== null, 'E-blocked: activeSlice is set via fallback');
 
       closeDatabase();
     } finally {

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

@@ -616,9 +616,10 @@ describe('derive-state-db', async () => {
       invalidateStateCache();
       const dbState = await deriveStateFromDb(base);
 
-      assert.deepStrictEqual(dbState.phase, 'blocked', 'blocked-db: phase is blocked');
+      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+      assert.deepStrictEqual(dbState.phase, 'planning', 'blocked-db: phase is planning (fallback picks a slice)');
       assert.deepStrictEqual(dbState.phase, fileState.phase, 'blocked-db: phase matches filesystem');
-      assert.ok(dbState.blockers.length > 0, 'blocked-db: has blockers');
+      assert.ok(dbState.activeSlice !== null, 'blocked-db: activeSlice is set via fallback');
 
       closeDatabase();
     } finally {

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

@@ -307,27 +307,87 @@ describe('derive-state-helpers', () => {
     }
   });
 
-  // ─── buildCompletenessSet: SUMMARY-on-disk marks complete ───────────
-  test('buildCompletenessSet: milestone with SUMMARY on disk treated as complete', async () => {
+  // ─── buildCompletenessSet: DB status is authoritative ──────────────
+  test('buildCompletenessSet: DB status=complete marks milestone complete', async () => {
     const base = createFixtureBase();
     try {
-      // M001 has summary on disk but DB status is still 'active'
       writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
       writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
-      // M002 is the real active milestone
       writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002\n\nActive.');
 
       openDatabase(':memory:');
-      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
       insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
 
       invalidateStateCache();
       const state = await deriveStateFromDb(base);
 
-      // M001 should be complete (summary on disk), M002 should be active
       const m1 = state.registry.find(e => e.id === 'M001');
-      assert.equal(m1?.status, 'complete', 'summary-disk: M001 marked complete via disk SUMMARY');
-      assert.equal(state.activeMilestone?.id, 'M002', 'summary-disk: M002 is active');
+      assert.equal(m1?.status, 'complete', 'DB status=complete → registry entry complete');
+      assert.equal(state.activeMilestone?.id, 'M002', 'M002 is the active milestone');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // ─── Regression #4179: orphan SUMMARY must NOT flip DB-active milestone ───
+  // A crashed complete-milestone turn (or stale/manual SUMMARY.md) can leave
+  // a milestone SUMMARY on disk while the DB row still reads 'active'. The
+  // read-side of state derivation must NOT treat the orphan SUMMARY as a
+  // completion signal, or the auto-loop advances and merges work that was
+  // never actually finished (same failure class as #4175, read-side twin).
+  test('buildCompletenessSet (#4179): orphan SUMMARY on disk does not mark DB-active milestone complete', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Orphan Summary\n\nLeft over from crashed turn.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      // Slice still in-flight — auto should resume, not merge.
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'active', risk: 'low', depends: [] });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'pending', risk: 'low', depends: ['S01'] });
+      insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'In-flight', status: 'pending' });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      const m1 = state.registry.find(e => e.id === 'M001');
+      assert.notEqual(m1?.status, 'complete', 'orphan SUMMARY must not mark milestone complete');
+      assert.equal(m1?.status, 'active', 'M001 remains active — DB is authoritative');
+      assert.equal(state.activeMilestone?.id, 'M001', 'M001 is still the active milestone');
+      assert.notEqual(state.phase, 'completing-milestone', 'must not short-circuit into completion');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  // Regression #4179 (companion): DB-active milestone with all slices done +
+  // validation terminal + orphan SUMMARY must still flow through completing-milestone
+  // (re-runs complete-milestone), not be reported as already-complete.
+  test('buildRegistryAndFindActive (#4179): orphan SUMMARY with validation-terminal falls through to completing-milestone', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_CONTENT);
+      writeFile(base, 'milestones/M001/M001-VALIDATION.md', '---\nverdict: passed\n---\n# Validation\nAll good.');
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Orphan Summary\n\nLeft over.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First', status: 'complete', risk: 'low', depends: [] });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second', status: 'complete', risk: 'low', depends: ['S01'] });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      const m1 = state.registry.find(e => e.id === 'M001');
+      assert.equal(m1?.status, 'active', 'M001 stays active despite orphan SUMMARY + validation-terminal');
+      assert.equal(state.activeMilestone?.id, 'M001', 'M001 is still the active milestone');
+      assert.equal(state.phase, 'completing-milestone', 'phase flows through completing-milestone (re-run)');
     } finally {
       closeDatabase();
       cleanup(base);

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

@@ -446,9 +446,9 @@ Continue from step 2.
 
       const state2 = await deriveState(base2);
 
-      assert.deepStrictEqual(state2.phase, 'blocked', 'blocked-B: phase is blocked');
-      assert.deepStrictEqual(state2.activeSlice, null, 'blocked-B: activeSlice is null');
-      assert.ok(state2.blockers.length > 0, 'blocked-B: blockers array is non-empty');
+      // With partial-dep fallback, S01 is picked despite unmet dep on S99
+      assert.deepStrictEqual(state2.phase, 'planning', 'blocked-B: phase is planning (fallback picks S01)');
+      assert.deepStrictEqual(state2.activeSlice?.id, 'S01', 'blocked-B: activeSlice is S01 via fallback');
     } finally {
       cleanup(base2);
     }

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -6,7 +6,7 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -48,3 +48,139 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(result, undefined, "Should not create routing config for copilot");
   });
 });
+
+describe("flat-rate provider extensibility (any/all/custom)", () => {
+  test("regression: built-in providers still flat-rate with no context", () => {
+    assert.equal(isFlatRateProvider("github-copilot"), true);
+    assert.equal(isFlatRateProvider("copilot"), true);
+    assert.equal(isFlatRateProvider("claude-code"), true);
+  });
+
+  test("regression: non-flat-rate API providers return false with no context", () => {
+    assert.equal(isFlatRateProvider("anthropic"), false);
+    assert.equal(isFlatRateProvider("openai"), false);
+    assert.equal(isFlatRateProvider("google-vertex"), false);
+  });
+
+  test("auto-detection: externalCli auth mode marks provider flat-rate", () => {
+    // Any provider registered with authMode: "externalCli" is a local
+    // CLI wrapper around the user's subscription — every request costs
+    // the same regardless of model, so dynamic routing provides no benefit.
+    assert.equal(
+      isFlatRateProvider("my-private-cli", { authMode: "externalCli" }),
+      true,
+    );
+  });
+
+  test("auto-detection: non-externalCli auth modes do not mark provider flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "apiKey" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "oauth" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "none" }),
+      false,
+    );
+  });
+
+  test("user preference: custom provider listed in userFlatRate is flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-ollama-proxy", { userFlatRate: ["my-ollama-proxy"] }),
+      true,
+    );
+  });
+
+  test("user preference: case-insensitive match against userFlatRate list", () => {
+    assert.equal(
+      isFlatRateProvider("My-Proxy", { userFlatRate: ["my-proxy"] }),
+      true,
+    );
+    assert.equal(
+      isFlatRateProvider("my-proxy", { userFlatRate: ["MY-PROXY"] }),
+      true,
+    );
+  });
+
+  test("user preference: provider not in userFlatRate list is not flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("other-proxy", { userFlatRate: ["my-proxy"] }),
+      false,
+    );
+  });
+
+  test("combined signals: built-in list wins even when context is empty", () => {
+    assert.equal(
+      isFlatRateProvider("claude-code", { authMode: "apiKey", userFlatRate: [] }),
+      true,
+    );
+  });
+
+  test("combined signals: externalCli auto-detection wins alongside userFlatRate miss", () => {
+    assert.equal(
+      isFlatRateProvider("my-cli", {
+        authMode: "externalCli",
+        userFlatRate: ["a-different-cli"],
+      }),
+      true,
+    );
+  });
+});
+
+describe("buildFlatRateContext()", () => {
+  test("builds a context from ctx.modelRegistry.getProviderAuthMode + prefs", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: (p: string) =>
+          p === "my-cli" ? "externalCli" : "apiKey",
+      },
+    };
+    const prefs = { flat_rate_providers: ["my-proxy"] };
+
+    const ctxForCli = buildFlatRateContext("my-cli", ctx, prefs);
+    assert.equal(ctxForCli.authMode, "externalCli");
+    assert.deepEqual(ctxForCli.userFlatRate, ["my-proxy"]);
+    assert.equal(isFlatRateProvider("my-cli", ctxForCli), true);
+
+    const ctxForProxy = buildFlatRateContext("my-proxy", ctx, prefs);
+    assert.equal(ctxForProxy.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("my-proxy", ctxForProxy), true);
+
+    const ctxForOther = buildFlatRateContext("anthropic", ctx, prefs);
+    assert.equal(ctxForOther.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("anthropic", ctxForOther), false);
+  });
+
+  test("survives missing ctx and missing prefs", () => {
+    const empty = buildFlatRateContext("anything");
+    assert.equal(empty.authMode, undefined);
+    assert.equal(empty.userFlatRate, undefined);
+    assert.equal(isFlatRateProvider("anything", empty), false);
+  });
+
+  test("survives a registry lookup that throws", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => {
+          throw new Error("registry boom");
+        },
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    // Error must be swallowed — authMode left undefined, function returns.
+    assert.equal(result.authMode, undefined);
+  });
+
+  test("registry returning a non-canonical auth mode is ignored", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => "weird-mode",
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    assert.equal(result.authMode, undefined);
+  });
+});

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -691,7 +691,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → blocked phase", async () => {
+  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,7 +736,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    assert.equal(state.phase, "blocked", "circular deps should produce blocked phase");
+    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
+    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
   });
 });