@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -1,7 +1,6 @@
 /**
- * Regression test for #3453: dynamic model routing must be disabled for
- * flat-rate providers like GitHub Copilot where all models cost the same
- * per request — routing only degrades quality with no cost benefit.
+ * Regression tests for flat-rate provider detection and the explicit opt-out
+ * that suppresses dynamic routing for subscription providers.
  */
 
 import { describe, test } from "node:test";
@@ -9,7 +8,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig, selectAndApplyModel } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -35,23 +34,18 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(isFlatRateProvider("openai"), false);
   });
 
-  test("resolvePreferredModelConfig returns undefined for copilot start model", () => {
+  test("resolvePreferredModelConfig synthesizes routing config for copilot start model when routing is enabled", () => {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
     const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
     const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
 
-    // When the user's start model is on a flat-rate provider,
-    // resolvePreferredModelConfig should not synthesize a routing
-    // config from tier_models — it should return undefined so the
-    // user's selected model is preserved.
     try {
       mkdirSync(join(tempProject, ".gsd"), { recursive: true });
       writeFileSync(
         join(tempProject, ".gsd", "PREFERENCES.md"),
         [
           "---",
-          "token_profile: burn-max",
           "dynamic_routing:",
           "  enabled: true",
           "  tier_models:",
@@ -70,10 +64,83 @@ describe("flat-rate provider routing guard (#3453)", () => {
         id: "claude-sonnet-4",
       });
 
-      // Should be undefined (no routing config created for flat-rate)
-      // Note: this only tests the synthesis guard — explicit per-unit config
-      // still takes precedence when the user configured one.
-      assert.equal(result, undefined, "Should not create routing config for copilot");
+      assert.deepEqual(result, {
+        primary: "claude-opus-4-6",
+        fallbacks: [],
+        source: "synthesized",
+      });
+    } finally {
+      process.chdir(originalCwd);
+      if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = originalGsdHome;
+      rmSync(tempProject, { recursive: true, force: true });
+      rmSync(tempGsdHome, { recursive: true, force: true });
+    }
+  });
+
+  test("selectAndApplyModel runs synthesized dynamic routing for flat-rate start model", async () => {
+    const originalCwd = process.cwd();
+    const originalGsdHome = process.env.GSD_HOME;
+    const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
+    const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
+    const setModelCalls: string[] = [];
+
+    try {
+      mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+      writeFileSync(
+        join(tempProject, ".gsd", "PREFERENCES.md"),
+        [
+          "---",
+          "dynamic_routing:",
+          "  enabled: true",
+          "  hooks: false",
+          "  budget_pressure: false",
+          "  tier_models:",
+          "    light: claude-haiku-4-5",
+          "    standard: claude-sonnet-4-6",
+          "    heavy: claude-opus-4-6",
+          "---",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_HOME = tempGsdHome;
+      process.chdir(tempProject);
+
+      const availableModels = [
+        { id: "claude-haiku-4-5", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-sonnet-4-6", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-opus-4-6", provider: "claude-code", api: "anthropic-messages" },
+      ];
+
+      const result = await selectAndApplyModel(
+        {
+          modelRegistry: { getAvailable: () => availableModels },
+          sessionManager: { getSessionId: () => "test-session" },
+          ui: { notify: () => {} },
+          model: { provider: "claude-code", id: "claude-opus-4-6", api: "anthropic-messages" },
+        } as any,
+        {
+          setModel: async (model: { provider: string; id: string }) => {
+            setModelCalls.push(`${model.provider}/${model.id}`);
+            return true;
+          },
+          emitBeforeModelSelect: async () => undefined,
+          getActiveTools: () => [],
+          emitAdjustToolSet: async () => undefined,
+          setActiveTools: () => {},
+        } as any,
+        "execute-task",
+        "M001/S01/T01",
+        tempProject,
+        undefined,
+        false,
+        { provider: "claude-code", id: "claude-opus-4-6" },
+        undefined,
+        true,
+      );
+
+      assert.deepEqual(setModelCalls, ["claude-code/claude-sonnet-4-6"]);
+      assert.deepEqual(result.routing, { tier: "standard", modelDowngraded: true });
     } finally {
       process.chdir(originalCwd);
       if (originalGsdHome === undefined) delete process.env.GSD_HOME;
@@ -220,9 +287,9 @@ describe("buildFlatRateContext()", () => {
   });
 });
 
-// ─── #4386: allow_flat_rate_providers opt-in ────────────────────────────────
+// ─── #4386/#1115: allow_flat_rate_providers override ────────────────────────
 
-describe("flat-rate routing opt-in (#4386)", () => {
+describe("flat-rate routing override (#4386/#1115)", () => {
   function withPrefs(prefsYaml: string, fn: () => void): void {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
@@ -247,7 +314,7 @@ describe("flat-rate routing opt-in (#4386)", () => {
     }
   }
 
-  test("default (opt-in absent): flat-rate start model still returns undefined", () => {
+  test("default (allow absent): flat-rate start model still synthesizes routing config", () => {
     withPrefs(
       [
         "dynamic_routing:",
@@ -260,12 +327,13 @@ describe("flat-rate routing opt-in (#4386)", () => {
           provider: "claude-code",
           id: "claude-opus-4-6",
         });
-        assert.equal(result, undefined, "default must preserve #3453 bypass");
+        assert.ok(result, "routing config should be synthesized");
+        assert.equal(result!.primary, "claude-opus-4-6");
       },
     );
   });
 
-  test("opt-in: synthesizes a routing config for flat-rate start model", () => {
+  test("explicit allow: synthesizes a routing config for flat-rate start model", () => {
     withPrefs(
       [
         "dynamic_routing:",

package/src/resources/extensions/gsd/tests/forensics-error-filter.test.ts

@@ -119,3 +119,91 @@ describe("extractTrace error filtering (#2539)", () => {
     assert.equal(trace.errors.length, 1, "lint error with output should be counted");
   });
 });
+
+describe("extractTrace pending tool calls (#945)", () => {
+  test("tool call without a toolResult is counted as an error", () => {
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_missing",
+              name: "gsd_summary_save",
+              arguments: { content: "unfinished summary" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    assert.equal(trace.toolCalls.length, 1);
+    assert.equal(trace.toolCalls[0]?.name, "gsd_summary_save");
+    assert.equal(trace.toolCalls[0]?.isError, true);
+    assert.equal(trace.toolCalls[0]?.result, "missing tool result (stream/tool-call abort before execution)");
+    assert.equal(trace.errors.length, 1);
+    assert.equal(trace.errors[0], "Tool call gsd_summary_save started but no toolResult was recorded");
+  });
+
+  test("pending bash call with no toolResult marks commandsRun entry as failed", () => {
+    // A bash tool call that was initiated but never got a toolResult (stream abort).
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_bash_missing",
+              name: "bash",
+              arguments: { command: "npm run build" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    // The tool call should be recorded as an error.
+    assert.equal(trace.toolCalls.length, 1);
+    assert.equal(trace.toolCalls[0]?.name, "bash");
+    assert.equal(trace.toolCalls[0]?.isError, true);
+
+    // The commandsRun entry must be consistent: failed: true, not failed: false.
+    assert.equal(trace.commandsRun.length, 1);
+    assert.equal(trace.commandsRun[0]?.command, "npm run build");
+    assert.equal(trace.commandsRun[0]?.failed, true,
+      "commandsRun entry should be failed when its bash call never returned a result");
+  });
+
+  test("pending bg_shell call with no toolResult marks commandsRun entry as failed", () => {
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_bg_missing",
+              name: "bg_shell",
+              arguments: { command: "sleep 30" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    assert.equal(trace.commandsRun.length, 1);
+    assert.equal(trace.commandsRun[0]?.failed, true,
+      "bg_shell commandsRun entry should be failed when no toolResult was recorded");
+  });
+});

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 
 import {
   checkAutoStartAfterDiscuss,
+  _getPendingAutoStart,
   setPendingAutoStart,
   clearPendingAutoStart,
 } from "../guided-flow.ts";
@@ -21,6 +22,7 @@ import { drainLogs } from "../workflow-logger.ts";
 import {
   openDatabase,
   closeDatabase,
+  getMilestone,
   insertMilestone,
 } from "../gsd-db.ts";
 
@@ -59,6 +61,12 @@ function mkBase(): string {
   return base;
 }
 
+function mkFlatBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-flat-"));
+  mkdirSync(join(base, ".gsd", "phases", "01-m001"), { recursive: true });
+  return base;
+}
+
 function writeContext(base: string): void {
   writeFileSync(
     join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -66,6 +74,13 @@ function writeContext(base: string): void {
   );
 }
 
+function writeFlatContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "phases", "01-m001", "01-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
+
 describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
@@ -142,4 +157,78 @@ describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
     );
     assert.equal(gate1bLog, undefined, "Gate 1b must not log when CONTEXT.md is absent");
   });
+
+  test("flat-phase CONTEXT.md accepts handoff without a legacy milestone context file", () => {
+    base = mkFlatBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, true, "flat-phase context must be found by the handoff");
+    assert.equal(cap.messages.length, 0, "startAuto=false must suppress scheduling");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
+  });
+
+  test("DB-unavailable recovery blocks handoff instead of reporting success", () => {
+    base = mkFlatBase();
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, false, "handoff must fail closed when the DB row cannot be confirmed");
+    assert.equal(cap.messages.length, 0, "must not schedule auto-start when DB is unavailable");
+    assert.equal(
+      cap.notifies.some(n => n.level === "success"),
+      false,
+      "must not report a successful handoff when DB recovery was skipped",
+    );
+    assert.ok(_getPendingAutoStart(base), "pending handoff should remain for a later recovery attempt");
+  });
+
+  test("missing DB row with CONTEXT.md inserts a queued row and accepts handoff", () => {
+    base = mkFlatBase();
+    openDatabase(":memory:");
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, true, "successful insert should recover the missing row");
+    assert.equal(getMilestone("M001")?.status, "queued");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
+  });
 });

package/src/resources/extensions/gsd/tests/gitignore-bg-shell-runtime.test.ts

@@ -40,6 +40,10 @@ describe('ensureGitignore writes .bg-shell/ baseline (#4902)', () => {
         lines.has('.bg-shell/'),
         `.gitignore should include .bg-shell/. Got:\n${ignore}`,
       );
+      assert.ok(
+        lines.has('.gsd-backups/'),
+        `.gitignore should include .gsd-backups/. Got:\n${ignore}`,
+      );
     } finally {
       cleanup(dir);
     }

package/src/resources/extensions/gsd/tests/gsd-core-parity-routing.test.ts

@@ -0,0 +1,183 @@
+// gsd-pi — Comprehensive routing test for all additional commands
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+//
+// Asserts that EVERY gsd-core command name is handled by the gsd-pi dispatcher —
+// either as an implemented native workflow (dispatches a prompt) or as an alias
+// (redirect / unavailable notice). None may fall through to "Unknown".
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { handleGSDCommand } from "../commands/dispatcher.ts";
+
+function createMockPi() {
+  const sent: any[] = [];
+  return {
+    sent,
+    sendMessage: (message: any) => sent.push(message),
+    registerCommand() {},
+    registerTool() {},
+    registerShortcut() {},
+    on() {},
+  };
+}
+
+function createMockCtx(cwd?: string) {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    cwd,
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => {},
+    },
+    shutdown: async () => {},
+  };
+}
+
+function createTempGsdProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-core-parity-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+// The complete list of gsd-core command names (from ~/github/open-gsd/gsd-core/commands/gsd/*.md).
+// extract-learnings and complete-milestone are natively handled by ops.ts (pre-existing).
+const GSD_CORE_COMMANDS = [
+  "add-tests",
+  "ai-integration-phase",
+  "audit-fix",
+  "audit-milestone",
+  "audit-uat",
+  "autonomous",
+  "capture",
+  "cleanup",
+  "code-review",
+  "complete-milestone",
+  "debug",
+  "discuss-phase",
+  "docs-update",
+  "execute-phase",
+  "explore",
+  "extract-learnings",
+  "graphify",
+  "health",
+  "help",
+  "import",
+  "inbox",
+  "ingest-docs",
+  "manager",
+  "map-codebase",
+  "milestone-summary",
+  "mvp-phase",
+  "new-milestone",
+  "new-project",
+  "ns-context",
+  "ns-ideate",
+  "ns-manage",
+  "ns-project",
+  "ns-review",
+  "ns-workflow",
+  "pause-work",
+  "phase",
+  "plan-phase",
+  "plan-review-convergence",
+  "progress",
+  "resume-work",
+  "review",
+  "review-backlog",
+  "secure-phase",
+  "settings",
+  "sketch",
+  "spec-phase",
+  "spike",
+  "stats",
+  "surface",
+  "thread",
+  "ui-phase",
+  "ui-review",
+  "ultraplan-phase",
+  "validate-phase",
+  "verify-work",
+  "workspace",
+  "workstreams",
+] as const;
+
+describe("gsd-core command parity routing", () => {
+  // Commands that legitimately don't dispatch a prompt on a bare invocation in a
+  // mock environment (they need a real .gsd/ project / TUI / gh CLI). We only
+  // assert they don't fall through to "Unknown".
+  test("every gsd-core command is handled (no 'Unknown' fallthrough)", async () => {
+    const unhandled: string[] = [];
+    const base = createTempGsdProject();
+    try {
+      for (const cmd of GSD_CORE_COMMANDS) {
+        const pi = createMockPi();
+        const ctx = createMockCtx(base);
+        try {
+          await handleGSDCommand(cmd, ctx as any, pi as any);
+        } catch {
+          // Some commands throw GSDNoProjectError etc. in a mock env — that still
+          // means they were recognized and routed, not "Unknown".
+        }
+        const fellThrough = ctx.notifications.some(
+          (n) => n.message.startsWith("Unknown:") && n.message.includes(`/gsd ${cmd}`),
+        );
+        if (fellThrough) unhandled.push(cmd);
+      }
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+    assert.deepStrictEqual(
+      unhandled,
+      [],
+      `These gsd-core commands fell through to "Unknown" (not routed):\n  ${unhandled.join(", ")}`,
+    );
+  });
+
+  test("implemented commands dispatch a prompt via pi.sendMessage", async () => {
+    const implemented = [
+      "explore", "spike", "sketch",
+      "map-codebase", "docs-update", "graphify", "stats", "progress", "health", "surface",
+      "code-review", "review", "audit-milestone", "audit-uat", "audit-fix", "ui-review",
+      "secure-phase", "validate-phase", "verify-work", "plan-review-convergence",
+      "discuss-phase", "plan-phase", "execute-phase", "spec-phase", "mvp-phase",
+      "ui-phase", "ai-integration-phase", "ultraplan-phase", "autonomous",
+      "pause-work", "resume-work",
+      "manager", "thread", "workstreams", "milestone-summary",
+      "review-backlog", "inbox", "import", "ingest-docs", "profile-user", "settings",
+    ];
+    const noPrompt: string[] = [];
+    const base = createTempGsdProject();
+    const processCwd = createTempGsdProject();
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(processCwd);
+      for (const cmd of implemented) {
+        const pi = createMockPi();
+        const ctx = createMockCtx(base);
+        await handleGSDCommand(cmd, ctx as any, pi as any);
+        if (pi.sent.length !== 1) noPrompt.push(`${cmd} (sent ${pi.sent.length})`);
+      }
+      assert.equal(existsSync(join(processCwd, ".gsd", "spikes")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "sketches")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "codebase")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "knowledge")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "reviews")), false);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(base, { recursive: true, force: true });
+      rmSync(processCwd, { recursive: true, force: true });
+    }
+    assert.deepStrictEqual(
+      noPrompt,
+      [],
+      `These implemented commands did not dispatch exactly one prompt:\n  ${noPrompt.join(", ")}`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/guidance.test.ts

@@ -145,4 +145,29 @@ describe("doctor fix hints", () => {
   test("codes without authored guidance resolve to undefined", () => {
     assert.equal(doctorFixHint("delimiter_in_title"), undefined);
   });
+
+  test("fixable issue codes instruct /gsd doctor fix, not bare /gsd doctor", () => {
+    const fixableCodes = [
+      "stale_crash_lock",
+      "stale_parallel_session",
+      "orphaned_auto_worktree",
+      "gitignore_missing_patterns",
+      "state_file_stale",
+      "state_file_missing",
+      "projection_drift",
+    ] as const;
+
+    for (const code of fixableCodes) {
+      const hint = doctorFixHint(code);
+      assert.ok(hint, `expected a hint for ${code}`);
+      assert.match(hint, /\/gsd doctor fix/, `hint for ${code} must use /gsd doctor fix`);
+    }
+  });
+
+  test("db_unavailable uses bare /gsd doctor (diagnostic only, no auto-fix)", () => {
+    const hint = doctorFixHint("db_unavailable");
+    assert.ok(hint);
+    assert.match(hint, /\/gsd doctor/);
+    assert.doesNotMatch(hint, /\/gsd doctor fix/);
+  });
 });

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

@@ -86,3 +86,45 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
+  const previousGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = join(base, ".gsd-home");
+
+  try {
+    const currentDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(currentDir, { recursive: true });
+
+    const draftPath = join(currentDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nSMALL-DRAFT-SIGNAL", "utf-8");
+    const smallPrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    writeFileSync(
+      draftPath,
+      ["# Draft", "", "SMALL-DRAFT-SIGNAL", "", "A".repeat(200_000), "", "OVERSIZED-DRAFT-TAIL-SIGNAL"].join("\n"),
+      "utf-8",
+    );
+    const largePrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    const addedChars = largePrompt.length - smallPrompt.length;
+
+    assert.match(largePrompt, /## Prior Discussion \(Draft Seed\)/);
+    assert.match(largePrompt, /### Prior Discussion Draft/);
+    assert.match(largePrompt, /SMALL-DRAFT-SIGNAL/);
+    assert.doesNotMatch(largePrompt, /OVERSIZED-DRAFT-TAIL-SIGNAL/);
+    assert.match(
+      largePrompt,
+      /Draft seed truncated; read the full draft at `\.gsd\/milestones\/M001\/M001-CONTEXT-DRAFT\.md` if needed\./,
+    );
+    assert.ok(addedChars < 25_000, `large draft should add bounded seed chars, added ${addedChars}`);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+  }
+});