@opengsd/gsd-pi 1.0.2-dev.867e002 → 1.0.2-dev.cce3612

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/discord-invite-links.test.ts

@@ -19,6 +19,7 @@ const VALID_INVITE = "https://discord.gg/8NnkKuepmQ";
 const FILES_WITH_INVITE_LINKS: string[] = [
   "README.md",
   "docs/dev/what-is-pi/15-pi-packages-the-ecosystem.md",
+  "packages/pi-coding-agent/README.md",
 ];
 
 describe("Discord invite links (#2699)", () => {

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/discuss-tool-scoping.test.ts

@@ -111,7 +111,7 @@ describe("discuss tool scoping (#2949)", () => {
             setCalls.push([...tools]);
             activeTools = [...tools];
           },
-          sendMessage: (message: unknown) => {
+          sendMessage: async (message: unknown) => {
             sent.push(message);
             sentTools = [...activeTools];
           },

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/doctor-scope-db-unavailable.test.ts

@@ -1,11 +1,12 @@
 import { afterEach, test } from "node:test";
 import assert from "node:assert/strict";
-import { closeDatabase } from "../gsd-db.ts";
+import { _getAdapter, closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { filterDoctorIssues } from "../doctor-format.ts";
 import { checkEngineHealth } from "../doctor-engine-checks.ts";
+import { appendEvent } from "../workflow-events.ts";
 
 afterEach(() => {
   closeDatabase();
@@ -41,3 +42,102 @@ test("checkEngineHealth reports db_unavailable when gsd.db exists but the DB is
   assert.equal(dbIssue.unitId, "project");
   assert.equal(dbIssue.file, ".gsd/gsd.db");
 });
+
+test("checkEngineHealth reads canonical reopen events from worktree bases", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-reopen-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const worktree = join(gsdDir, "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), "gitdir: ../../../../.git/worktrees/M001\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M001", title: "Reopened", status: "active" });
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO workers (
+      worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("worker-1", "localhost", 1, "2026-01-01T00:00:00.000Z", "test", "2026-01-01T00:00:00.000Z", "stopped", base);
+  db.prepare(
+    `INSERT INTO unit_dispatches (
+      trace_id, worker_id, milestone_lease_token, milestone_id,
+      unit_type, unit_id, status, attempt_n, started_at, ended_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    "trace-1",
+    "worker-1",
+    1,
+    "M001",
+    "complete-milestone",
+    "M001",
+    "completed",
+    1,
+    "2026-01-01T00:00:00.000Z",
+    "2026-01-01T00:00:01.000Z",
+  );
+  appendEvent(base, {
+    cmd: "reopen-milestone",
+    params: { milestoneId: "M001" },
+    ts: "2026-01-01T00:00:02.000Z",
+    actor: "agent",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(worktree, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "completed_milestone_reopened"),
+    false,
+    "canonical reopen event should exempt the reopened milestone from doctor drift errors",
+  );
+});
+
+test("checkEngineHealth treats explicit reopen as authoritative when dispatch timestamps are missing", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-reopen-no-dispatch-time-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M001", title: "Reopened", status: "active" });
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO workers (
+      worker_id, host, pid, started_at, version, last_heartbeat_at, status, project_root_realpath
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("worker-1", "localhost", 1, "2026-01-01T00:00:00.000Z", "test", "2026-01-01T00:00:00.000Z", "stopped", base);
+  db.exec("PRAGMA writable_schema = ON");
+  db.prepare(
+    `UPDATE sqlite_schema
+     SET sql = replace(sql, 'started_at TEXT NOT NULL', 'started_at TEXT')
+     WHERE type = 'table' AND name = 'unit_dispatches'`,
+  ).run();
+  db.exec("PRAGMA writable_schema = OFF");
+  closeDatabase();
+  openDatabase(join(gsdDir, "gsd.db"));
+  const reopenedDb = _getAdapter()!;
+  reopenedDb.prepare(
+    `INSERT INTO unit_dispatches (
+      trace_id, worker_id, milestone_lease_token, milestone_id,
+      unit_type, unit_id, status, attempt_n, started_at, ended_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run("trace-1", "worker-1", 1, "M001", "complete-milestone", "M001", "completed", 1, null, null);
+  appendEvent(base, {
+    cmd: "reopen-milestone",
+    params: { milestoneId: "M001" },
+    ts: "2026-01-01T00:00:02.000Z",
+    actor: "agent",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "completed_milestone_reopened"),
+    false,
+    "explicit reopen should exempt reopened milestone even when completion dispatch timestamps are absent",
+  );
+});

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();
     }