@opengsd/gsd-pi 1.0.2-dev.5961fbf → 1.0.2-dev.5f7864c

package/src/resources/extensions/gsd/tests/commands-usage.test.ts

@@ -8,6 +8,7 @@ import {
   scanSessionTokenTotals,
   handleUsage,
 } from "../commands-usage.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const TS = 1;
 
@@ -108,3 +109,99 @@ test("handleUsage emits JSON when --json is passed", async () => {
   assert.equal(parsed.contextUsage.tokens, 10_000);
   assert.equal(parsed.sessionTotals.input, 0);
 });
+
+test("handleUsage renders interactive usage output inside a full border", async () => {
+  let renderFn: ((width: number) => string[]) | undefined;
+  const messages: string[] = [];
+  const ctx = {
+    hasUI: true,
+    model: { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 200_000 },
+    getContextUsage: () => ({ tokens: 10_000, contextWindow: 200_000, percent: 5 }),
+    sessionManager: { getEntries: () => [] },
+    ui: {
+      custom: async (factory: any) => {
+        const theme = {
+          fg: (_color: string, text: string) => text,
+          bold: (text: string) => text,
+        };
+        const component = factory({ requestRender: () => {} }, theme, {}, () => {});
+        renderFn = component.render;
+        return true;
+      },
+      notify(message: string) {
+        messages.push(message);
+      },
+    },
+  };
+
+  await handleUsage("", ctx as any);
+
+  assert.equal(messages.length, 0, "interactive usage should use the dialog instead of notify");
+  assert.ok(renderFn, "render function should have been captured");
+  const lines = renderFn!(80);
+  assertFullOuterBorder(lines, 80);
+  assert.match(lines.join("\n"), /claude-code\/claude-sonnet-4-6/);
+});
+
+test("handleUsage keeps short-terminal usage dialog scrollable", async () => {
+  const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+  Object.defineProperty(process.stdout, "rows", { value: 10, configurable: true });
+
+  try {
+    let component: { render(width: number): string[]; handleInput(data: string): void } | undefined;
+    let closed = false;
+    const ctx = {
+      hasUI: true,
+      model: { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 200_000 },
+      getContextUsage: () => ({ tokens: 10_000, contextWindow: 200_000, percent: 5 }),
+      sessionManager: {
+        getEntries: () => sessionEntries({
+          role: "assistant",
+          usage: {
+            input: 1000,
+            output: 200,
+            cacheRead: 500,
+            cacheWrite: 100,
+            totalTokens: 1800,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0.05 },
+          },
+          content: [{ type: "toolCall", id: "tc-1", name: "read", arguments: {} }],
+          timestamp: TS,
+        }),
+      },
+      ui: {
+        custom: async (factory: any) => {
+          const theme = {
+            fg: (_color: string, text: string) => text,
+            bold: (text: string) => text,
+          };
+          component = factory({ requestRender: () => {} }, theme, {}, () => {
+            closed = true;
+          });
+          return true;
+        },
+        notify() {},
+      },
+    };
+
+    await handleUsage("", ctx as any);
+
+    assert.ok(component, "usage dialog should render via custom UI");
+    const initialLines = component.render(80);
+    assert.ok(initialLines.length <= 8, `usage dialog should fit 80% terminal height, got ${initialLines.length}`);
+
+    for (let i = 0; i < 10; i++) component.handleInput("\u001b[B");
+
+    assert.equal(closed, false, "scroll keys should not close a scrollable usage dialog");
+    assert.match(component.render(80).join("\n"), /Tool calls: 1/);
+
+    component.handleInput("x");
+    assert.equal(closed, true, "non-scroll keys should close the usage dialog");
+  } finally {
+    if (originalRowsDescriptor) {
+      Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+    } else {
+      delete (process.stdout as { rows?: number }).rows;
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/context-chart.test.ts

@@ -10,6 +10,7 @@ import type { ContextBreakdownReport } from "../commands-context.ts";
 import { buildContextChartHtml, writeContextChartHtml } from "../context-chart-html.ts";
 import { formatContextChartText, getContextChartTotals } from "../context-overlay.ts";
 import { buildContextBreakdown } from "../commands-context.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const TS = 1;
 
@@ -103,3 +104,11 @@ test("formatContextChartText includes chart sections", () => {
   assert.match(text, /Conversation/);
   assert.match(text, /█/);
 });
+
+test("formatContextChartText renders the context dialog inside a full border", () => {
+  const lines = formatContextChartText(SAMPLE_REPORT, 80).split("\n");
+  assertFullOuterBorder(lines, 80);
+  assert.match(lines[0] ?? "", /^╭─ Context Breakdown /);
+  assert.ok(lines.some((line) => line.startsWith("│")), "body rows should have side borders");
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+});

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

@@ -0,0 +1,25 @@
+/**
+ * GSD dashboard overlay dialog chrome tests.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GSDDashboardOverlay } from "../dashboard-overlay.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+test("GSDDashboardOverlay renders inside the shared full border", (t) => {
+  const overlay = new GSDDashboardOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+  t.after(() => overlay.dispose());
+
+  const lines = overlay.render(100);
+  assertFullOuterBorder(lines, 100);
+  assert.match(lines[0] ?? "", /^╭─ GSD Dashboard /);
+  assert.ok(lines.some((line) => line.startsWith("│")), "body rows should have side borders");
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
+});

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

@@ -9,7 +9,9 @@ const discussPrompt = readFileSync(promptPath, "utf-8");
 test("discuss prompt: resilient vision framing", () => {
   const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
   assert.ok(!hardenedPattern.test(discussPrompt), "prompt no longer uses exact-verbosity lock");
-  assert.ok(discussPrompt.includes('Ask: "What\'s the vision?" once'), "prompt asks for vision exactly once");
+  assert.ok(discussPrompt.includes('Ask exactly this once: "{{visionAsk}}"'), "prompt asks the injected vision opener exactly once");
+  assert.ok(discussPrompt.includes("The opener is intentionally variable"), "prompt documents variable opener voice");
   assert.ok(discussPrompt.includes("Special handling"), "prompt documents special handling");
-  assert.ok(discussPrompt.includes('instead of repeating "What\'s the vision?"'), "prompt forbids repeating");
+  assert.ok(discussPrompt.includes("instead of repeating the opener"), "prompt forbids repeating the opener");
+  assert.ok(!discussPrompt.includes('"What\'s the vision?"'), "prompt no longer freezes the old opener");
 });

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

@@ -702,6 +702,48 @@ test("runProviderChecks reports ok for claude-code without any API key", () => {
   rmSync(tmpHome, { recursive: true, force: true });
 });
 
+test("runProviderChecks reports errors for required Google CLI providers missing from PATH", () => {
+  const scenarios = [
+    { provider: "google-gemini-cli", label: "Google Gemini CLI", model: "gemini-2.5-pro" },
+    { provider: "google-antigravity", label: "Antigravity", model: "default" },
+  ];
+
+  for (const { provider, label, model } of scenarios) {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${provider}-repo-`)));
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  execution:",
+        `    model: ${model}`,
+        `    provider: ${provider}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${provider}-home-`)));
+
+    withEnv({
+      HOME: tmpHome,
+      PATH: tmpHome,
+    }, () => {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const cli = results.find(r => r.name === provider);
+        assert.ok(cli, `${provider} result should exist`);
+        assert.equal(cli!.status, "error", `${provider} should error when the CLI binary is missing`);
+        assert.ok(cli!.detail?.includes(label), "should explain which CLI must be installed");
+      });
+    });
+
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+});
+
 test("runProviderChecks reports ok for Anthropic via claude-code binary in PATH", () => {
   // Simulate a user who has no Anthropic API key but has the claude CLI installed.
   // Their PREFERENCES use a claude model without an explicit provider, so the doctor
@@ -736,6 +778,69 @@ test("runProviderChecks reports ok for Anthropic via claude-code binary in PATH"
   });
 });
 
+test("runProviderChecks ignores external CLI auth sentinels when the CLI is missing", () => {
+  const scenarios = [
+    {
+      requiredProvider: "anthropic",
+      routeProvider: "claude-code",
+      model: "claude-sonnet-4-6",
+      env: {
+        ANTHROPIC_API_KEY: undefined,
+        ANTHROPIC_OAUTH_TOKEN: undefined,
+        COPILOT_GITHUB_TOKEN: undefined,
+        GH_TOKEN: undefined,
+        GITHUB_TOKEN: undefined,
+      },
+    },
+    {
+      requiredProvider: "google",
+      routeProvider: "google-gemini-cli",
+      model: "gemini-2.5-pro",
+      env: {
+        GEMINI_API_KEY: undefined,
+        GOOGLE_API_KEY: undefined,
+      },
+    },
+  ];
+
+  for (const { requiredProvider, routeProvider, model, env } of scenarios) {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${routeProvider}-sentinel-repo-`)));
+    const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), `gsd-providers-${routeProvider}-sentinel-home-`)));
+    const agentDir = join(tmpHome, ".gsd", "agent");
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(
+      join(repo, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        `  execution: ${model}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(agentDir, "auth.json"), JSON.stringify({
+      [routeProvider]: { type: "api_key", key: "cli" },
+    }));
+
+    withEnv({
+      ...env,
+      HOME: tmpHome,
+      PATH: tmpHome,
+    }, () => {
+      withCwd(repo, () => {
+        const results = runProviderChecks();
+        const provider = results.find(r => r.name === requiredProvider);
+        assert.ok(provider, `${requiredProvider} result should exist`);
+        assert.equal(provider!.status, "error", `${routeProvider} sentinel should not satisfy ${requiredProvider}`);
+      });
+    });
+
+    rmSync(repo, { recursive: true, force: true });
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+});
+
 test("runProviderChecks detects claude.cmd in PATH on Windows (#4503)", { skip: process.platform !== "win32" }, () => {
   const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-cc-win-route-home-")));
   const binDir = join(tmpHome, "bin");

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -6,6 +6,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { VISION_ASK_VARIANTS } from "../vision-ask.ts";
 
 test("guided milestone prompt renders compact interview and context guidance", async (t) => {
   const previousGsdHome = process.env.GSD_HOME;
@@ -31,6 +32,11 @@ test("guided milestone prompt renders compact interview and context guidance", a
 
   assert.match(prompt, /M001 context written/);
   assert.match(prompt, /Project Shape/);
+  assert.ok(
+    VISION_ASK_VARIANTS.some((opener) => prompt.includes(opener)),
+    "prompt should render a conversational opener variant",
+  );
+  assert.doesNotMatch(prompt, /\{\{visionAsk\}\}/);
   assert.match(prompt, /default to `complex`/i);
   assert.match(prompt, /3 or 4 concrete, researched options/);
   assert.match(prompt, /"Other — let me discuss"/);

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -10,9 +10,10 @@ import {
   formatKeyDashboard,
   formatTestResults,
   runKeyDoctor,
-  formatDoctorFindings,
-  PROVIDER_REGISTRY,
-} from "../key-manager.ts";
+	  formatDoctorFindings,
+	  PROVIDER_REGISTRY,
+	  getProviderAuthMode,
+	} from "../key-manager.ts";
 
 function makeAuth(data: Record<string, any> = {}): AuthStorage {
   return AuthStorage.inMemory(data);
@@ -76,6 +77,12 @@ test("describeCredential describes an empty API key", () => {
   assert.equal(describeCredential({ type: "api_key", key: "" }), "empty key");
 });
 
+test("describeCredential describes external CLI sentinels without calling them API keys", () => {
+  const provider = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
+  assert.ok(provider);
+  assert.equal(describeCredential({ type: "api_key", key: "cli" }, provider), "external CLI");
+});
+
 test("describeCredential describes an OAuth token with expiry", () => {
   const result = describeCredential({
     type: "oauth",
@@ -149,7 +156,19 @@ test("PROVIDER_REGISTRY includes claude-code as a first-class LLM provider (#454
   const entry = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
   assert.ok(entry, "claude-code must be in PROVIDER_REGISTRY");
   assert.equal(entry!.category, "llm");
-  assert.ok(entry!.hasOAuth, "claude-code uses OAuth (CLI auth)");
+  assert.equal(getProviderAuthMode(entry!), "externalCli");
+});
+
+test("PROVIDER_REGISTRY classifies only Copilot and Codex as browser OAuth LLM providers", () => {
+  const modes = Object.fromEntries(
+    PROVIDER_REGISTRY.filter((p) => p.category === "llm").map((p) => [p.id, getProviderAuthMode(p)]),
+  );
+  assert.equal(modes.anthropic, "apiKey");
+  assert.equal(modes["github-copilot"], "browserOAuth");
+  assert.equal(modes["openai-codex"], "browserOAuth");
+  assert.equal(modes["claude-code"], "externalCli");
+  assert.equal(modes["google-gemini-cli"], "externalCli");
+  assert.equal(modes["google-antigravity"], "externalCli");
 });
 
 test("PROVIDER_REGISTRY includes all tool/search providers", () => {

package/src/resources/extensions/gsd/tests/notification-overlay.test.ts

@@ -11,6 +11,7 @@ import { visibleWidth } from "@gsd/pi-tui";
 import { appendNotification, initNotificationStore, _resetNotificationStore } from "../notification-store.ts";
 import { GSDNotificationOverlay, notificationOverlayOptions } from "../notification-overlay.ts";
 import { wrapVisibleText } from "../tui/render-kit.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const fakeTheme = {
   fg: (_color: string, text: string) => text,
@@ -92,7 +93,11 @@ describe("notification overlay — wrapText", () => {
     t.after(() => overlay.dispose());
 
     for (const width of [40, 80, 120]) {
-      assertLinesFit(overlay.render(width), width);
+      const rendered = overlay.render(width);
+      assertLinesFit(rendered, width);
+      assertFullOuterBorder(rendered, width);
+      assert.match(rendered[0] ?? "", /^╭─ Notifications /);
+      assert.match(rendered.at(-1) ?? "", /^╰─+╯$/);
       overlay.invalidate();
     }
   });

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -48,20 +48,27 @@ describe("auditOrphanedMilestoneBranches", () => {
     const result = auditOrphanedMilestoneBranches(dir, "worktree");
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
+    assert.deepStrictEqual(result.actions, []);
+    assert.equal(result.blockingStrandedWork, null);
   });
 
-  test("skips in none isolation mode", () => {
-    // Create a milestone branch that would otherwise be detected
+  test("runs in none isolation mode and cleans safe completed residue", () => {
     run("git branch milestone/M001", dir);
     insertMilestone({ id: "M001", title: "Test", status: "complete" });
 
     const result = auditOrphanedMilestoneBranches(dir, "none");
-    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(
+      result.recovered.some((r) => r.includes("Deleted merged branch milestone/M001")),
+      `should clean merged completed residue even in none mode; got: ${JSON.stringify(result.recovered)}`,
+    );
     assert.deepStrictEqual(result.warnings, []);
+    assert.ok(
+      result.actions.some((action) => action.kind === "complete-merged-branch"),
+      "should record structured cleanup action",
+    );
 
-    // Branch should still exist
     const branches = run("git branch --list milestone/M001", dir);
-    assert.ok(branches.includes("milestone/M001"), "branch should be preserved in none mode");
+    assert.equal(branches, "", "safe completed branch should be cleaned in none mode");
   });
 
   test("deletes merged branch for completed milestone", () => {
@@ -149,9 +156,12 @@ describe("auditOrphanedMilestoneBranches", () => {
     // Must surface a warning so the user knows the worktree holds uncollapsed work
     assert.ok(result.warnings.length > 0, "should warn about in-progress orphan");
     assert.ok(
-      result.warnings.some(w => w.includes("milestone/M001") && w.includes("in-progress")),
-      `warning should mention milestone/M001 and in-progress state; got: ${JSON.stringify(result.warnings)}`,
+      result.warnings.some(w => w.includes("Stranded work") && w.includes("milestone/M001") && w.includes("in-progress")),
+      `warning should mention stranded milestone/M001 and in-progress state; got: ${JSON.stringify(result.warnings)}`,
     );
+    assert.equal(result.blockingStrandedWork?.milestoneId, "M001");
+    assert.equal(result.blockingStrandedWork?.recoveryMode, "branch");
+    assert.equal(result.blockingStrandedWork?.commitsAhead, 1);
 
     // Branch must still exist
     const branches = run("git branch --list milestone/M001", dir);
@@ -184,6 +194,53 @@ describe("auditOrphanedMilestoneBranches", () => {
       result.warnings.some(w => w.includes(".gsd/worktrees/M001") || w.includes("worktree")),
       `warning should reference the worktree location; got: ${JSON.stringify(result.warnings)}`,
     );
+    assert.equal(result.blockingStrandedWork?.recoveryMode, "worktree");
+  });
+
+  test("detects dirty in-progress worktree even when branch has no commits ahead", () => {
+    run("git branch milestone/M001", dir);
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${join(dir, ".git", "worktrees", "M001")}\n`);
+    writeFileSync(join(wtDir, "dirty.txt"), "uncommitted work\n");
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      hasChanges: (basePath) => basePath === wtDir,
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(
+      result.warnings.some((w) => w.includes("uncommitted changes")),
+      `dirty worktree should be treated as stranded work; got: ${JSON.stringify(result.warnings)}`,
+    );
+    assert.equal(result.blockingStrandedWork?.milestoneId, "M001");
+    assert.equal(result.blockingStrandedWork?.dirtyWorktree, true);
+    assert.equal(result.blockingStrandedWork?.recoveryMode, "worktree");
+  });
+
+  test("detects dirty in-progress worktree even when milestone branch is absent", () => {
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${join(dir, ".git", "worktrees", "M001")}\n`);
+    writeFileSync(join(wtDir, "dirty.txt"), "branchless work\n");
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "none", {
+      hasChanges: (basePath) => basePath === wtDir,
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(
+      result.warnings.some((w) => w.includes("Stranded work") && w.includes("M001")),
+      `branchless dirty worktree should block; got: ${JSON.stringify(result.warnings)}`,
+    );
+    assert.equal(result.blockingStrandedWork?.branch, undefined);
+    assert.equal(result.blockingStrandedWork?.dirtyWorktree, true);
+    assert.equal(result.blockingStrandedWork?.recoveryMode, "worktree");
   });
 
   test("cleans up orphaned worktree directory for merged milestone", () => {
@@ -359,7 +416,7 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.ok(existsSync(wtDir), "active milestone worktree dir must be preserved");
   });
 
-  test("#5879 — skips branch-less orphan in 'none' isolation mode", () => {
+  test("#5879 — cleans branch-less complete orphan in 'none' isolation mode", () => {
     insertMilestone({ id: "M001", title: "Test", status: "complete" });
 
     const wtDir = join(dir, ".gsd", "worktrees", "M001");
@@ -368,7 +425,10 @@ describe("auditOrphanedMilestoneBranches", () => {
 
     const result = auditOrphanedMilestoneBranches(dir, "none");
 
-    assert.deepStrictEqual(result.recovered, []);
-    assert.ok(existsSync(wtDir), "'none' mode must not touch worktree dirs");
+    assert.ok(
+      result.recovered.some((r) => r.includes("M001") && r.includes("branch already deleted")),
+      `none mode should still clean safe completed residue; got: ${JSON.stringify(result.recovered)}`,
+    );
+    assert.ok(!existsSync(wtDir), "completed orphan worktree dir should be cleaned in none mode");
   });
 });

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -5,6 +5,7 @@ import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 
 import { visibleWidth } from "@gsd/pi-tui";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 function assertLinesFit(lines: string[], width: number): void {
   for (const line of lines) {
@@ -51,6 +52,9 @@ describe("parallel-monitor-overlay", () => {
     const joined = lines.join("\n");
     assert.ok(joined.includes("Parallel Monitor"), "should include title");
     assert.ok(joined.includes("No parallel workers found"), "should show empty state");
+    assertFullOuterBorder(lines, 80);
+    assert.match(lines[0] ?? "", /^╭─ GSD Parallel Monitor /);
+    assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
 
     // Dispose should not throw
     overlay.dispose();
@@ -105,7 +109,9 @@ describe("parallel-monitor-overlay", () => {
     );
 
     for (const width of [40, 80, 120]) {
-      assertLinesFit(overlay.render(width), width);
+      const lines = overlay.render(width);
+      assertLinesFit(lines, width);
+      assertFullOuterBorder(lines, width);
       overlay.invalidate();
     }
 

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

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

package/src/resources/extensions/gsd/tests/show-config-command.test.ts

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 
 import { GSDConfigOverlay, formatConfigText } from "../config-overlay.ts";
 import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const theme = {
   bold: (s: string) => s,
@@ -24,6 +25,9 @@ test("GSDConfigOverlay renders and responds to input", () => {
 
   const lines = overlay.render(60);
   assert.ok(lines.some((line) => line.includes("GSD Configuration")));
+  assertFullOuterBorder(lines, 60);
+  assert.match(lines[0] ?? "", /^╭─ GSD Configuration /);
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
 
   overlay.handleInput("j");
   assert.equal(renderRequests, 1);

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

@@ -15,6 +15,13 @@ function readGsdFile(relativePath: string): string {
   return readFileSync(resolve(gsdDir, relativePath), "utf-8");
 }
 
+function firstIndexOfAny(source: string, needles: string[]): number {
+  const indexes = needles
+    .map((needle) => source.indexOf(needle))
+    .filter((index) => index > -1);
+  return indexes.length > 0 ? Math.min(...indexes) : -1;
+}
+
 test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
   const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
   const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
@@ -145,7 +152,11 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
   const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
-  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
+  const enterMilestoneIdx = firstIndexOfAny(bootstrapBody, [
+    "buildLifecycle().enterMilestone",
+    "lifecycle.enterMilestone",
+    "lifecycle.adoptStrandedMilestone",
+  ]);
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
@@ -158,7 +169,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
   assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
   assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
-  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter or adopt milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",