@opengsd/gsd-pi 1.9.0 → 1.10.0

package/src/resources/extensions/gsd/tools/reopen-milestone.ts

@@ -22,7 +22,15 @@ import { logWarning } from "../workflow-logger.js";
 import { debugLog } from "../debug-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, clearPathCache } from "../paths.js";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveSlicePath,
+  resolveTasksDir,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenMilestoneParams {
   milestoneId: string;
@@ -69,6 +77,10 @@ export async function handleReopenMilestone(
   // auto-corrects entities back to "complete", making reopen a no-op (#3161).
   try {
     const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = !!milestoneDir && (
+      milestoneDir.startsWith(legacyBase + "/") || milestoneDir.startsWith(legacyBase + "\\")
+    );
     if (milestoneDir) {
       const milestoneSummary = join(milestoneDir, `${params.milestoneId}-SUMMARY.md`);
       if (existsSync(milestoneSummary)) unlinkSync(milestoneSummary);
@@ -85,10 +97,17 @@ export async function handleReopenMilestone(
       }
 
       const tasksDir = resolveTasksDir(basePath, params.milestoneId, slice.id);
-      if (tasksDir) {
-        const tasks = getSliceTasks(params.milestoneId, slice.id);
-        for (const task of tasks) {
-          const taskSummary = join(tasksDir, `${task.id}-SUMMARY.md`);
+      const tasks = getSliceTasks(params.milestoneId, slice.id);
+      for (const task of tasks) {
+        const taskSummaries = isLegacy
+          ? (tasksDir ? [join(tasksDir, buildTaskFileName(task.id, "SUMMARY"))] : [])
+          : milestoneDir
+            ? [
+              join(milestoneDir, buildFlatTaskFileName(slice.id, task.id, "SUMMARY")),
+              join(milestoneDir, buildTaskFileName(task.id, "SUMMARY")),
+            ]
+            : [];
+        for (const taskSummary of taskSummaries) {
           if (existsSync(taskSummary)) unlinkSync(taskSummary);
         }
       }

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -27,7 +27,15 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveTasksDir,
+  resolveSlicePath,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenSliceParams {
   milestoneId: string;
@@ -80,11 +88,23 @@ export async function handleReopenSlice(
   // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
   // auto-corrects tasks back to "complete", making reopen a no-op (#3161).
   try {
+    const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = !!milestoneDir && (
+      milestoneDir.startsWith(legacyBase + "/") || milestoneDir.startsWith(legacyBase + "\\")
+    );
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-    if (tasksDir) {
-      const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-      for (const task of tasks) {
-        const summaryPath = join(tasksDir, `${task.id}-SUMMARY.md`);
+    const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+    for (const task of tasks) {
+      const summaryPaths = isLegacy
+        ? (tasksDir ? [join(tasksDir, buildTaskFileName(task.id, "SUMMARY"))] : [])
+        : milestoneDir
+          ? [
+            join(milestoneDir, buildFlatTaskFileName(params.sliceId, task.id, "SUMMARY")),
+            join(milestoneDir, buildTaskFileName(task.id, "SUMMARY")),
+          ]
+          : [];
+      for (const summaryPath of summaryPaths) {
         if (existsSync(summaryPath)) unlinkSync(summaryPath);
       }
     }

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

@@ -25,8 +25,16 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { writeReopenReason } from "../reopen-reason.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
+import { join } from "node:path";
+import {
+  buildFlatTaskFileName,
+  buildTaskFileName,
+  legacyMilestonesDir,
+  resolveMilestonePath,
+  resolveTasksDir,
+  resolveSlicePath,
+  clearPathCache,
+} from "../paths.js";
 
 export interface ReopenTaskParams {
   milestoneId: string;
@@ -113,13 +121,19 @@ export async function handleReopenTask(
   // summary cleanup into tasks/ (#1208).
   try {
     const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
-    if (slicePath) {
-      const isLegacySlice = basename(dirname(slicePath)) === "slices";
-      const summaryDir = isLegacySlice
-        ? (resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath)
-        : slicePath;
-      const summaryPath = join(summaryDir, `${params.taskId}-SUMMARY.md`);
-      if (existsSync(summaryPath)) unlinkSync(summaryPath);
+    const milestonePath = resolveMilestonePath(basePath, params.milestoneId);
+    if (milestonePath) {
+      const legacyBase = legacyMilestonesDir(basePath);
+      const isLegacy = milestonePath.startsWith(legacyBase + "/") || milestonePath.startsWith(legacyBase + "\\");
+      const summaryPaths = isLegacy
+        ? [join(resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath ?? join(milestonePath, "slices", params.sliceId, "tasks"), buildTaskFileName(params.taskId, "SUMMARY"))]
+        : [
+          join(milestonePath, buildFlatTaskFileName(params.sliceId, params.taskId, "SUMMARY")),
+          join(milestonePath, buildTaskFileName(params.taskId, "SUMMARY")),
+        ];
+      for (const summaryPath of summaryPaths) {
+        if (existsSync(summaryPath)) unlinkSync(summaryPath);
+      }
     }
   } catch (cleanupErr) {
     logWarning("tool", `reopen-task artifact cleanup warning: ${(cleanupErr as Error).message}`);

package/src/resources/extensions/gsd/unit-context-composer.ts

@@ -46,6 +46,7 @@ import {
   type ToolsPolicy,
   type UnitContextManifest,
 } from "./unit-context-manifest.js";
+import { resolveEffectivePlanningToolsPolicy } from "./planning-subagent-policy.js";
 import { getUnitToolSurfaceContract } from "./unit-tool-contracts.js";
 import type { UnitPromptContextContract } from "./tool-contract.js";
 
@@ -207,6 +208,7 @@ export function composeContextModeInstructions(
 
 export interface ComposeToolSurfaceInstructionOptions {
   readonly renderMode: ContextModeRenderMode;
+  readonly basePath?: string;
 }
 
 const TOOL_SURFACE_GUIDANCE_BY_UNIT: Record<string, string> = {
@@ -226,16 +228,39 @@ const TOOL_SURFACE_GUIDANCE_BY_UNIT: Record<string, string> = {
     "Persist completion only through `gsd_complete_milestone` after verification passes. Do not query `.gsd/gsd.db` directly. Do not write `.gsd/PROJECT.md` or `.gsd/REQUIREMENTS.md` by hand — use `gsd_summary_save` and `gsd_requirement_update`.",
   "replan-slice":
     "Persist replans through `gsd_replan_slice` only. Do not edit `PLAN.md` or task plans directly.",
-  "plan-slice":
-    "Persist planning through `gsd_plan_slice` only. Dispatch subagents only to **scout** or **planner** for reconnaissance — not implementation agents. Do not edit user source files outside `.gsd/**`.",
-  "refine-slice":
-    "Persist refinements through `gsd_plan_slice` only. Dispatch subagents only to **scout** or **planner**. Do not edit user source files outside `.gsd/**`.",
-  "plan-milestone":
-    "Persist milestone planning through `gsd_plan_milestone` / `gsd_plan_slice`. Do not edit user source files outside `.gsd/**`.",
   "research-slice":
     "Dispatch subagents only to **scout** or **planner** for reconnaissance. Do not edit user source files outside `.gsd/**`.",
 };
 
+function formatAllowedAgents(agents: readonly string[]): string {
+  return agents.map((agent) => `**${agent}**`).join(", ");
+}
+
+function guidanceForUnitToolsPolicy(unitType: string, policy: ToolsPolicy): string | undefined {
+  if (unitType === "plan-slice") {
+    const dispatch = policy.mode === "planning-dispatch"
+      ? ` Dispatch subagents only to ${formatAllowedAgents(policy.allowedSubagents)} for reconnaissance — not implementation agents.`
+      : " Do not dispatch subagents.";
+    return `Persist planning through \`gsd_plan_slice\` only.${dispatch} Do not edit user source files outside \`.gsd/**\`.`;
+  }
+
+  if (unitType === "refine-slice") {
+    const dispatch = policy.mode === "planning-dispatch"
+      ? ` Dispatch subagents only to ${formatAllowedAgents(policy.allowedSubagents)}.`
+      : " Do not dispatch subagents.";
+    return `Persist refinements through \`gsd_plan_slice\` only.${dispatch} Do not edit user source files outside \`.gsd/**\`.`;
+  }
+
+  if (unitType === "plan-milestone") {
+    const dispatch = policy.mode === "planning-dispatch"
+      ? ` Dispatch subagents only to ${formatAllowedAgents(policy.allowedSubagents)}.`
+      : "";
+    return `Persist milestone planning through \`gsd_plan_milestone\` / \`gsd_plan_slice\`.${dispatch} Do not edit user source files outside \`.gsd/**\`.`;
+  }
+
+  return undefined;
+}
+
 function guidanceForToolsPolicy(policy: ToolsPolicy): string | null {
   switch (policy.mode) {
     case "planning":
@@ -280,8 +305,9 @@ export function composeToolSurfaceInstructions(
   const manifest = resolveManifest(unitType);
   if (!manifest) return "";
 
-  const unitGuidance = TOOL_SURFACE_GUIDANCE_BY_UNIT[unitType];
-  const policyGuidance = unitGuidance ? null : guidanceForToolsPolicy(manifest.tools);
+  const effectiveTools = resolveEffectivePlanningToolsPolicy(unitType, manifest.tools, opts.basePath) ?? manifest.tools;
+  const unitGuidance = guidanceForUnitToolsPolicy(unitType, effectiveTools) ?? TOOL_SURFACE_GUIDANCE_BY_UNIT[unitType];
+  const policyGuidance = unitGuidance ? null : guidanceForToolsPolicy(effectiveTools);
   const forbiddenLine = formatForbiddenWorkflowToolsLine(unitType, unitGuidance);
   const parts = [unitGuidance, policyGuidance, forbiddenLine].filter(
     (part): part is string => typeof part === "string" && part.length > 0,

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -26,7 +26,7 @@ import { deriveState } from "./state.js";
 import type { GSDState } from "./types.js";
 import { renderPlanFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { readManifest } from "./workflow-manifest.js";
-import { gsdRoot, resolveMilestoneFile, resolveSliceFile, resolveTaskFile, relTaskFile } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveSliceFile, resolveTaskFile, targetTaskFile } from "./paths.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────
 
@@ -329,8 +329,7 @@ export function renderSummaryProjection(basePath: string, milestoneId: string, s
   const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
   const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
 
-  const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY")
-    ?? join(basePath, relTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title));
+  const summaryPath = targetTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title);
   mkdirSync(dirname(summaryPath), { recursive: true });
   atomicWriteSync(summaryPath, content);
 }

package/src/resources/extensions/gsd/workspace.ts

@@ -10,6 +10,7 @@ import {
   normalizeRealPath,
 } from "./paths.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { milestoneMetaPath } from "./git-service.js";
 
 export type GsdWorkspaceMode = "project" | "worktree";
 
@@ -107,7 +108,7 @@ export function scopeMilestone(workspace: GsdWorkspace, milestoneId: string): Mi
     stateFile: () => join(gsd, "STATE.md"),
     dbPath: () => contract.projectDb,
     milestoneDir: () => scopeMilestoneDir(basePath, milestoneId),
-    metaJson: () => join(gsd, `${milestoneId}-META.json`),
+    metaJson: () => milestoneMetaPath(basePath, milestoneId),
   });
 
   return scope;

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

@@ -32,7 +32,7 @@ import {
 import { join } from "node:path";
 
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import type { MilestoneScope } from "./workspace.js";
 import { logError, logWarning } from "./workflow-logger.js";
@@ -161,6 +161,7 @@ function syncOtherMilestoneArtifacts(
       // additive safeCopyRecursive; skip it here to avoid redundant work.
       if (milestoneEntry.name === currentMilestoneId) continue;
       const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+      if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir)) continue;
       const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
 
       // Additively project the entire milestone subtree (force:false), not just
@@ -271,36 +272,32 @@ export function _projectRootToWorktreeImpl(
   // Without this, worktree-local files (e.g. VALIDATION.md written
   // by validate-milestone) get clobbered by stale project root copies,
   // causing an infinite re-validation loop (#1886).
-  safeCopyRecursive(
-    join(prGsd, "milestones", milestoneId),
-    join(wtGsd, "milestones", milestoneId),
-    { force: false },
-  );
+  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
+  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+  if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
+    safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
+
+    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+    // The additive-only copy above preserves worktree-local files, but
+    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+    // syncs it to the project root, the worktree may retain a stale copy (e.g.
+    // verdict:fail while the project root has verdict:pass from a retry). On
+    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+    // run-uat indefinitely (stuck-loop ×9).
+    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+  }
 
-  // Additively project the full subtree of every OTHER milestone so
-  // worktree-bound units can read prior-milestone context artifacts and so
-  // completed milestones retain their per-slice/per-task SUMMARY.md and
-  // UAT.md on the worktree filesystem (otherwise the stale-render detector
-  // flags them as "complete in DB but missing on disk").
+  // Additively project the full subtree of every OTHER content-bearing legacy
+  // milestone so worktree-bound units can read prior-milestone context artifacts
+  // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
   syncOtherMilestoneArtifacts(
     join(prGsd, "milestones"),
     join(wtGsd, "milestones"),
     milestoneId,
   );
 
-  // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-  // The additive-only copy above preserves worktree-local files, but
-  // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-  // syncs it to the project root, the worktree may retain a stale copy (e.g.
-  // verdict:fail while the project root has verdict:pass from a retry). On
-  // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-  // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-  // run-uat indefinitely (stuck-loop ×9).
-  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
-  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-  forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-  forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
-
   // Forward-sync completed-units.json from project root to worktree.
   // Project root is authoritative for completion state after crash recovery;
   // without this, the worktree re-dispatches already-completed units (#1886).

package/src/resources/extensions/shared/interview-ui.ts

@@ -252,6 +252,11 @@ export async function showInterviewRound(
 		let previewTotal = 0;
 		function resetPreviewScroll() { previewScroll = 0; }
 
+		let optionsScroll = 0;
+		let optionsViewport = 0;
+		let optionsTotal = 0;
+		function resetOptionsScroll() { optionsScroll = 0; }
+
 		function finish(result: RoundResult) {
 			if (completed) return;
 			completed = true;
@@ -318,6 +323,7 @@ export async function showInterviewRound(
 			saveEditorToState();
 			currentIdx = newIdx;
 			resetPreviewScroll();
+			resetOptionsScroll();
 			loadStateToEditor();
 			focusNotes = states[currentIdx].notesVisible && states[currentIdx].notes.length > 0;
 			refresh();
@@ -464,20 +470,39 @@ export async function showInterviewRound(
 				if (matchesKey(data, Key.right)) { switchQuestion((currentIdx + 1) % questions.length); return; }
 			}
 
-			// ── Preview scrolling ────────────────────────────────────────
+			// ── Side-by-side panel scrolling ─────────────────────────────
 			if (matchesKey(data, Key.pageUp)) {
-				if (previewScroll > 0) { previewScroll = Math.max(0, previewScroll - previewViewport); refresh(); }
+				let didScroll = false;
+				if (optionsScroll > 0) {
+					optionsScroll = Math.max(0, optionsScroll - optionsViewport);
+					didScroll = true;
+				}
+				if (previewScroll > 0) {
+					previewScroll = Math.max(0, previewScroll - previewViewport);
+					didScroll = true;
+				}
+				if (didScroll) refresh();
 				return;
 			}
 			if (matchesKey(data, Key.pageDown)) {
+				let didScroll = false;
+				const maxOptionsScroll = Math.max(0, optionsTotal - optionsViewport);
+				if (optionsScroll < maxOptionsScroll) {
+					optionsScroll = Math.min(maxOptionsScroll, optionsScroll + optionsViewport);
+					didScroll = true;
+				}
 				const maxScroll = Math.max(0, previewTotal - previewViewport);
-				if (previewScroll < maxScroll) { previewScroll = Math.min(maxScroll, previewScroll + previewViewport); refresh(); }
+				if (previewScroll < maxScroll) {
+					previewScroll = Math.min(maxScroll, previewScroll + previewViewport);
+					didScroll = true;
+				}
+				if (didScroll) refresh();
 				return;
 			}
 
 			// ── Cursor navigation ────────────────────────────────────────
-			if (matchesKey(data, Key.up)) { st.cursorIndex = (st.cursorIndex - 1 + optCount) % optCount; resetPreviewScroll(); refresh(); return; }
-			if (matchesKey(data, Key.down)) { st.cursorIndex = (st.cursorIndex + 1) % optCount; resetPreviewScroll(); refresh(); return; }
+			if (matchesKey(data, Key.up)) { st.cursorIndex = (st.cursorIndex - 1 + optCount) % optCount; resetPreviewScroll(); resetOptionsScroll(); refresh(); return; }
+			if (matchesKey(data, Key.down)) { st.cursorIndex = (st.cursorIndex + 1) % optCount; resetPreviewScroll(); resetOptionsScroll(); refresh(); return; }
 
 			if (multiSel) {
 				const doneI = noneOrDoneIdx(currentIdx);
@@ -695,6 +720,8 @@ export async function showInterviewRound(
 			// No scrollable preview unless the side-by-side path sets these below.
 			previewTotal = 0;
 			previewViewport = 0;
+			optionsTotal = 0;
+			optionsViewport = 0;
 
 			if (useSideBySide) {
 				// ── Preview path ──────────────────────────────────────
@@ -734,10 +761,21 @@ export async function showInterviewRound(
 				const leftWidth = Math.max(MIN_OPTIONS_WIDTH, contentWidth - previewWidth - DIVIDER_WIDTH);
 
 				const fullLeft = renderOptionsColumn(leftWidth);
-				const leftLines = fullLeft.slice(0, maxBody);
+				optionsTotal = fullLeft.length;
+				optionsViewport = maxBody;
+				const maxOptionsScroll = Math.max(0, fullLeft.length - maxBody);
+				if (optionsScroll > maxOptionsScroll) optionsScroll = maxOptionsScroll;
+
+				const leftLines = fullLeft.slice(optionsScroll, optionsScroll + maxBody);
 				if (fullLeft.length > maxBody) {
-					const n = fullLeft.length - maxBody + 1;
-					leftLines[maxBody - 1] = scrollIndicator(`+${n} lines hidden`, leftWidth);
+					const hiddenAbove = optionsScroll;
+					const hiddenBelow = fullLeft.length - (optionsScroll + maxBody);
+					if (hiddenAbove > 0) {
+						leftLines[0] = scrollIndicator(`▲ ${hiddenAbove} more`, leftWidth);
+					}
+					if (hiddenBelow > 0) {
+						leftLines[leftLines.length - 1] = scrollIndicator(`▼ ${hiddenBelow} more · PgUp/PgDn`, leftWidth);
+					}
 				}
 
 				const preview = getCurrentPreview();
@@ -791,6 +829,7 @@ export async function showInterviewRound(
 					hints.push(isLast && allAnswered() ? "enter to review" : "enter to next");
 				}
 				if (previewTotal > previewViewport) hints.push("pgup/pgdn scroll preview");
+				if (optionsTotal > optionsViewport) hints.push("pgup/pgdn scroll options");
 				hints.push("esc to exit");
 				const footer = ui.hints(hints)[0] ?? "";
 

package/src/resources/extensions/shared/tests/interview-ui-border.test.ts

@@ -192,4 +192,33 @@ describe("interview-ui dialog borders", () => {
 		const back = stripAnsi(widget.render(100).join("\n"));
 		assert.doesNotMatch(back, /▲ \d+ more/, "top indicator should disappear after scrolling back to top");
 	});
+
+	it("makes overflowing side-by-side options scrollable with PgUp/PgDn", async () => {
+		const overflowOptions = Array.from({ length: 8 }, (_, i) => ({
+			label: `Overflow Option ${i + 1}`,
+			description: `Detailed explanation for option ${i + 1} that is intentionally long enough to wrap in the options column and force vertical overflow.`,
+			...(i === 0 ? { preview: "Short preview" } : {}),
+		}));
+		const widget = await captureInterviewWidget([{
+			...questions[0],
+			options: overflowOptions,
+		}]);
+
+		const initial = stripAnsi(widget.render(100).join("\n"));
+		assertFullOuterBorder(widget.render(100), 100);
+		assert.match(initial, /▼ \d+ more/, "bottom scroll indicator should appear when options overflow");
+		assert.match(initial, /pgup\/pgdn scroll options/, "footer should hint at options scrolling");
+		assert.doesNotMatch(initial, /\+\d+ lines hidden/, "options overflow should not be a dead-end hidden-lines marker");
+		assert.doesNotMatch(initial, /▲ \d+ more/, "top indicator should be absent before scrolling");
+
+		widget.handleInput(PAGE_DOWN);
+		const scrolled = stripAnsi(widget.render(100).join("\n"));
+		assertFullOuterBorder(widget.render(100), 100);
+		assert.match(scrolled, /▲ \d+ more/, "top scroll indicator should appear after scrolling down");
+		assert.ok(scrolled !== initial, "scrolling should change the rendered options");
+
+		widget.handleInput(PAGE_UP);
+		const back = stripAnsi(widget.render(100).join("\n"));
+		assert.doesNotMatch(back, /▲ \d+ more/, "top indicator should disappear after scrolling back to top");
+	});
 });