@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -0,0 +1,71 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for premature auto-mode closeout chat rewrites.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  rewritePrematureCloseoutLine,
+  rewritePrematureCloseoutText,
+  sanitizePrematureCloseoutMessageEnd,
+} from "../auto-closeout-messaging.ts";
+
+test("rewritePrematureCloseoutLine rewrites milestone complete to closeout submitted", () => {
+  assert.equal(
+    rewritePrematureCloseoutLine("Milestone M005 complete."),
+    "Milestone M005 closeout submitted.",
+  );
+  assert.equal(
+    rewritePrematureCloseoutLine("  Milestone M005 complete  "),
+    "Milestone M005 closeout submitted.",
+  );
+});
+
+test("rewritePrematureCloseoutLine rewrites slice, task, uat, quick-task, and triage lines", () => {
+  assert.equal(rewritePrematureCloseoutLine("Slice S01 complete."), "Slice S01 closeout submitted.");
+  assert.equal(rewritePrematureCloseoutLine("Task T03 complete."), "Task T03 closeout submitted.");
+  assert.equal(rewritePrematureCloseoutLine("UAT S02 complete."), "UAT S02 results submitted.");
+  assert.equal(rewritePrematureCloseoutLine("Quick task 4 complete."), "Quick task 4 closeout submitted.");
+  assert.equal(rewritePrematureCloseoutLine("Triage complete."), "Triage closeout submitted.");
+});
+
+test("rewritePrematureCloseoutText leaves unrelated prose unchanged", () => {
+  const input = [
+    "Verification summary:",
+    "- tests passed",
+    "Milestone M005 complete.",
+    "No further work needed.",
+  ].join("\n");
+  const output = rewritePrematureCloseoutText(input);
+  assert.match(output, /Milestone M005 closeout submitted\./);
+  assert.match(output, /Verification summary:/);
+  assert.doesNotMatch(output, /Milestone M005 complete\./);
+});
+
+test("sanitizePrematureCloseoutMessageEnd rewrites assistant text blocks in place", () => {
+  const event = {
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "Milestone M005 complete." }],
+    },
+  };
+  sanitizePrematureCloseoutMessageEnd(event);
+  assert.equal(
+    (event.message.content[0] as { text: string }).text,
+    "Milestone M005 closeout submitted.",
+  );
+});
+
+test("sanitizePrematureCloseoutMessageEnd ignores non-assistant messages", () => {
+  const event = {
+    message: {
+      role: "user",
+      content: [{ type: "text", text: "Milestone M005 complete." }],
+    },
+  };
+  sanitizePrematureCloseoutMessageEnd(event);
+  assert.equal(
+    (event.message.content[0] as { text: string }).text,
+    "Milestone M005 complete.",
+  );
+});

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

@@ -40,6 +40,12 @@ import {
   recordAutoToolSurfaceSnapshot,
 } from "../auto-runtime-state.ts";
 import { formatRtkSavingsLabel } from "../../shared/rtk-session-stats.ts";
+import {
+  createProgressStripUiMock,
+  renderProgressStrip,
+  renderProgressStripLines,
+  assertLinesFit,
+} from "./progress-strip-test-helpers.ts";
 import {
   openDatabase,
   closeDatabase,
@@ -63,15 +69,6 @@ function cleanup(dir: string): void {
   }
 }
 
-function assertLinesFit(lines: string[], width: number): void {
-  for (const line of lines) {
-    assert.ok(
-      visibleWidth(line) <= width,
-      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
-    );
-  }
-}
-
 type RenderableWidget = { render(width: number): string[]; invalidate(): void; dispose?: () => void };
 
 // ─── unitVerb ─────────────────────────────────────────────────────────────
@@ -316,13 +313,15 @@ test("setAutoOutcomeWidget renders a durable next-action handoff", () => {
     { fg: (_color: string, text: string) => text, bold: (text: string) => text },
   );
   const output = component.render(100).join("\n");
+  assert.match(output, /^GSD · /m);
   assert.match(output, /Auto-mode paused/);
   assert.match(output, /Paused by user request/);
   assert.match(output, /researching M005\/S01/);
   assert.match(output, /\/gsd auto/);
+  assert.doesNotMatch(output, /^───/m);
 });
 
-test("setCompletionProgressWidget keeps terminal all-complete handoff in progress slot", () => {
+test("setCompletionProgressWidget keeps terminal all-complete handoff in outcome slot", () => {
   const calls: Array<[string, unknown]> = [];
   setCompletionProgressWidget(
     {
@@ -357,13 +356,13 @@ test("setCompletionProgressWidget keeps terminal all-complete handoff in progres
   );
 
   assert.ok(
-    calls.some(([key, value]) => key === "gsd-outcome" && value === undefined),
-    "terminal completion should clear stale outcome widgets before rendering progress roll-up",
+    calls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+    "terminal completion should clear the legacy progress widget slot",
   );
-  const progress = calls.filter(([key]) => key === "gsd-progress").at(-1);
-  assert.equal(typeof progress?.[1], "function", "terminal completion must install the final handoff in the progress slot");
+  const outcome = calls.filter(([key]) => key === "gsd-outcome").at(-1);
+  assert.equal(typeof outcome?.[1], "function", "terminal completion must install the final handoff in the outcome slot");
 
-  const component = (progress?.[1] as any)(
+  const component = (outcome?.[1] as any)(
     { requestRender() {} },
     { fg: (_color: string, text: string) => text, bold: (text: string) => text },
   );
@@ -408,17 +407,11 @@ test("buildPhaseHandoffOutcome ignores non-assistant trailing messages", () => {
 });
 
 test("updateProgressWidget preserves the phase handoff during session switching", () => {
-  const calls: Array<[string, unknown]> = [];
+  const mock = createProgressStripUiMock();
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setWidget(key: string, factory: unknown) {
-          calls.push([key, factory]);
-        },
-        setHeader() {},
-        setStatus() {},
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M005/S01/T01",
@@ -438,25 +431,28 @@ test("updateProgressWidget preserves the phase handoff during session switching"
     },
   );
 
-  assert.ok(calls.some(([key]) => key === "gsd-progress"));
+  assert.equal(
+    mock.getProgressState(),
+    undefined,
+    "progress strip should not publish while session switching is active",
+  );
   assert.ok(
-    !calls.some(([key, value]) => key === "gsd-outcome" && value === undefined),
+    mock.widgetCalls.some(([key, value]) => key === "gsd-progress" && value === undefined),
+    "stale gsd-progress widget slot should still be cleared",
+  );
+  assert.ok(
+    !mock.widgetCalls.some(([key, value]) => key === "gsd-outcome" && value === undefined),
     "handoff widget should stay visible until the next progress frame renders",
   );
+  mock.disposeProgress();
 });
 
 test("updateProgressWidget clears the phase handoff once active progress resumes", () => {
-  const calls: Array<[string, unknown]> = [];
+  const mock = createProgressStripUiMock();
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setWidget(key: string, factory: unknown) {
-          calls.push([key, factory]);
-        },
-        setHeader() {},
-        setStatus() {},
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M005/S01/T01",
@@ -476,11 +472,12 @@ test("updateProgressWidget clears the phase handoff once active progress resumes
     },
   );
 
-  assert.ok(calls.some(([key]) => key === "gsd-progress"));
+  assert.ok(mock.getProgressState(), "progress strip state should publish once session switching ends");
   assert.ok(
-    calls.some(([key, value]) => key === "gsd-outcome" && value === undefined),
+    mock.widgetCalls.some(([key, value]) => key === "gsd-outcome" && value === undefined),
     "handoff widget should clear once the active dashboard can render",
   );
+  mock.disposeProgress();
 });
 
 test("shouldRenderRoadmapProgress hides pre-roadmap zero-slice progress", () => {
@@ -636,10 +633,10 @@ test("updateProgressWidget full mode keeps footer-owned signals out of auto deck
   const projectPrefsPath = join(dir, ".gsd", "preferences.md");
   const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
   writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
-  let widget: { render(width: number): string[]; dispose?: () => void } | null = null;
+  const mock = createProgressStripUiMock();
 
   t.after(() => {
-    widget?.dispose?.();
+    mock.disposeProgress();
     _resetWidgetModeForTests();
     clearSliceProgressCache();
     cleanup(dir);
@@ -651,18 +648,7 @@ test("updateProgressWidget full mode keeps footer-owned signals out of auto deck
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setHeader() {},
-        setStatus() {},
-        setWidget(_key: string, factory: any) {
-          if (_key === "gsd-progress") {
-            widget = factory(
-              { requestRender() {} },
-              { fg: (_color: string, text: string) => text, bold: (text: string) => text },
-            );
-          }
-        },
-      },
+      ui: mock.ui,
       sessionManager: { getSessionId: () => "session-1" },
     } as any,
     "execute-task",
@@ -688,15 +674,13 @@ test("updateProgressWidget full mode keeps footer-owned signals out of auto deck
     },
   );
 
-  const installedWidget = widget as { render(width: number): string[]; dispose?: () => void } | null;
-  assert.ok(installedWidget, "progress widget should be installed");
-  const rendered = installedWidget.render(120).join("\n");
+  const progress = mock.getProgressState();
+  assert.ok(progress, "progress strip state should be published");
+  const rendered = renderProgressStrip(progress!, 120);
 
-  assert.match(rendered, /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s+GSD\s+·\s+AUTO\s+·\s+running/);
-  assert.doesNotMatch(rendered.split("\n")[1] ?? "", /M004\/S01\/T01/);
-  assert.match(rendered, /Budget Tracking/);
+  assert.match(rendered, /GSD AUTO/);
   assert.match(rendered, /T01: Add repeat column via idempotent ALTER TABLE/);
-  assert.match(rendered, /dashboard/);
+  assert.match(rendered, /tools/);
   assert.doesNotMatch(rendered, /claude-sonnet-4-6/, "footer owns provider/model display");
   assert.doesNotMatch(rendered, /0\.2%|ctx|1\.0M/, "footer owns raw context meter display");
   assert.doesNotMatch(rendered, /\$/, "footer owns session cost display");
@@ -712,10 +696,10 @@ test("updateProgressWidget small mode renders the dense horizontal grid", (t) =>
   writeFileSync(projectPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
   writeFileSync(globalPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
 
-  const holder: { widget?: RenderableWidget } = {};
+  const mock = createProgressStripUiMock();
 
   t.after(() => {
-    holder.widget?.dispose?.();
+    mock.disposeProgress();
     closeDatabase();
     clearSliceProgressCache();
     _resetWidgetModeForTests();
@@ -736,18 +720,7 @@ test("updateProgressWidget small mode renders the dense horizontal grid", (t) =>
   updateProgressWidget(
     {
       hasUI: true,
-      ui: {
-        setHeader() {},
-        setStatus() {},
-        setWidget(_key: string, factory: any) {
-          if (_key === "gsd-progress") {
-            holder.widget = factory(
-              { requestRender() {} },
-              { fg: (_color: string, text: string) => text, bold: (text: string) => text },
-            );
-          }
-        },
-      },
+      ui: mock.ui,
     } as any,
     "execute-task",
     "M004/S01/T02",
@@ -768,60 +741,40 @@ test("updateProgressWidget small mode renders the dense horizontal grid", (t) =>
     },
   );
 
-  assert.ok(holder.widget, "progress widget should be installed");
-  const widget = holder.widget;
-  const lines = widget.render(120);
-  const rendered = lines.join("\n");
-
-  assert.equal(lines.length, 4, `small widget should render as rule + two dense rows + rule:\n${rendered}`);
-  assert.match(rendered, /STATUS\s+.*AUTO\s+running/);
-  assert.match(rendered, /UNIT\s+M004\/S01\/T02/);
-  assert.match(rendered, /SPEND/);
-  assert.match(rendered, /TIME/);
-  assert.match(rendered, /PHASE\s+execute-task/);
-  assert.match(rendered, /WORK\s+T02: Backfill repeat m/);
-  assert.match(rendered, /TASK\s+2\/2/);
-  assert.match(rendered, /SLICE.*1\/2/);
-  assert.doesNotMatch(rendered, /\/gsd next|\/gsd status/);
-  assert.doesNotMatch(rendered, /dashboard|esc pause/);
+  const progress = mock.getProgressState();
+  assert.ok(progress, "progress strip state should be published");
+  assert.equal(progress!.widgetMode, "small");
+  const rendered = renderProgressStrip(progress!, 120);
+
+  assert.match(rendered, /GSD AUTO/);
+  assert.match(rendered, /T02: Backfill repeat metadata/);
+  assert.match(rendered, /tasks/);
+  assert.doesNotMatch(rendered, /\/gsd next|\/gsd status|esc pause/);
 
   for (const width of [40, 80, 120]) {
-    widget.invalidate();
-    assertLinesFit(widget.render(width), width);
+    assertLinesFit(renderProgressStripLines(progress!, width, { cwd: dir }), width);
   }
 });
 
 test("updateProgressWidget shows provider-waiting state consistently for auto and next modes", (t) => {
   const dir = makeTempDir("auto-next-dashboard");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
-  const widgets: Array<{ render(width: number): string[]; dispose?: () => void }> = [];
+  const mocks: ReturnType<typeof createProgressStripUiMock>[] = [];
 
   t.after(() => {
-    for (const widget of widgets) widget.dispose?.();
+    for (const mock of mocks) mock.disposeProgress();
     _resetWidgetModeForTests();
     clearSliceProgressCache();
     cleanup(dir);
   });
 
-  function renderDashboard(stepMode: boolean): string {
-    const holder: { widget?: { render(width: number): string[]; dispose?: () => void } } = {};
+  function captureDashboard(stepMode: boolean): string {
+    const mock = createProgressStripUiMock();
+    mocks.push(mock);
     updateProgressWidget(
       {
         hasUI: true,
-        ui: {
-          setHeader() {},
-          setStatus() {},
-          setWidget(_key: string, factory: any) {
-            if (_key === "gsd-progress") {
-              const installed = factory(
-                { requestRender() {} },
-                { fg: (_color: string, text: string) => text, bold: (text: string) => text },
-              );
-              holder.widget = installed;
-              widgets.push(installed);
-            }
-          },
-        },
+        ui: mock.ui,
       } as any,
       "complete-slice",
       "M003/S01",
@@ -842,21 +795,20 @@ test("updateProgressWidget shows provider-waiting state consistently for auto an
       },
     );
 
-    assert.ok(holder.widget, "progress widget should be installed");
-    return holder.widget.render(120).join("\n");
+    const progress = mock.getProgressState();
+    assert.ok(progress, "progress strip state should be published");
+    return renderProgressStrip(progress!, 120, { cwd: dir });
   }
 
-  const autoRendered = renderDashboard(false);
-  const nextRendered = renderDashboard(true);
+  const autoRendered = captureDashboard(false);
+  const nextRendered = captureDashboard(true);
 
-  assert.match(autoRendered, /STATUS\s+.*AUTO\s+running/);
-  assert.match(nextRendered, /STATUS\s+.*NEXT\s+running/);
-  assert.doesNotMatch(autoRendered.split("\n")[1] ?? "", /completing M003\/S01/);
-  assert.doesNotMatch(nextRendered.split("\n")[1] ?? "", /completing M003\/S01/);
+  assert.match(autoRendered, /AUTO/);
+  assert.match(nextRendered, /NEXT/);
+  assert.match(autoRendered, /Completing|complete-slice/i);
+  assert.match(nextRendered, /Completing|complete-slice/i);
   assert.doesNotMatch(autoRendered, /waiting on provider.*Waiting on provider/i);
   assert.doesNotMatch(nextRendered, /waiting on provider.*Waiting on provider/i);
-  assert.match(autoRendered, /PHASE\s+complete-slice/);
-  assert.match(nextRendered, /PHASE\s+complete-slice/);
   assert.doesNotMatch(autoRendered, /Working/);
   assert.doesNotMatch(nextRendered, /Working/);
 });

package/src/resources/extensions/gsd/tests/auto-direct-dispatch-parse.test.ts

@@ -0,0 +1,33 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { parseDirectDispatchPhase } from "../auto-direct-dispatch.ts";
+
+test("parseDirectDispatchPhase accepts milestone id suffix", () => {
+  assert.deepEqual(parseDirectDispatchPhase("complete-milestone M005"), {
+    phase: "complete-milestone",
+    milestoneId: "M005",
+  });
+});
+
+test("parseDirectDispatchPhase ignores trailing punctuation on milestone id", () => {
+  assert.deepEqual(parseDirectDispatchPhase("complete-milestone M005."), {
+    phase: "complete-milestone",
+    milestoneId: "M005",
+  });
+});
+
+test("parseDirectDispatchPhase ignores extra words after milestone id", () => {
+  assert.deepEqual(parseDirectDispatchPhase("complete-milestone M005 complete"), {
+    phase: "complete-milestone",
+    milestoneId: "M005",
+  });
+});
+
+test("parseDirectDispatchPhase preserves bare phase names", () => {
+  assert.deepEqual(parseDirectDispatchPhase("plan"), { phase: "plan", milestoneId: undefined });
+  assert.deepEqual(parseDirectDispatchPhase("complete-milestone"), {
+    phase: "complete-milestone",
+    milestoneId: undefined,
+  });
+});

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

@@ -3358,6 +3358,110 @@ test("autoLoop handles dispatch skip action by continuing", async (t) => {
   );
 });
 
+test("autoLoop pauses after repeated orchestration skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return { action: "skip" as const, reason: "gate-marker-drift" as const };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  const dispatchCalls = deps.callLog.filter((c) => c === "resolveDispatch");
+  assert.equal(dispatchCalls.length, 3, "persistent orchestration skips should pause before the runaway cap");
+  assert.equal(deps.callLog.includes("pauseAuto"), true, "persistent orchestration skips should pause auto-mode");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "persistent orchestration skips should not hit the max-iteration stop");
+});
+
+test("autoLoop does not pause on repeated idempotent advance skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({
+    currentMilestoneId: "M001",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        if (advanceCalls >= 5) s.active = false;
+        return { kind: "skipped" as const, reason: "idempotent advance: unit already active" };
+      },
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+      getStatus: () => ({ phase: "running" as const, transitionCount: 1 }),
+    } satisfies AutoOrchestrationModule,
+  });
+
+  const deps = makeMockDeps();
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(advanceCalls >= 5, "loop should complete multiple idempotent skips before deactivating");
+  assert.equal(deps.callLog.includes("pauseAuto"), false, "idempotent advance skips must not trigger the consecutive-skip pause");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "idempotent advance skips must not reach the max-iteration stop");
+});
+
+test("autoLoop skip streak survives sidecar iteration without resetting", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({ currentMilestoneId: "M001" });
+  s.orchestration = {
+    start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    advance: async () => {
+      advanceCalls++;
+      if (advanceCalls === 2) {
+        // Inject a sidecar so the *next* iteration takes the sidecar path rather than
+        // calling orchestration.advance() — which must NOT reset the skip streak.
+        s.sidecarQueue.push({
+          kind: "hook" as const,
+          unitType: "run-uat",
+          unitId: "M001/S01/T01/review",
+          prompt: "review",
+        });
+      }
+      return { kind: "skipped" as const, reason: "gate-marker-drift" };
+    },
+    completeActiveUnit: async () => {},
+    retryActiveUnit: async () => {},
+    resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+    getStatus: () => ({ phase: "running" as const, transitionCount: advanceCalls }),
+  } satisfies AutoOrchestrationModule;
+
+  const deps = makeMockDeps();
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+
+  // Wait for the sidecar unit to call newSession (pi.calls grows)
+  await waitForMicrotasks(() => pi.calls.length >= 1, "sidecar unit to start");
+  resolveAgentEnd(makeEvent()); // resolve the sidecar unit
+
+  await loopPromise;
+
+  // Skip 1 (call 1) + sidecar iteration (no advance) + skip 3 (call 3, matches key) → pause.
+  // The old reset at the dispatch boundary would have zeroed the counter during the sidecar,
+  // requiring 3 more skips (calls 3,4,5) before pausing. With the fix, 3 total → call 3.
+  assert.equal(advanceCalls, 3, "skip streak must survive the sidecar iteration: pause on the 3rd total skip");
+  assert.ok(deps.callLog.includes("pauseAuto"), "persistent skips must still pause after an interleaved sidecar");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "must not hit the max-iteration stop");
+});
+
 test("autoLoop drains sidecar queue after postUnitPostVerification enqueues items", async (t) => {
   _resetPendingResolve();
 

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

@@ -1,10 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { recoverFailedMigration } from "../migrate-external.ts";
+import { externalGsdRoot } from "../repo-identity.ts";
 
 // Regression tests for #4416: `.gsd.migrating` must be healed before auto-mode
 // proceeds, including on the resume path in auto.ts (fixed at auto.ts:1325).
@@ -48,6 +49,36 @@ test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exi
   assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
 });
 
+test("recoverFailedMigration removes orphan when .gsd is an intact external-state junction", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-orphan-"));
+  const stateDir = mkdtempSync(join(tmpdir(), "gsd-migrating-state-"));
+  const previousStateDir = process.env.GSD_STATE_DIR;
+  const previousProjectId = process.env.GSD_PROJECT_ID;
+  process.env.GSD_STATE_DIR = stateDir;
+  process.env.GSD_PROJECT_ID = "recover-orphan";
+  t.after(() => {
+    if (previousStateDir === undefined) delete process.env.GSD_STATE_DIR;
+    else process.env.GSD_STATE_DIR = previousStateDir;
+    if (previousProjectId === undefined) delete process.env.GSD_PROJECT_ID;
+    else process.env.GSD_PROJECT_ID = previousProjectId;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  const externalPath = externalGsdRoot(base);
+  mkdirSync(join(externalPath, "phases"), { recursive: true });
+  writeFileSync(join(externalPath, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(externalPath, "gsd.db"), "not empty\n", "utf-8");
+  symlinkSync(externalPath, join(base, ".gsd"), "junction");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd junction must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
 test("recoverFailedMigration preserves contents of .gsd.migrating", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-migrating-contents-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/auto-model-selection-tool-poisoning.test.ts

@@ -334,9 +334,12 @@ test("genuinely-impossible (b): cross-provider routing disabled + provider misma
 
     // Set dynamic_routing.cross_provider=false via PREFERENCES so the policy
     // disables cross-provider routing.
+    // burn-max prevents the D046 balanced profile from injecting canonical
+    // anthropic models — without it, source:"explicit" forces allowCrossProvider=true
+    // and the cross-provider guard is bypassed before the test can exercise it.
     writeFileSync(
       join(env.dir, ".gsd", "PREFERENCES.md"),
-      ["---", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
+      ["---", "token_profile: burn-max", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
       "utf-8",
     );
 
@@ -434,9 +437,11 @@ test("restore baseline: setActiveTools(BASELINE) called between units before nex
 test("error carries deny reason fragment from applyModelPolicyFilter", async () => {
   const env = makeTempProject();
   try {
+    // burn-max: prevents D046 balanced default from injecting source:"explicit"
+    // which would force allowCrossProvider=true and bypass cross-provider denial.
     writeFileSync(
       join(env.dir, ".gsd", "PREFERENCES.md"),
-      ["---", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
+      ["---", "token_profile: burn-max", "dynamic_routing:", "  enabled: true", "  cross_provider: false", "  tier_models:", "    heavy: other-provider/other-model", "---"].join("\n"),
       "utf-8",
     );
 

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

@@ -26,6 +26,11 @@ test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models
       join(tempProject, ".gsd", "PREFERENCES.md"),
       [
         "---",
+        // burn-max disables profile-based model injection so the synthesis path
+        // (dynamic_routing.tier_models.heavy → primary) is exercised as intended.
+        // Without this, the D046 balanced default injects models.planning and the
+        // function returns source:"explicit" before reaching synthesis.
+        "token_profile: burn-max",
         "dynamic_routing:",
         "  enabled: true",
         "  tier_models:",
@@ -70,6 +75,8 @@ test("resolvePreferredModelConfig falls back to auto start model when heavy tier
       join(tempProject, ".gsd", "PREFERENCES.md"),
       [
         "---",
+        // burn-max: no profile model injection → synthesis path runs
+        "token_profile: burn-max",
         "dynamic_routing:",
         "  enabled: true",
         "  tier_models:",
@@ -395,6 +402,9 @@ test("selectAndApplyModel escalates dynamic routing tier when retry metadata is
     join(tempProject, ".gsd", "PREFERENCES.md"),
     [
       "---",
+      // burn-max: no profile model injection → synthesis ceiling = heavy tier
+      // → source:"synthesized" → dynamic routing escalation is active on retry
+      "token_profile: burn-max",
       "dynamic_routing:",
       "  enabled: true",
       "  hooks: false",