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

package/src/resources/extensions/gsd/tests/worktree-post-create-hook.test.ts

@@ -13,7 +13,7 @@ import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync, readFileSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runWorktreePostCreateHook } from "../auto-worktree.ts";
+import { runWorktreePostCreateHook } from "../worktree-post-create-hook.ts";
 
 function makeTmpDir(): string {
   return mkdtempSync(join(tmpdir(), "gsd-wt-hook-test-"));
@@ -45,10 +45,150 @@ function writeNodeHookScript(filePath: string, code: string): void {
 test("returns null when no hook path is provided", () => {
   const src = makeTmpDir();
   const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
   try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
     const result = runWorktreePostCreateHook(src, wt, undefined);
     assert.equal(result, null);
   } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("reads git.worktree_post_create from project preferences without loading auto-worktree", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(
+      join(src, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/post-create")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    const hookFile = hookPath(join(hooksDir, "post-create"));
+    writeNodeHookScript(
+      hookFile,
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "ok");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.ok(existsSync(join(wt, "configured-hook-ran")), "configured hook should run");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("prefers canonical project PREFERENCES.md over legacy lowercase preferences.md", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(
+      join(src, ".gsd", "preferences.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/legacy")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(src, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/canonical")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "canonical")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "canonical");`,
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "legacy")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "legacy");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.equal(readFileSync(join(wt, "configured-hook-ran"), "utf-8"), "canonical");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("prefers canonical global PREFERENCES.md over legacy lowercase preferences.md", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    const gsdHomeDir = join(src, "global-gsd-home");
+    process.env.GSD_HOME = gsdHomeDir;
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    mkdirSync(gsdHomeDir, { recursive: true });
+    writeFileSync(
+      join(gsdHomeDir, "preferences.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/legacy")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(gsdHomeDir, "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/canonical")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "canonical")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "canonical");`,
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "legacy")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "legacy");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.equal(readFileSync(join(wt, "configured-hook-ran"), "utf-8"), "canonical");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
     rmSync(src, { recursive: true, force: true });
     rmSync(wt, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/worktree-state-projection.test.ts

@@ -2,7 +2,7 @@
 // File Purpose: Worktree State Projection Module — typed-Interface contract tests for projectRootToWorktree (ADR-016).
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
@@ -60,6 +60,43 @@ test("projectRootToWorktree is idempotent — repeated calls do not throw", () =
   }
 });
 
+test("projectRootToWorktree forwards root PROJECT.md into isolated worktrees", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const worktree = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(worktree, ".gsd"), { recursive: true });
+
+    const projectContent = [
+      "# Project",
+      "",
+      "## Milestone Sequence",
+      "",
+      "- [ ] M001: Foundation — Establish the runnable slice.",
+      "",
+    ].join("\n");
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), projectContent);
+    writeFileSync(join(dir, ".gsd", "REQUIREMENTS.md"), "# Requirements\n");
+    writeFileSync(join(dir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+    const workspace = createWorkspace(worktree);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    projection.projectRootToWorktree(scope);
+
+    const projectedProject = join(worktree, ".gsd", "PROJECT.md");
+    assert.ok(existsSync(projectedProject), "PROJECT.md is available to worktree-bound units");
+    assert.equal(readFileSync(projectedProject, "utf-8"), projectContent);
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-ROADMAP.md")),
+      "milestone artifacts still project into the worktree",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 // ─── projectWorktreeToRoot — Module contract ────────────────────────────────
 
 test("projectWorktreeToRoot exists and accepts a MilestoneScope", () => {

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -296,6 +296,11 @@ test('complete-slice closeout policy allows gsd_exec verification surface', () =
   assert.strictEqual(r.block, false);
 });
 
+test('complete-slice closeout policy allows MCP-scoped gsd_exec verification surface', () => {
+  const r = shouldBlockPlanningUnit('mcp__custom-workflow__gsd_exec', '', BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW);
+  assert.strictEqual(r.block, false);
+});
+
 test('planning-dispatch: still blocks writes to user source (write isolation preserved)', () => {
   const r = shouldBlockPlanningUnit('write', join(BASE, 'src', 'main.ts'), BASE, 'plan-slice', PLANNING_DISPATCH);
   assert.strictEqual(r.block, true);
@@ -329,6 +334,11 @@ test('planning-unit: allows gsd_* MCP tools (own validation)', () => {
   assert.strictEqual(r.block, false);
 });
 
+test('planning-unit: allows MCP-scoped gsd_* tools (own validation)', () => {
+  const r = shouldBlockPlanningUnit('mcp__custom-workflow__gsd_summary_save', '', BASE, 'discuss-milestone', PLANNING);
+  assert.strictEqual(r.block, false);
+});
+
 test('planning-unit: allows web research tools', () => {
   const r = shouldBlockPlanningUnit('search-the-web', '', BASE, 'research-milestone', PLANNING);
   assert.strictEqual(r.block, false);

package/src/resources/extensions/gsd/tests/zombie-gsd-state.test.ts

@@ -14,7 +14,7 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -79,3 +79,47 @@ test("#2942: injected existsFn — milestones/ alone is enough", () => {
     p === "/proj/.gsd" || p === "/proj/.gsd/milestones";
   assert.equal(hasGsdBootstrapArtifacts("/proj/.gsd", existsFn), true);
 });
+
+test("bare /gsd routes zombie .gsd folders to project init before closeout/db checks", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-zombie-bare-command-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  try {
+    process.chdir(base);
+    process.env.GSD_HOME = join(base, ".test-gsd-home");
+    delete process.env.GSD_PROJECT_ROOT;
+
+    const notifications: string[] = [];
+    const ctx = {
+      hasUI: false,
+      ui: {
+        notify: (content: unknown) => notifications.push(String(content)),
+        setStatus: () => {},
+        setWidget: () => {},
+      },
+    };
+    const { handleAutoCommand } = await import("../commands/handlers/auto.ts");
+
+    await handleAutoCommand("", ctx as any, {} as any);
+
+    assert.ok(
+      notifications.some((message) => message.includes("/gsd init did not start")),
+      "bare /gsd should route unbootstrapped zombie folders to the init wizard",
+    );
+    assert.equal(
+      existsSync(join(base, ".gsd", "gsd.db")),
+      false,
+      "bare /gsd should not create the project DB before init has bootstrapped .gsd/",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+  }
+});

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -173,6 +173,15 @@ export async function handleCompleteTask(
   if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
     return { error: "milestoneId is required and must be a non-empty string" };
   }
+  if (!params.oneLiner || typeof params.oneLiner !== "string" || params.oneLiner.trim() === "") {
+    return { error: "oneLiner is required and must be a non-empty string" };
+  }
+  if (!params.narrative || typeof params.narrative !== "string" || params.narrative.trim() === "") {
+    return { error: "narrative is required and must be a non-empty string" };
+  }
+  if (!params.verification || typeof params.verification !== "string" || params.verification.trim() === "") {
+    return { error: "verification is required and must be a non-empty string" };
+  }
 
   const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
 

package/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -14,8 +14,11 @@ import { isContextModeEnabled, type ContextModeConfig } from "../preferences-typ
 import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecToolParams {
-  runtime: ExecSandboxRequest["runtime"];
-  script: string;
+  runtime?: unknown;
+  script?: unknown;
+  command?: unknown;
+  cmd?: unknown;
+  code?: unknown;
   purpose?: string;
   timeout_ms?: number;
 }
@@ -80,6 +83,39 @@ function paramError(message: string): ToolExecutionResult {
   };
 }
 
+function normalizeRuntime(value: unknown): ExecSandboxRequest["runtime"] | ToolExecutionResult {
+  if (value === undefined || value === null || value === "") return "bash";
+  if (typeof value !== "string") {
+    return paramError(`invalid runtime "${String(value)}" — must be bash | node | python`);
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "" || normalized === "bash" || normalized === "sh" || normalized === "shell") return "bash";
+  if (normalized === "node" || normalized === "nodejs" || normalized === "js" || normalized === "javascript") return "node";
+  if (normalized === "python" || normalized === "python3" || normalized === "py") return "python";
+  return paramError(`invalid runtime "${value}" — must be bash | node | python`);
+}
+
+function normalizeScript(params: ExecToolParams): string | ToolExecutionResult {
+  const candidates = [params.script, params.command, params.cmd, params.code];
+  let sawNonString = false;
+  for (const candidate of candidates) {
+    if (candidate === undefined || candidate === null) continue;
+    if (typeof candidate !== "string") {
+      sawNonString = true;
+      continue;
+    }
+    if (candidate.trim().length > 0) return candidate;
+  }
+  if (sawNonString) {
+    return paramError("script/command must be a non-empty string");
+  }
+  return paramError("script is required and must be a non-empty string");
+}
+
+function isToolExecutionResult(value: unknown): value is ToolExecutionResult {
+  return typeof value === "object" && value !== null && Array.isArray((value as { content?: unknown }).content);
+}
+
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -201,14 +237,10 @@ export async function executeGsdExec(
 ): Promise<ToolExecutionResult> {
   if (!isEnabled(deps.preferences)) return contextModeDisabledResult("gsd_exec");
 
-  const runtime = params.runtime;
-  if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
-    return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
-  }
-  const script = typeof params.script === "string" ? params.script : "";
-  if (script.trim().length === 0) {
-    return paramError("script is required and must be a non-empty string");
-  }
+  const runtime = normalizeRuntime(params.runtime);
+  if (isToolExecutionResult(runtime)) return runtime;
+  const script = normalizeScript(params);
+  if (isToolExecutionResult(script)) return script;
   if (Buffer.byteLength(script, "utf8") > 200_000) {
     return paramError("script exceeds the 200 KB length limit");
   }

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -15,8 +15,10 @@ import {
 } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
+import { join } from "node:path";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
@@ -96,6 +98,28 @@ function registerProjectMilestoneSequence(content: string): string[] {
   return registered;
 }
 
+async function mirrorArtifactToActiveWorktreeProjection(
+  basePath: string,
+  relativePath: string,
+  content: string,
+): Promise<void> {
+  const contract = resolveGsdPathContract(basePath);
+  if (!contract.worktreeGsd) return;
+  if (contract.worktreeGsd === contract.projectGsd) return;
+
+  const fullPath = join(contract.worktreeGsd, relativePath);
+  try {
+    await saveFile(fullPath, content);
+    clearPathCache();
+    clearParseCache();
+    invalidateStateCache();
+  } catch (err) {
+    logWarning("tool", `gsd_summary_save worktree projection mirror failed: ${(err as Error).message}`, {
+      path: relativePath,
+    });
+  }
+}
+
 export async function executeSummarySave(
   params: SummarySaveParams,
   basePath: string = process.cwd(),
@@ -197,6 +221,7 @@ export async function executeSummarySave(
       },
       basePath,
     );
+    await mirrorArtifactToActiveWorktreeProjection(basePath, relativePath, contentToSave);
 
     let registeredMilestones: string[] = [];
     if (params.artifact_type === "PROJECT") {
@@ -306,7 +331,7 @@ export interface TaskCompleteParams {
   milestoneId: string;
   oneLiner: string;
   narrative: string;
-  verification: string;
+  verification?: string;
   deviations?: string;
   knownIssues?: string;
   keyFiles?: string[];
@@ -315,6 +340,40 @@ export interface TaskCompleteParams {
   verificationEvidence?: VerificationEvidenceInput[];
 }
 
+type NormalizedVerificationEvidence = {
+  command: string;
+  exitCode: number;
+  verdict: string;
+  durationMs: number;
+};
+
+function normalizeVerificationEvidence(
+  evidence: VerificationEvidenceInput[] | undefined,
+): NormalizedVerificationEvidence[] {
+  return (evidence ?? []).map((entry) =>
+    typeof entry === "string"
+      ? { command: entry, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 }
+      : entry,
+  );
+}
+
+function deriveVerificationSummary(
+  evidence: NormalizedVerificationEvidence[],
+): string | null {
+  if (evidence.length === 0) return null;
+
+  const rendered = evidence.slice(0, 3).map((entry) => {
+    const command = entry.command.trim() || "(unspecified command)";
+    const verdict = entry.verdict.trim() || "recorded";
+    return `\`${command}\` exited ${entry.exitCode} (${verdict})`;
+  });
+  const suffix = evidence.length > rendered.length
+    ? `; ${evidence.length - rendered.length} more check(s) recorded`
+    : "";
+
+  return `Verification evidence recorded: ${rendered.join("; ")}${suffix}.`;
+}
+
 export type CompleteMilestoneExecutorParams = Partial<CompleteMilestoneParams> & Record<string, unknown>;
 export type SliceCompleteExecutorParams = CompleteSliceParams;
 export type PlanMilestoneExecutorParams = PlanMilestoneParams;
@@ -350,9 +409,27 @@ export async function executeTaskComplete(
   }
   try {
     const coerced = { ...params };
-    coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) =>
-      typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v,
-    );
+    const verificationEvidence = normalizeVerificationEvidence(params.verificationEvidence);
+    coerced.verificationEvidence = verificationEvidence;
+
+    const verification = typeof params.verification === "string" ? params.verification.trim() : "";
+    if (verification.length === 0) {
+      const derived = deriveVerificationSummary(verificationEvidence);
+      if (derived) {
+        coerced.verification = derived;
+      } else if (params.blockerDiscovered === true) {
+        coerced.verification = "Not run: blocker discovered before verification.";
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: "Error completing task: verification is required unless verificationEvidence is provided or blockerDiscovered is true.",
+          }],
+          details: { operation: "complete_task", error: "verification_required" },
+          isError: true,
+        };
+      }
+    }
 
     const result = await handleCompleteTask(coerced as any, basePath);
     if ("error" in result) {

package/src/resources/extensions/gsd/tui/render-kit.ts

@@ -151,3 +151,85 @@ export function renderFrame(
   lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
   return lines.map((line) => safeLine(line, width, ""));
 }
+
+export interface DialogFrameOptions {
+  borderColor?: string;
+  paddingX?: number;
+  footer?: string | string[];
+  scroll?: {
+    offset: number;
+    visibleRows: number;
+    totalRows: number;
+    trackOffset?: number;
+    trackRows?: number;
+  };
+}
+
+function renderTitledTopBorder(
+  theme: ThemeLike,
+  title: string,
+  width: number,
+  border: (text: string) => string,
+): string {
+  const trimmedTitle = title.trim();
+  if (!trimmedTitle || width < 10) {
+    return border("╭" + "─".repeat(width - 2) + "╮");
+  }
+
+  const maxTitleWidth = Math.max(0, width - 7);
+  const safeTitle = safeLine(trimmedTitle, maxTitleWidth);
+  const fill = Math.max(0, width - visibleWidth(safeTitle) - 5);
+  return border("╭─ ") + theme.bold(theme.fg("accent", safeTitle)) + border(" " + "─".repeat(fill) + "╮");
+}
+
+export function renderDialogFrame(
+  theme: ThemeLike,
+  title: string,
+  inner: string[],
+  width: number,
+  options: DialogFrameOptions = {},
+): string[] {
+  if (width < 4) return inner.map((line) => safeLine(line, width));
+
+  const borderColor = options.borderColor ?? "borderAccent";
+  const paddingX = Math.max(0, options.paddingX ?? 1);
+  const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+  const border = (text: string) => theme.fg(borderColor, text);
+  const pad = " ".repeat(paddingX);
+  const lines = [renderTitledTopBorder(theme, title, width, border)];
+
+  const scroll = options.scroll;
+  const bodyRows = inner.length;
+  const trackOffset = Math.max(0, Math.min(scroll?.trackOffset ?? 0, bodyRows));
+  const trackRows = Math.max(0, Math.min(scroll?.trackRows ?? bodyRows, bodyRows - trackOffset));
+  const scrollable = !!scroll && scroll.totalRows > scroll.visibleRows && trackRows > 0;
+  const thumbLen = scrollable
+    ? Math.max(1, Math.round((scroll.visibleRows / scroll.totalRows) * trackRows))
+    : 0;
+  const maxThumbStart = Math.max(0, trackRows - thumbLen);
+  const maxScrollOffset = scrollable ? Math.max(1, scroll.totalRows - scroll.visibleRows) : 1;
+  const thumbStart = scrollable
+    ? trackOffset + Math.min(maxThumbStart, Math.round((scroll.offset / maxScrollOffset) * maxThumbStart))
+    : -1;
+
+  for (let i = 0; i < inner.length; i++) {
+    const line = inner[i] ?? "";
+    const rightBorder = scrollable && i >= thumbStart && i < thumbStart + thumbLen ? "┃" : "│";
+    lines.push(border("│") + pad + padRightVisible(line, contentWidth) + pad + border(rightBorder));
+  }
+
+  const footer = Array.isArray(options.footer)
+    ? options.footer
+    : options.footer
+      ? [options.footer]
+      : [];
+  if (footer.length > 0) {
+    lines.push(border("├" + "─".repeat(width - 2) + "┤"));
+    for (const line of footer) {
+      lines.push(border("│") + pad + padRightVisible(line, contentWidth) + pad + border("│"));
+    }
+  }
+
+  lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+  return lines.map((line) => safeLine(line, width, ""));
+}