@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -241,6 +241,36 @@ test('executeGsdExec: enforces per-call timeout override end-to-end', async () =
   }
 });
 
+test('executeGsdExec: defaults to bash and accepts command alias', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { command: 'echo command-alias-defaults-to-bash' },
+      { baseDir: base, preferences: { context_mode: { enabled: true } } },
+    );
+    assert.equal(result.isError, false);
+    assert.equal(result.details.runtime, 'bash');
+    assert.ok(result.content[0].text.includes('command-alias-defaults-to-bash'));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: accepts common runtime aliases', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'js', code: 'console.log("runtime-alias-node")' },
+      { baseDir: base, preferences: { context_mode: { enabled: true } } },
+    );
+    assert.equal(result.isError, false);
+    assert.equal(result.details.runtime, 'node');
+    assert.ok(result.content[0].text.includes('runtime-alias-node'));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('executeGsdExec: rejects empty script', async () => {
   const base = freshBase();
   try {

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/headless-answers.test.ts

@@ -92,10 +92,10 @@ test('loadAndValidateAnswerFile — wrong types (non-string secret value)', (t)
 // AnswerInjector — observeEvent + tryHandle
 // ---------------------------------------------------------------------------
 
-function makeToolExecutionStart(questions: Record<string, unknown>[]) {
+function makeToolExecutionStart(questions: Record<string, unknown>[], toolName = 'ask_user_questions') {
   return {
     type: 'tool_execution_start',
-    toolName: 'ask_user_questions',
+    toolName,
     input: { questions },
   };
 }
@@ -140,6 +140,25 @@ test('observeEvent stores metadata', (t) => {
   assert.strictEqual(injector.getStats().questionsDefaulted, 1);
 });
 
+test('observeEvent stores metadata for MCP-scoped ask_user_questions', (t) => {
+  const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }], 'mcp__custom-workflow__ask_user_questions'));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent('req-1', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  assert.strictEqual(handled, true);
+  assert.strictEqual(captured.length, 1);
+});
+
 test('tryHandle matches by question ID — single select', (t) => {
   const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
 
@@ -312,7 +331,7 @@ test('tryHandle deferred resolution — observeEvent after tryHandle', async (t)
 // ---------------------------------------------------------------------------
 
 test('getSecretEnvVars returns secrets map', (t) => {
-  const secrets = { API_KEY: 'sk-123', DB_URL: 'postgres://localhost/db' };
+  const secrets = { API_KEY: 'sk-123', DB_URL: 'db-local-fixture' };
   const injector = new AnswerInjector({ secrets });
 
   assert.deepStrictEqual(injector.getSecretEnvVars(), secrets);

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -370,6 +370,49 @@ test("mergeCompletedMilestone — synthesizes roadmap from DB when projection is
   }
 });
 
+test("mergeCompletedMilestone — stale worktree marker does not auto-commit dirty root overlap", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    setupWorktreeIsolation(repo);
+    setupRoadmap(repo, "M011", "Dirty Root Recovery", ["S01: App shell"]);
+
+    createMilestoneBranch(repo, "M011", [
+      { name: "index.html", content: "<h1>M011</h1>\n" },
+    ]);
+
+    // Stale marker without a registered git worktree. Recovery must not treat
+    // the project root as a worktree and auto-commit this overlapping file to
+    // main before attempting the milestone merge.
+    mkdirSync(join(repo, ".gsd", "worktrees", "M011", ".gsd"), { recursive: true });
+    writeFileSync(join(repo, "index.html"), "<h1>local root draft</h1>\n");
+
+    process.chdir(repo);
+    const result = await mergeCompletedMilestone(repo, "M011");
+
+    assert.equal(result.success, false, "dirty overlap should block branch-mode recovery");
+    assert.match(
+      result.error ?? "",
+      /checkout|overwritten|untracked|would be overwritten/i,
+      "error should explain that checkout/dirty root state blocked recovery",
+    );
+
+    const subjects = run("git log --format=%s", repo);
+    assert.ok(
+      !subjects.includes("chore: auto-commit before milestone merge"),
+      "recovery must not auto-commit project-root overlap to main",
+    );
+    assert.equal(run("git branch --show-current", repo), "main");
+    assert.equal(run("git branch --list milestone/M011", repo).trim(), "milestone/M011");
+    assert.equal(run("git status --short -- index.html", repo), "?? index.html");
+  } finally {
+    process.chdir(savedCwd);
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    cleanup(repo);
+  }
+});
+
 test("mergeCompletedMilestone — clean merge, session status cleaned up", async () => {
   const savedCwd = process.cwd();
   const repo = createTempRepo();

package/src/resources/extensions/gsd/tests/interactive-tool-idle-exemption.test.ts

@@ -43,6 +43,14 @@ describe("hasInteractiveToolInFlight", () => {
     assert.equal(hasInteractiveToolInFlight(), true);
   });
 
+  test("returns true when MCP-scoped interactive tools are in-flight", () => {
+    markToolStart("call-1", true, "mcp__custom-workflow__ask_user_questions");
+    assert.equal(hasInteractiveToolInFlight(), true);
+    clearInFlightTools();
+    markToolStart("call-2", true, "mcp__custom-workflow__secure_env_collect");
+    assert.equal(hasInteractiveToolInFlight(), true);
+  });
+
   test("returns false after interactive tool completes", () => {
     markToolStart("call-1", true, "ask_user_questions");
     assert.equal(hasInteractiveToolInFlight(), true);

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/mcp-filter.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { discoverMcpServerNames, computeMcpDisallowedTools } from "../mcp-filter.ts";
+import { discoverMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools } from "../mcp-filter.ts";
 import type { ClaudeCodeMcpConfig } from "../preferences-types.ts";
 
 // ─── discoverMcpServerNames ────────────────────────────────────────────────
@@ -57,6 +57,24 @@ describe("discoverMcpServerNames", () => {
     const result = discoverMcpServerNames(dir);
     assert.deepEqual(result, ["only-server"]);
   });
+
+  it("discovers workflow server names by config signature", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "custom-workflow": {
+            command: "node",
+            args: ["custom-cli.js"],
+            env: { GSD_WORKFLOW_PROJECT_ROOT: dir },
+          },
+          unrelated: { command: "npx", args: ["other"] },
+        },
+      }),
+    );
+    assert.equal(discoverWorkflowMcpServerName(dir), "custom-workflow");
+  });
 });
 
 // ─── computeMcpDisallowedTools ─────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -72,6 +72,30 @@ test("ensureProjectWorkflowMcpConfig preserves existing mcp servers", () => {
   }
 });
 
+test("ensureProjectWorkflowMcpConfig uses custom workflow server name from env", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot, {
+      GSD_WORKFLOW_MCP_COMMAND: "node",
+      GSD_WORKFLOW_MCP_NAME: "custom-workflow",
+      GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["server.js"]),
+      GSD_WORKFLOW_MCP_CWD: projectRoot,
+    });
+    assert.equal(result.status, "created");
+    assert.equal(result.serverName, "custom-workflow");
+
+    const parsed = JSON.parse(readFileSync(result.configPath, "utf-8")) as {
+      mcpServers?: Record<string, { command?: string; args?: string[] }>;
+    };
+    assert.ok(parsed.mcpServers?.["custom-workflow"]);
+    assert.equal(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME], undefined);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
 test("ensureProjectWorkflowMcpConfig is idempotent when config is already current", () => {
   const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
   mkdirSync(join(projectRoot, ".gsd"), { recursive: true });

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

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { copyFileSync, mkdtempSync, renameSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
@@ -7,7 +8,9 @@ import test from "node:test";
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
 import {
   closeDatabase,
+  checkpointDatabase,
   getAllMilestones,
+  _getAdapter,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -20,6 +23,20 @@ import {
 import { writeGSDDirectory } from "../migrate/writer.ts";
 import type { GSDProject } from "../migrate/types.ts";
 
+const _require = createRequire(import.meta.url);
+
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require("node:sqlite") as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require("better-sqlite3") as SqliteCtor | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === "function" ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
+
 function makeBase(): string {
   return mkdtempSync(join(tmpdir(), "gsd-migration-auto-check-"));
 }
@@ -133,3 +150,41 @@ test("migration auto-check leaves matching DB hierarchy alone", async () => {
     cleanup(base);
   }
 });
+
+test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    checkpointDatabase();
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    const replacementPath = join(base, ".gsd", "gsd-replacement.db");
+    copyFileSync(dbPath, replacementPath);
+
+    const replacement = openRawSqliteForTest(replacementPath);
+    try {
+      replacement.exec(`
+        INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo, created_at, sequence)
+        VALUES ('M001', 'S01', 'Legacy Slice', 'pending', 'medium', '[]', 'Legacy slice demo', '', 1);
+        INSERT INTO tasks (milestone_id, slice_id, id, title, status, sequence)
+        VALUES ('M001', 'S01', 'T01', 'Legacy Task', 'pending', 1);
+      `);
+    } finally {
+      replacement.close();
+    }
+
+    const staleAdapter = _getAdapter();
+    renameSync(replacementPath, dbPath);
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.notEqual(_getAdapter(), staleAdapter, "startup comparison must reopen the active DB handle");
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});

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/park-milestone.test.ts

@@ -19,6 +19,7 @@ import {
   openDatabase,
 } from "../gsd-db.ts";
 import { createWorktree } from "../worktree-manager.ts";
+import { _resetLogs, drainLogs, setStderrLoggingEnabled } from "../workflow-logger.ts";
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -190,7 +191,9 @@ test('getActiveMilestoneId skips parked', async () => {
   // ─── Test 10: discardMilestone removes directory ──────────────────────
 test('discardMilestone removes directory', async () => {
     const base = createFixtureBase();
+    const previousStderr = setStderrLoggingEnabled(false);
     try {
+      _resetLogs();
       createMilestone(base, 'M001', { withRoadmap: true });
       clearCaches();
 
@@ -200,7 +203,13 @@ test('discardMilestone removes directory', async () => {
       const success = discardMilestone(base, 'M001');
       assert.ok(success, 'discardMilestone returns true');
       assert.ok(!existsSync(mDir), 'milestone dir removed after discard');
+      const logs = drainLogs();
+      assert.ok(
+        logs.some((entry) => entry.message.includes('discardMilestone DB cleanup skipped for M001: database unavailable')),
+        'discardMilestone warns when DB cleanup is skipped',
+      );
     } finally {
+      setStderrLoggingEnabled(previousStderr);
       cleanup(base);
     }
 });