@garygentry/feature-forge 0.2.14 → 0.3.1

package/adapters/pi/extensions/ask-user-question/view/dialog-builder.ts

@@ -0,0 +1,224 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/dialog-builder.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import { DynamicBorder, type Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Container, type Input, Spacer } from "@earendil-works/pi-tui";
+import type { QuestionnaireState } from "../state/state.js";
+import type { QuestionData } from "../tool/types.js";
+import type { PreviewPaneProps } from "./components/preview/preview-pane.js";
+import type { TabBar } from "./components/tab-bar.js";
+import type { StatefulView } from "./stateful-view.js";
+import type { TabComponents } from "./tab-components.js";
+import { QuestionTabStrategy, SubmitTabStrategy, type TabContentStrategy } from "./tab-content-strategy.js";
+
+export const HINT_PART_ENTER = "Enter to select";
+export const HINT_PART_NAV = "↑/↓ to navigate";
+export const HINT_PART_TOGGLE = "Space to toggle";
+export const HINT_PART_NOTES = "n to add notes";
+export const HINT_PART_TAB = "Tab to switch questions";
+export const HINT_PART_CANCEL = "Esc to cancel";
+export const HINT_PART_COLLAPSE = "Ctrl+] to collapse";
+export const HINT_PART_EXPAND = "Ctrl+] to expand";
+/**
+ * `HINT_SINGLE` / `HINT_MULTI` are the resting core hint for NON-multiSelect
+ * question tabs only: `buildHintText` drops `NOTES` while the notes editor is
+ * open (`state.notesVisible`) or the "Type something." row is capturing text
+ * (`state.inputMode`), and on multiSelect tabs it interleaves `TOGGLE` between
+ * `NAV` and `NOTES`, so neither composite is a substring there — assert on
+ * `HINT_PART_*` constants in those states instead. The collapse affordance is
+ * appended AFTER cancel by `buildHintText` so the resting core stays a contiguous
+ * prefix substring of the rendered line. On narrow terminals the collapse tail
+ * clips with `…` (`OneLineClippedText`); the core is preserved.
+ */
+export const HINT_SINGLE = [HINT_PART_ENTER, HINT_PART_NAV, HINT_PART_NOTES, HINT_PART_CANCEL].join(" · ");
+export const HINT_MULTI = [HINT_PART_ENTER, HINT_PART_NAV, HINT_PART_NOTES, HINT_PART_TAB, HINT_PART_CANCEL].join(
+	" · ",
+);
+/** Single-line footer shown by `QuestionnaireSession` when `state.collapsed === true`. Bypasses `buildHintText`. */
+export const COLLAPSED_HINT = [HINT_PART_EXPAND, HINT_PART_CANCEL].join(" · ");
+export const REVIEW_HEADING = "Review your answers";
+export const READY_PROMPT = "Ready to submit your answers?";
+export const INCOMPLETE_WARNING_PREFIX = "⚠ Answer remaining questions before submitting:";
+
+const OVERFLOW_UP = "↑";
+const OVERFLOW_DOWN = "↓";
+const OVERFLOW_BOTH = "↕";
+
+export type DialogState = QuestionnaireState;
+
+/** Per-tick projection of dialog state. Written by the adapter; read by the strategy thunk. */
+export interface DialogProps {
+	state: DialogState;
+	activePreviewPane: StatefulView<PreviewPaneProps>;
+}
+
+/** Construction-time config for `DialogView`. Frozen after construction. */
+export interface DialogConfig {
+	theme: Theme;
+	questions: readonly QuestionData[];
+	tabBar: TabBar | undefined;
+	notesInput: Input;
+	isMulti: boolean;
+	tabsByIndex: ReadonlyArray<TabComponents>;
+	/** Optional so single-question mode and non-submit tests can omit it; SubmitTabStrategy falls back to Spacer rows. */
+	submitPicker?: Component;
+	/** Worst-case body height across all tabs/options. Determines the stable overall dialog footprint. */
+	getBodyHeight: (width: number) => number;
+	/** Body height of the CURRENTLY active tab/option. The chrome subtracts this from `getBodyHeight` to absorb the residual OUTSIDE the bordered region. */
+	getCurrentBodyHeight: (width: number) => number;
+	/** Terminal height getter. Mirrors `getTerminalWidth` — reads `tui.terminal.rows` at render time. */
+	getTerminalRows: () => number;
+}
+
+/**
+ * The 7th renderable, promoted from a structural literal to a named class so
+ * all view-layer components share one explicit `implements StatefulView<P>`
+ * contract. `setProps(DialogProps)` writes the live cell read by the
+ * strategy thunk during `render()`. `liveProps.activePreviewPane` is a
+ * resolved pane reference threaded by the adapter per tick — the dialog
+ * itself does not derive it.
+ */
+export class DialogView implements StatefulView<DialogProps> {
+	private liveProps: DialogProps;
+	private readonly config: DialogConfig;
+	private readonly questionStrategy: TabContentStrategy;
+	private readonly submitStrategy: TabContentStrategy | undefined;
+	private readonly maxFooterRowCount: number;
+
+	constructor(config: DialogConfig, initialProps: DialogProps) {
+		this.config = config;
+		this.liveProps = initialProps;
+		this.questionStrategy = new QuestionTabStrategy({
+			theme: config.theme,
+			questions: config.questions,
+			getPreviewPane: () => this.liveProps.activePreviewPane,
+			tabsByIndex: config.tabsByIndex,
+			notesInput: config.notesInput,
+			isMulti: config.isMulti,
+			getCurrentBodyHeight: config.getCurrentBodyHeight,
+		});
+		this.submitStrategy = config.isMulti
+			? new SubmitTabStrategy({
+					theme: config.theme,
+					questions: config.questions,
+					submitPicker: config.submitPicker,
+				})
+			: undefined;
+		this.maxFooterRowCount = Math.max(this.questionStrategy.footerRowCount, this.submitStrategy?.footerRowCount ?? 0);
+	}
+
+	setProps(props: DialogProps): void {
+		this.liveProps = props;
+	}
+
+	handleInput(_data: string): void {}
+
+	// Invalidation is driven by `QuestionnairePropsAdapter.invalidate()`, which
+	// owns the full set of renderables (binding registries + extras like
+	// `notesInput`). DialogView has no cached layout of its own.
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const state = this.liveProps.state;
+		const onSubmit = this.config.isMulti && state.currentTab === this.config.questions.length;
+		const strategy = onSubmit && this.submitStrategy ? this.submitStrategy : this.questionStrategy;
+
+		// Cache heading rows (avoid double construction in render and container build).
+		const headingRowCache = strategy.headingRows(state);
+		const headingCount = headingRowCache.length;
+
+		// Build container WITHOUT residual spacer — spacer handled below based on overflow.
+		const natural = this.buildContainerFromStrategy(strategy, headingRowCache).render(width);
+
+		// Fixed region sizes (deterministic from structure).
+		// TabBar.render() returns [tabLine, ""] — always 2 rows.
+		const topFixed = 1 + (this.config.isMulti && this.config.tabBar ? 2 : 0) + 1;
+		const bottomFixed = 1 + strategy.footerRowCount;
+		const middleRows = natural.length - topFixed - bottomFixed;
+
+		// Residual spacer: equalizes total height across tabs (only needed when no overflow).
+		const spacerRows = Math.max(
+			0,
+			this.config.getBodyHeight(width) +
+				this.maxFooterRowCount -
+				strategy.bodyHeight(width, state) -
+				strategy.footerRowCount,
+		);
+
+		const termRows = this.config.getTerminalRows();
+
+		if (natural.length + spacerRows <= termRows) {
+			// No overflow — add residual spacer rows after footer.
+			return spacerRows > 0 ? [...natural, ...Array<string>(spacerRows).fill("")] : natural;
+		}
+
+		// OVERFLOW — apply 3-region partition with scroll-to-focus.
+		const availableMiddle = Math.max(0, termRows - topFixed - bottomFixed);
+		if (availableMiddle === 0) {
+			// Terminal too small for any middle content — show just chrome.
+			const chromeOnly = [...natural.slice(0, topFixed), ...natural.slice(natural.length - bottomFixed)];
+			return chromeOnly.length > termRows ? chromeOnly.slice(0, termRows) : chromeOnly;
+		}
+
+		const bodyRange = strategy.focusedItemRowRange(width, state);
+
+		// Compute scroll window centered on the focused option.
+		let scrollStart: number;
+		if (bodyRange) {
+			const focusedRowInMiddle = headingCount + bodyRange[0];
+			const focusedHeight = bodyRange[1] - bodyRange[0];
+			// Center the focused item vertically in the available middle space.
+			const idealStart = focusedRowInMiddle - Math.floor(Math.max(0, availableMiddle - focusedHeight) / 2);
+			scrollStart = Math.max(0, Math.min(idealStart, middleRows - availableMiddle));
+		} else {
+			// No interactive focus (submit tab) — top-anchor the middle.
+			scrollStart = 0;
+		}
+
+		const scrollableMiddle = natural.slice(topFixed + scrollStart, topFixed + scrollStart + availableMiddle);
+
+		const hasUp = scrollStart > 0;
+		const hasDown = scrollStart + availableMiddle < middleRows;
+		if (hasUp && hasDown && scrollableMiddle.length === 1) {
+			// Single-row middle: combined ↕ avoids the prior collision where ↓ overwrote ↑.
+			scrollableMiddle[0] = this.config.theme.fg("dim", OVERFLOW_BOTH);
+		} else {
+			if (hasUp && scrollableMiddle.length > 0) {
+				scrollableMiddle[0] = this.config.theme.fg("dim", OVERFLOW_UP);
+			}
+			if (hasDown && scrollableMiddle.length > 0) {
+				scrollableMiddle[scrollableMiddle.length - 1] = this.config.theme.fg("dim", OVERFLOW_DOWN);
+			}
+		}
+
+		const result = [
+			...natural.slice(0, topFixed),
+			...scrollableMiddle,
+			...natural.slice(natural.length - bottomFixed),
+		];
+		// Safety: never exceed terminal rows (covers the availableMiddle === 0 case
+		// where topFixed + bottomFixed > termRows).
+		return result.length > termRows ? result.slice(0, termRows) : result;
+	}
+
+	private buildContainerFromStrategy(strategy: TabContentStrategy, headingRowCache: Component[]): Container {
+		const { theme, isMulti, tabBar } = this.config;
+		const state = this.liveProps.state;
+		const container = new Container();
+		const border = () => new DynamicBorder((s) => theme.fg("accent", s));
+
+		container.addChild(border());
+		if (isMulti && tabBar) container.addChild(tabBar);
+		container.addChild(new Spacer(1));
+
+		for (const c of headingRowCache) container.addChild(c);
+		container.addChild(strategy.bodyComponent(state));
+		container.addChild(new Spacer(1));
+		for (const c of strategy.midRows(state)) container.addChild(c);
+
+		container.addChild(border());
+		for (const c of strategy.footerRows(state)) container.addChild(c);
+
+		// BodyResidualSpacer moved out of Container — handled in render().
+		return container;
+	}
+}

package/adapters/pi/extensions/ask-user-question/view/props-adapter.ts

@@ -0,0 +1,125 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/props-adapter.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { Input } from "@earendil-works/pi-tui";
+import type { BindingContext, PerTabBindingContext } from "../state/selectors/contract.js";
+import { selectActivePreviewPaneIndex } from "../state/selectors/derivations.js";
+import { selectActiveView } from "../state/selectors/focus.js";
+import type { QuestionnaireState } from "../state/state.js";
+import type { QuestionData } from "../tool/types.js";
+import type { BoundGlobalBinding, BoundPerTabBinding } from "./component-binding.js";
+import type { WrappingSelectItem } from "./components/wrapping-select.js";
+import type { TabComponents } from "./tab-components.js";
+
+/** Cache-invalidation contract used by the adapter. `pi-tui` `Component` already satisfies it. */
+interface Invalidatable {
+	invalidate(): void;
+}
+
+/**
+ * Reads pi-tui Input's private `cursor` field via type escape with full runtime validation.
+ * Returns `undefined` on any failure → graceful degradation to end-of-buffer cursor.
+ * Follow-up: replace with Input.getCursorOffset() when pi-tui exposes a public API.
+ */
+function getInputCursorOffset(input: Input): number | undefined {
+	const raw = (input as unknown as { cursor?: unknown }).cursor;
+	if (typeof raw !== "number") return undefined;
+	if (!Number.isSafeInteger(raw)) return undefined;
+	const value = input.getValue();
+	if (raw < 0 || raw > value.length) return undefined;
+	return raw;
+}
+
+export interface QuestionnairePropsAdapterConfig {
+	tui: { requestRender(): void };
+	questions: readonly QuestionData[];
+	itemsByTab: ReadonlyArray<readonly WrappingSelectItem[]>;
+	tabsByIndex: ReadonlyArray<TabComponents>;
+	inlineInput: Input;
+	globalBindings: ReadonlyArray<BoundGlobalBinding>;
+	perTabBindings: ReadonlyArray<BoundPerTabBinding>;
+	/**
+	 * Renderables not reached by the binding registries (e.g. the notes
+	 * `Input`, which is typed into directly and has no props). Walked by
+	 * `invalidate()` after the binding-driven components.
+	 */
+	extraInvalidatables?: ReadonlyArray<Invalidatable>;
+}
+
+/**
+ * View fan-out: drives every component setter from the canonical state via
+ * two binding registries. `globalBindings` covers the cross-tab components
+ * (dialog, submitPicker?, tabBar?); `perTabBindings` covers the
+ * per-tab kinds (optionList, preview, multiSelect?). The hand-coded fan-out
+ * collapses to one global loop + one nested per-tab loop. The inline-Other
+ * value is read from the headless `inlineInput` instance per tick into ctx so
+ * `selectOptionListProps` sees the live value.
+ */
+export class QuestionnairePropsAdapter {
+	private readonly tui: QuestionnairePropsAdapterConfig["tui"];
+	private readonly questions: readonly QuestionData[];
+	private readonly itemsByTab: ReadonlyArray<readonly WrappingSelectItem[]>;
+	private readonly tabsByIndex: ReadonlyArray<TabComponents>;
+	private readonly inlineInput: Input;
+	private readonly globalBindings: ReadonlyArray<BoundGlobalBinding>;
+	private readonly perTabBindings: ReadonlyArray<BoundPerTabBinding>;
+	private readonly extraInvalidatables: ReadonlyArray<Invalidatable>;
+
+	constructor(config: QuestionnairePropsAdapterConfig) {
+		this.tui = config.tui;
+		this.questions = config.questions;
+		this.itemsByTab = config.itemsByTab;
+		this.tabsByIndex = config.tabsByIndex;
+		this.inlineInput = config.inlineInput;
+		this.globalBindings = config.globalBindings;
+		this.perTabBindings = config.perTabBindings;
+		this.extraInvalidatables = config.extraInvalidatables ?? [];
+	}
+
+	apply(state: QuestionnaireState): void {
+		const totalQuestions = this.questions.length;
+		const activeView = selectActiveView(state, totalQuestions);
+		const paneIndex = selectActivePreviewPaneIndex(state.currentTab, totalQuestions);
+		const activePreviewPane = this.tabsByIndex[paneIndex]?.preview ?? this.tabsByIndex[0]!.preview;
+
+		const ctx: BindingContext = {
+			questions: this.questions,
+			itemsByTab: this.itemsByTab,
+			totalQuestions,
+			activeView,
+			inputBuffer: this.inlineInput.getValue(),
+			inputCursorOffset: getInputCursorOffset(this.inlineInput),
+			activePreviewPane,
+		};
+
+		for (const binding of this.globalBindings) {
+			binding.apply(state, ctx);
+		}
+
+		for (let i = 0; i < this.tabsByIndex.length; i++) {
+			const tab = this.tabsByIndex[i]!;
+			const tabCtx: PerTabBindingContext = { ...ctx, tab, i };
+			for (const binding of this.perTabBindings) {
+				binding.apply(state, tabCtx);
+			}
+		}
+
+		this.tui.requestRender();
+	}
+
+	/**
+	 * Invalidates every owned renderable. Called by the session in place of
+	 * the old `dialog.invalidate()` forwarding chain — DialogView no longer
+	 * reaches into siblings (tabBar, notesInput, activePreviewPane).
+	 * Iterates the same registries used by `apply()` plus
+	 * `extraInvalidatables` for components outside the binding system.
+	 */
+	invalidate(): void {
+		for (const b of this.globalBindings) b.invalidate();
+		for (const tab of this.tabsByIndex) {
+			tab.optionList.invalidate();
+			tab.preview.invalidate();
+			tab.multiSelect?.invalidate();
+		}
+		for (const x of this.extraInvalidatables) x.invalidate();
+	}
+}

package/adapters/pi/extensions/ask-user-question/view/stateful-view.ts

@@ -0,0 +1,26 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/stateful-view.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { Component } from "@earendil-works/pi-tui";
+
+/**
+ * Generic prop-driven component contract. Every renderable owns its own `P` shape;
+ * the adapter computes `P` from canonical state via per-component selectors and
+ * pushes it via `setProps`. `focused: boolean` is a field on `P` only where the
+ * component needs it.
+ */
+export interface StatefulView<P> extends Component {
+	setProps(props: P): void;
+}
+
+/**
+ * Discriminated focus union — encodes the three-cell focus invariant
+ * (`notesVisible`, submit-tab, options). Dispatcher cascade (`key-router.ts`)
+ * and reducer's defensive clears (`state-reducer.ts`) enforce mutual exclusion;
+ * this type makes it explicit so per-component `focused: boolean` flags
+ * derive from one equality check against this discriminant rather than
+ * parallel boolean reads.
+ *
+ * Priority order: notes > submit > options. Matches the dispatcher
+ * cascade exactly so the union is observably equivalent to today's reads.
+ */
+export type ActiveView = "notes" | "options" | "submit";

package/adapters/pi/extensions/ask-user-question/view/tab-components.ts

@@ -0,0 +1,18 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/tab-components.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { MultiSelectView } from "./components/multi-select-view.js";
+import type { OptionListViewProps } from "./components/option-list-view.js";
+import type { PreviewPane } from "./components/preview/preview-pane.js";
+import type { StatefulView } from "./stateful-view.js";
+
+export interface TabBodyHeights {
+	current: number;
+	max: number;
+}
+
+export interface TabComponents {
+	optionList: StatefulView<OptionListViewProps>;
+	preview: PreviewPane;
+	multiSelect?: MultiSelectView;
+	bodyHeights: (width: number) => TabBodyHeights;
+}

package/adapters/pi/extensions/ask-user-question/view/tab-content-strategy.ts

@@ -0,0 +1,252 @@
+// GENERATED — DO NOT EDIT. Source: adapter-src/pi/extensions/ask-user-question/view/tab-content-strategy.ts
+// Regenerate with: python3 scripts/build-adapters.py
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Container, type Input, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { t } from "../state/i18n-bridge.js";
+import { formatAnswerScalar } from "../tool/format-answer.js";
+import type { QuestionData } from "../tool/types.js";
+import type { PreviewPane, PreviewPaneProps } from "./components/preview/preview-pane.js";
+import {
+	type DialogState,
+	HINT_PART_CANCEL,
+	HINT_PART_COLLAPSE,
+	HINT_PART_ENTER,
+	HINT_PART_NAV,
+	HINT_PART_NOTES,
+	HINT_PART_TAB,
+	HINT_PART_TOGGLE,
+	INCOMPLETE_WARNING_PREFIX,
+	READY_PROMPT,
+	REVIEW_HEADING,
+} from "./dialog-builder.js";
+import type { StatefulView } from "./stateful-view.js";
+import type { TabComponents } from "./tab-components.js";
+
+const NOTES_HEADER = "Notes:";
+
+/**
+ * Single-row, width-clipped chrome cell. The footer row count is invariant
+ * (`QuestionTabStrategy.footerRowCount = 2`) — pi-tui's `Text` word-wraps when
+ * the styled hint exceeds `width`, inflating that row count and desyncing the
+ * `bodyHeight + footerRowCount` math in `DialogView.render`. Clipping with
+ * `truncateToWidth` (ANSI-aware, matches `multi-select-view.ts` usage) keeps
+ * the hint on one line; the collapse affordance falls off the right edge with
+ * `…` on terminals too narrow to advertise it.
+ */
+class OneLineClippedText implements Component {
+	constructor(
+		private readonly text: string,
+		private readonly paddingLeft: number = 0,
+	) {}
+
+	render(width: number): string[] {
+		const pad = " ".repeat(this.paddingLeft);
+		const avail = Math.max(0, width - this.paddingLeft);
+		return [pad + truncateToWidth(this.text, avail, "…", false)];
+	}
+
+	invalidate(): void {}
+
+	handleInput(_data: string): void {}
+}
+
+/**
+ * Per-tab content provider. Pure functional — closes over construction-time
+ * config; per-tick state threads through method args. The chrome wrapper
+ * enforces height equality across tabs via `bodyHeight + footerRowCount`.
+ */
+export interface TabContentStrategy {
+	/** Total RENDERED footer rows — MUST equal what `footerRows()` actually emits. Drives residual math. */
+	readonly footerRowCount: number;
+
+	/** Variable rows above the body, after top chrome (border + tabBar + Spacer). */
+	headingRows(state: DialogState): Component[];
+
+	/** Body Component placed at the body slot. */
+	bodyComponent(state: DialogState): Component;
+
+	/** Natural rendered height of `bodyComponent(state)` at given width. */
+	bodyHeight(width: number, state: DialogState): number;
+
+	/** Optional rows between body's trailing Spacer and the bottom border. */
+	midRows(state: DialogState): Component[];
+
+	/** Footer rows below the bottom border. Rendered row count MUST equal `footerRowCount`. */
+	footerRows(state: DialogState): Component[];
+
+	/** Row range of the focused item within the body's rendered output, or undefined if no interactive focus. */
+	focusedItemRowRange(width: number, state: DialogState): [number, number] | undefined;
+}
+
+export interface QuestionTabStrategyConfig {
+	theme: Theme;
+	questions: readonly QuestionData[];
+	getPreviewPane: () => StatefulView<PreviewPaneProps>;
+	tabsByIndex: ReadonlyArray<TabComponents>;
+	notesInput: Input;
+	isMulti: boolean;
+	getCurrentBodyHeight: (width: number) => number;
+}
+
+export class QuestionTabStrategy implements TabContentStrategy {
+	/** Spacer(1) + OneLineClippedText(hint, 1) = 2 rendered rows. */
+	readonly footerRowCount = 2;
+
+	constructor(private readonly config: QuestionTabStrategyConfig) {}
+
+	headingRows(state: DialogState): Component[] {
+		const out: Component[] = [];
+		const question = this.config.questions[state.currentTab];
+		// In multi-question mode the tab bar already shows the header; suppress the inline badge.
+		if (!this.config.isMulti && question?.header && question.header.length > 0) {
+			out.push(new Text(this.config.theme.bg("selectedBg", ` ${question.header} `), 1, 0));
+			out.push(new Spacer(1));
+		}
+		if (question) {
+			out.push(new Text(this.config.theme.bold(question.question), 1, 0));
+			out.push(new Spacer(1));
+		}
+		return out;
+	}
+
+	bodyComponent(state: DialogState): Component {
+		const question = this.config.questions[state.currentTab];
+		const mso = this.config.tabsByIndex[state.currentTab]?.multiSelect;
+		if (question?.multiSelect === true && mso) return mso;
+		return this.config.getPreviewPane();
+	}
+
+	bodyHeight(width: number, _state: DialogState): number {
+		return this.config.getCurrentBodyHeight(width);
+	}
+
+	midRows(state: DialogState): Component[] {
+		if (!state.notesVisible) return [];
+		return [
+			new Text(this.config.theme.fg("muted", t("notes.header", NOTES_HEADER)), 1, 0),
+			this.config.notesInput,
+			new Spacer(1),
+		];
+	}
+
+	footerRows(state: DialogState): Component[] {
+		const question = this.config.questions[state.currentTab];
+		// OneLineClippedText (not pi-tui `Text`) — `buildHintText` includes the collapse
+		// affordance, pushing the rendered string past 80 columns; `Text` would wrap and
+		// break the strategy's `footerRowCount = 2` invariant. Clipping on narrow terminals
+		// drops the trailing parts (collapse hint first, then cancel) with `…`.
+		return [
+			new Spacer(1),
+			new OneLineClippedText(this.config.theme.fg("dim", buildHintText(question, this.config.isMulti, state)), 1),
+		];
+	}
+
+	focusedItemRowRange(width: number, state: DialogState): [number, number] | undefined {
+		const question = this.config.questions[state.currentTab];
+		const mso = this.config.tabsByIndex[state.currentTab]?.multiSelect;
+		if (question?.multiSelect === true && mso) return mso.focusedItemRowRange(width);
+		return (this.config.getPreviewPane() as unknown as PreviewPane).focusedItemRowRange(width);
+	}
+}
+
+export interface SubmitTabStrategyConfig {
+	theme: Theme;
+	questions: readonly QuestionData[];
+	submitPicker: Component | undefined;
+}
+
+export class SubmitTabStrategy implements TabContentStrategy {
+	/** Spacer(1) + Text(prompt, 1) + Spacer(1) + submitPicker(2) = 5 rendered rows. Fallback path lands at 5 via 2 trailing Spacer(1)s. */
+	readonly footerRowCount = 5;
+
+	constructor(private readonly config: SubmitTabStrategyConfig) {}
+
+	headingRows(_state: DialogState): Component[] {
+		return [
+			new Text(this.config.theme.bold(this.config.theme.fg("accent", t("review.heading", REVIEW_HEADING))), 1, 0),
+			new Spacer(1),
+		];
+	}
+
+	bodyComponent(state: DialogState): Component {
+		const c = new Container();
+		for (let i = 0; i < this.config.questions.length; i++) {
+			const q = this.config.questions[i];
+			const a = state.answers.get(i);
+			if (!a) continue;
+			const label = q.header && q.header.length > 0 ? q.header : `Q${i + 1}`;
+			const answerText = formatAnswerScalar(a, "summary");
+			c.addChild(new Text(this.config.theme.fg("muted", ` ● ${label}`), 1, 0));
+			c.addChild(
+				new Text(`   ${this.config.theme.fg("muted", "→")} ${this.config.theme.fg("text", answerText)}`, 1, 0),
+			);
+			if (a.notes && a.notes.length > 0) {
+				c.addChild(new Text(this.config.theme.fg("dim", `     notes: ${a.notes}`), 1, 0));
+			}
+		}
+		return c;
+	}
+
+	bodyHeight(width: number, state: DialogState): number {
+		return this.bodyComponent(state).render(width).length;
+	}
+
+	midRows(_state: DialogState): Component[] {
+		return [];
+	}
+
+	footerRows(state: DialogState): Component[] {
+		const missing: string[] = [];
+		for (let i = 0; i < this.config.questions.length; i++) {
+			const q = this.config.questions[i];
+			if (!state.answers.has(i)) {
+				missing.push(q.header && q.header.length > 0 ? q.header : `Q${i + 1}`);
+			}
+		}
+		const promptText =
+			missing.length === 0
+				? this.config.theme.fg("muted", t("review.ready", READY_PROMPT))
+				: this.config.theme.fg(
+						"warning",
+						`${t("review.incomplete", INCOMPLETE_WARNING_PREFIX)} ${missing.join(", ")}`,
+					);
+		const out: Component[] = [new Spacer(1), new Text(promptText, 1, 0), new Spacer(1)];
+		if (this.config.submitPicker) {
+			out.push(this.config.submitPicker);
+		} else {
+			// Padding when the picker isn't wired — keeps rendered row count at footerRowCount=5.
+			out.push(new Spacer(1));
+			out.push(new Spacer(1));
+		}
+		return out;
+	}
+
+	focusedItemRowRange(_width: number, _state: DialogState): [number, number] | undefined {
+		return undefined;
+	}
+}
+
+/**
+ * Build the controls hint line. Order:
+ *   Enter · ↑/↓ [· Space toggle] [· n notes] [· Tab switch] · Esc · Ctrl+] collapse
+ *
+ * `NOTES` is now part of the resting (notes-closed) core — it renders on every
+ * question tab and drops when `state.notesVisible` flips the editor open OR while
+ * `state.inputMode` has the "Type something." row capturing text (`n` would insert
+ * a literal character there, so advertising it would lie). The collapse affordance
+ * is appended last so the resting core stays a contiguous substring even when the
+ * trailing part is clipped by `OneLineClippedText` on terminals < ~95 cols. This
+ * is the trade we picked over wrapping (which would inflate `footerRowCount` and
+ * desync the height math in `DialogView.render`).
+ */
+export function buildHintText(question: QuestionData | undefined, isMulti: boolean, state: DialogState): string {
+	const parts: string[] = [t("hint.enter", HINT_PART_ENTER), t("hint.navigate", HINT_PART_NAV)];
+	if (question?.multiSelect === true) parts.push(t("hint.toggle", HINT_PART_TOGGLE));
+	if (question && !state.notesVisible && !state.inputMode) {
+		parts.push(t("hint.notes", HINT_PART_NOTES));
+	}
+	if (isMulti) parts.push(t("hint.tab", HINT_PART_TAB));
+	parts.push(t("hint.cancel", HINT_PART_CANCEL));
+	parts.push(t("hint.collapse", HINT_PART_COLLAPSE));
+	return parts.join(" · ");
+}

package/adapters/pi/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "feature-forge-pi-adapter",
+  "private": true,
+  "version": "0.0.0",
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "skills": [
+      "./skills"
+    ],
+    "extensions": [
+      "./extensions/ask-user-question/index.ts"
+    ]
+  },
+  "pi-subagents": {
+    "agents": [
+      "./agents"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  }
+}