@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/panels/polish-tables.ts

@@ -0,0 +1,258 @@
+import type { Line } from '../types/grid.ts';
+import { getDisplayWidth, truncateDisplay } from '../utils/terminal-width.ts';
+import { GLYPHS, UI_TONES } from '../renderer/ui-primitives.ts';
+// Build on the leaf primitives in ./polish-core.ts (palette + base line
+// builders). polish-core has no back-edge to this file, so there is no cycle.
+import { buildSelectablePanelLine, DEFAULT_PANEL_PALETTE } from './polish-core.ts';
+import type { PanelPalette, StyledPanelSegment } from './polish-core.ts';
+
+// ---------------------------------------------------------------------------
+// Shared formatting primitives (the toolkit panels standardize on).
+//
+// All are display-width aware (via getDisplayWidth / truncateDisplay) so they
+// stay aligned across emoji, CJK, and other wide characters — never hand-roll
+// .slice()/.padEnd() truncation or alignment in panels.
+// ---------------------------------------------------------------------------
+
+export type ColumnAlign = 'left' | 'right' | 'center';
+
+export interface ColumnSpec {
+  /** Fixed display width of the column. */
+  readonly width: number;
+  /** Horizontal alignment within the column. Default 'left'. */
+  readonly align?: ColumnAlign;
+}
+
+export interface AlignedCell {
+  readonly text: string;
+  readonly fg: string;
+  readonly bg?: string;
+  readonly bold?: boolean;
+  readonly dim?: boolean;
+}
+
+/** Truncate + pad `text` to exactly `width` display columns with alignment. */
+function alignText(text: string, width: number, align: ColumnAlign): string {
+  if (width <= 0) return '';
+  const truncated = truncateDisplay(text, width);
+  const pad = Math.max(0, width - getDisplayWidth(truncated));
+  if (pad === 0) return truncated;
+  if (align === 'right') return ' '.repeat(pad) + truncated;
+  if (align === 'center') {
+    const left = Math.floor(pad / 2);
+    return ' '.repeat(left) + truncated + ' '.repeat(pad - left);
+  }
+  return truncated + ' '.repeat(pad);
+}
+
+/**
+ * Build a multi-column row with display-width-aware alignment. Replaces manual
+ * `.padEnd()`/`.padStart()` column math (which misaligns on wide chars).
+ *
+ * `cells` and `columns` are zip-aligned by index; extra cells are ignored.
+ */
+export function buildAlignedRow(
+  width: number,
+  cells: ReadonlyArray<AlignedCell>,
+  columns: ReadonlyArray<ColumnSpec>,
+  options: {
+    readonly gap?: number;
+    readonly selected?: boolean;
+    readonly selectedBg?: string;
+    readonly marker?: string;
+    readonly fillBg?: string;
+  } = {},
+): Line {
+  const gap = options.gap ?? 1;
+  const segments: StyledPanelSegment[] = [];
+  const count = Math.min(cells.length, columns.length);
+  for (let i = 0; i < count; i++) {
+    const col = columns[i]!;
+    const cell = cells[i]!;
+    if (i > 0 && gap > 0) segments.push({ text: ' '.repeat(gap), fg: cell.fg, bg: cell.bg });
+    segments.push({
+      text: alignText(cell.text, col.width, col.align ?? 'left'),
+      fg: cell.fg,
+      bg: cell.bg,
+      bold: cell.bold,
+      dim: cell.dim,
+    });
+  }
+  return buildSelectablePanelLine(width, segments, {
+    selected: options.selected,
+    selectedBg: options.selectedBg,
+    fillBg: options.fillBg,
+    leadingMarker: options.marker,
+  });
+}
+
+export type StatusBadgeKind =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'blocked'
+  | 'review';
+
+interface BadgeSpec {
+  readonly glyph: string;
+  readonly fg: string;
+  readonly label: string;
+}
+
+const STATUS_BADGES: Record<StatusBadgeKind, BadgeSpec> = {
+  pending:   { glyph: GLYPHS.status.pending, fg: DEFAULT_PANEL_PALETTE.info, label: 'Pending' },
+  running:   { glyph: GLYPHS.status.active,  fg: UI_TONES.state.active,      label: 'Running' },
+  completed: { glyph: GLYPHS.status.success, fg: DEFAULT_PANEL_PALETTE.good, label: 'Completed' },
+  failed:    { glyph: GLYPHS.status.failure, fg: DEFAULT_PANEL_PALETTE.bad,  label: 'Failed' },
+  cancelled: { glyph: GLYPHS.status.skipped, fg: DEFAULT_PANEL_PALETTE.dim,  label: 'Cancelled' },
+  blocked:   { glyph: GLYPHS.status.blocked, fg: UI_TONES.state.blocked,     label: 'Blocked' },
+  review:    { glyph: GLYPHS.status.review,  fg: DEFAULT_PANEL_PALETTE.info, label: 'Review' },
+};
+
+/**
+ * Canonical status badge (glyph + label) with a consistent color per lifecycle
+ * state. Returns StyledPanelSegment[] — spread into a buildPanelLine call:
+ *   buildPanelLine(width, [['  ', C.label], ...buildStatusBadge('running')])
+ * Supersedes ad-hoc per-panel status→color maps.
+ */
+export function buildStatusBadge(
+  kind: StatusBadgeKind,
+  label?: string,
+  opts?: { glyph?: string; bg?: string; count?: number },
+): StyledPanelSegment[] {
+  const spec = STATUS_BADGES[kind];
+  const glyph = opts?.glyph ?? spec.glyph;
+  const text = label ?? spec.label;
+  const rendered = opts?.count !== undefined ? `${glyph} ${text} (${opts.count})` : `${glyph} ${text}`;
+  return [{ text: rendered, fg: spec.fg, bg: opts?.bg }];
+}
+
+export interface TreeItemSpec {
+  readonly depth: number;
+  readonly label: string;
+  readonly icon?: string;
+  readonly expandable?: boolean;
+  readonly expanded?: boolean;
+  readonly labelColor?: string;
+  /** Right-aligned metadata columns (e.g. size, mtime). */
+  readonly metadata?: ReadonlyArray<{ text: string; fg: string }>;
+}
+
+/**
+ * Build a hierarchical tree row: indentation + expand/collapse glyph + optional
+ * icon + label, with right-aligned metadata. Replaces hand-rolled indentation
+ * in file-explorer / symbol-outline / orchestration panels.
+ */
+export function buildTreeRow(
+  width: number,
+  item: TreeItemSpec,
+  palette: PanelPalette,
+  options: { selected?: boolean; selectedBg?: string; indentWidth?: number } = {},
+): Line {
+  const indent = ' '.repeat(Math.max(0, item.depth) * (options.indentWidth ?? 2));
+  const toggle = item.expandable
+    ? (item.expanded ? GLYPHS.navigation.expanded : GLYPHS.navigation.collapsed)
+    : ' ';
+  const iconPart = item.icon ? `${item.icon} ` : '';
+  const prefix = `${indent}${toggle} ${iconPart}`;
+  const prefixW = getDisplayWidth(prefix);
+
+  const metadata = item.metadata ?? [];
+  const metaText = metadata.map((m) => m.text).join(' ');
+  const metaW = getDisplayWidth(metaText);
+  const reserve = metaW > 0 ? metaW + 1 : 0;
+
+  const labelBudget = Math.max(0, width - prefixW - reserve);
+  const label = truncateDisplay(item.label, labelBudget);
+  const usedW = prefixW + getDisplayWidth(label);
+
+  const segments: StyledPanelSegment[] = [
+    { text: prefix, fg: palette.dim },
+    { text: label, fg: item.labelColor ?? palette.value },
+  ];
+  if (metaW > 0) {
+    const spacer = Math.max(1, width - usedW - metaW);
+    segments.push({ text: ' '.repeat(spacer), fg: palette.dim });
+    metadata.forEach((m, i) => {
+      if (i > 0) segments.push({ text: ' ', fg: palette.dim });
+      segments.push({ text: m.text, fg: m.fg });
+    });
+  }
+  return buildSelectablePanelLine(width, segments, {
+    selected: options.selected,
+    selectedBg: options.selectedBg ?? palette.selectBg,
+  });
+}
+
+export interface TableColumn {
+  readonly label: string;
+  /** Fixed width; omit to auto-distribute remaining space. */
+  readonly width?: number;
+  readonly align?: ColumnAlign;
+}
+
+export interface TableCell {
+  readonly text: string;
+  readonly fg?: string;
+  readonly bg?: string;
+  readonly bold?: boolean;
+}
+
+export interface TableRow {
+  readonly cells: ReadonlyArray<TableCell>;
+  readonly selected?: boolean;
+}
+
+/** Resolve concrete per-column widths, auto-distributing any unsized columns. */
+function resolveColumnWidths(width: number, columns: ReadonlyArray<TableColumn>, gap: number): number[] {
+  const totalGap = gap * Math.max(0, columns.length - 1);
+  const explicit = columns.reduce((s, c) => s + (c.width ?? 0), 0);
+  const autoIdx = columns.map((c, i) => (c.width === undefined ? i : -1)).filter((i) => i >= 0);
+  const autoBudget = Math.max(0, width - totalGap - explicit);
+  const each = autoIdx.length > 0 ? Math.floor(autoBudget / autoIdx.length) : 0;
+  const widths = columns.map((c) => c.width ?? each);
+  if (autoIdx.length > 0) {
+    const used = each * autoIdx.length;
+    widths[autoIdx[autoIdx.length - 1]!] += autoBudget - used; // remainder to last auto col
+  }
+  return widths;
+}
+
+/**
+ * Build a table: a header row plus aligned data rows. Replaces ad-hoc
+ * row/column offset math in history/ledger/roster panels.
+ */
+export function buildTable(
+  width: number,
+  columns: ReadonlyArray<TableColumn>,
+  rows: ReadonlyArray<TableRow>,
+  palette: PanelPalette,
+  options: { gap?: number; selectedBg?: string } = {},
+): Line[] {
+  const gap = options.gap ?? 1;
+  const widths = resolveColumnWidths(width, columns, gap);
+  const specs: ColumnSpec[] = columns.map((c, i) => ({ width: widths[i]!, align: c.align }));
+
+  const header = buildAlignedRow(
+    width,
+    columns.map((c) => ({ text: c.label, fg: palette.label, bold: true })),
+    specs,
+    { gap },
+  );
+
+  const dataRows = rows.map((row) =>
+    buildAlignedRow(
+      width,
+      columns.map((_, i) => {
+        const cell = row.cells[i] ?? { text: '', fg: palette.value };
+        return { text: cell.text, fg: cell.fg ?? palette.value, bg: cell.bg, bold: cell.bold };
+      }),
+      specs,
+      { gap, selected: row.selected, selectedBg: options.selectedBg ?? palette.selectBg },
+    ),
+  );
+
+  return [header, ...dataRows];
+}

package/src/panels/polish.ts

@@ -2,152 +2,31 @@ import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
 import { getSurfaceContentRows, getTrackedVisibleWindow, getVisibleWindow, type VisibleWindow } from '../renderer/surface-layout.ts';
-import { GLYPHS, UI_TONES } from '../renderer/ui-primitives.ts';
+import { GLYPHS } from '../renderer/ui-primitives.ts';
 import { type StatusState, STATE_GLYPHS } from '../renderer/status-glyphs.ts';
-
-export interface PanelPalette {
-  readonly label: string;
-  readonly value: string;
-  readonly dim: string;
-  readonly info: string;
-  readonly good?: string;
-  readonly warn?: string;
-  readonly bad?: string;
-  readonly empty: string;
-  readonly header?: string;
-  readonly headerBg?: string;
-  readonly surfaceBg?: string;
-  readonly sectionBg?: string;
-  readonly summaryBg?: string;
-  readonly inputBg?: string;
-  readonly accent?: string;
-  readonly selectBg?: string;
-}
-
-export const DEFAULT_PANEL_PALETTE: Readonly<Required<PanelPalette>> = {
-  header: UI_TONES.fg.primary,
-  headerBg: UI_TONES.bg.title,
-  label: UI_TONES.fg.muted,
-  value: UI_TONES.fg.primary,
-  dim: UI_TONES.fg.dim,
-  info: UI_TONES.state.info,
-  good: UI_TONES.state.good,
-  warn: UI_TONES.state.warn,
-  bad: UI_TONES.state.bad,
-  empty: '#334155',
-  surfaceBg: UI_TONES.bg.surface,
-  sectionBg: UI_TONES.bg.section,
-  summaryBg: UI_TONES.bg.summary,
-  inputBg: UI_TONES.bg.input,
-  accent: UI_TONES.fg.secondary,
-  selectBg: UI_TONES.bg.selected,
-} as const;
-
-/**
- * Extend the base panel palette with domain-specific colors.
- *
- * Convention: raw hex colors may only live inside a palette constant declared
- * at the top of a panel file, not inline in render calls.
- *
- * @example
- * ```ts
- * const C = extendPalette(DEFAULT_PANEL_PALETTE, {
- *   decision: '#38bdf8',
- *   incident: '#ef4444',
- * });
- * ```
- */
-export function extendPalette<T extends Record<string, string>>(
-  base: typeof DEFAULT_PANEL_PALETTE,
-  extras: T,
-): typeof DEFAULT_PANEL_PALETTE & T {
-  return { ...base, ...extras };
-}
-
-export function buildPanelLine(
-  width: number,
-  segments: Array<StyledPanelSegment | [string, string, string?]>,
-): Line {
-  return buildStyledPanelLine(
-    width,
-    segments.map((seg) =>
-      Array.isArray(seg) ? { text: seg[0], fg: seg[1], bg: seg[2] } : seg,
-    ),
-  );
-}
-
-export interface StyledPanelSegment {
-  readonly text: string;
-  readonly fg: string;
-  readonly bg?: string;
-  readonly bold?: boolean;
-  readonly dim?: boolean;
-}
-
-export function buildSelectablePanelLine(
-  width: number,
-  segments: ReadonlyArray<StyledPanelSegment>,
-  options: { selected?: boolean; selectedBg?: string; fillFg?: string; fillBg?: string; leadingMarker?: string } = {},
-): Line {
-  const selected = options.selected ?? false;
-  const selectedBg = selected ? (options.selectedBg ?? DEFAULT_PANEL_PALETTE.selectBg) : '';
-  const fillBg = selectedBg || options.fillBg || '';
-  const fillFg = options.fillFg ?? '';
-  const cells = createEmptyLine(width);
-  if (fillBg) {
-    for (let col = 0; col < width; col++) {
-      cells[col] = createStyledCell(' ', { bg: fillBg, fg: fillFg });
-    }
-  }
-
-  let col = 0;
-  if (selected && options.leadingMarker) {
-    for (const ch of options.leadingMarker) {
-      const charWidth = getDisplayWidth(ch);
-      if (charWidth <= 0 || col + charWidth > width) break;
-      cells[col] = createStyledCell(ch, { fg: DEFAULT_PANEL_PALETTE.info, bg: selectedBg, bold: true });
-      if (charWidth > 1 && col + 1 < width) cells[col + 1] = createStyledCell(' ', { fg: DEFAULT_PANEL_PALETTE.info, bg: selectedBg, bold: true });
-      col += charWidth;
-    }
-  }
-  for (const segment of segments) {
-    const fg = segment.fg;
-    const bg = segment.bg ?? fillBg;
-    for (const ch of segment.text) {
-      const charWidth = getDisplayWidth(ch);
-      if (charWidth <= 0) continue;
-      if (col + charWidth > width) return cells;
-      cells[col] = createStyledCell(ch, {
-        fg,
-        bg,
-        bold: segment.bold ?? false,
-        dim: segment.dim ?? false,
-      });
-      if (charWidth > 1 && col + 1 < width) {
-        cells[col + 1] = createStyledCell(' ', {
-          fg,
-          bg,
-          bold: segment.bold ?? false,
-          dim: segment.dim ?? false,
-        });
-      }
-      col += charWidth;
-    }
-  }
-
-  while (col < width) {
-    cells[col++] = createStyledCell(' ', { bg: fillBg, fg: fillFg });
-  }
-  return cells;
-}
-
-export function buildStyledPanelLine(
-  width: number,
-  segments: ReadonlyArray<StyledPanelSegment>,
-  options: { fillBg?: string; fillFg?: string } = {},
-): Line {
-  return buildSelectablePanelLine(width, segments, options);
-}
+import { buildPanelLine, buildStyledPanelLine, DEFAULT_PANEL_PALETTE } from './polish-core.ts';
+import type { PanelPalette, StyledPanelSegment } from './polish-core.ts';
+
+// The panel formatting toolkit is split across three modules to stay under the
+// architecture line-count cap; every symbol remains importable from './polish.ts':
+//   - ./polish-core.ts    palette + base line primitives (leaf)
+//   - ./polish-tables.ts  table / tree / badge / aligned-row primitives
+// This module keeps the higher-level builders + workspace layout.
+export * from './polish-core.ts';
+export {
+  buildAlignedRow,
+  buildStatusBadge,
+  buildTreeRow,
+  buildTable,
+  type ColumnAlign,
+  type ColumnSpec,
+  type AlignedCell,
+  type StatusBadgeKind,
+  type TreeItemSpec,
+  type TableColumn,
+  type TableCell,
+  type TableRow,
+} from './polish-tables.ts';
 
 export function buildGuidanceLine(
   width: number,
@@ -568,16 +447,26 @@ export function resolveScrollablePanelSection(
     afterSections: options.afterSections,
     minRows: options.section.minRows ?? 1,
   });
+  // When a window-summary row will render (list longer than the budget can
+  // show), it occupies one of the section's rows. Reserve that row up front so
+  // the summary is accounted INSIDE the budget; otherwise the appended summary
+  // pushes total output one line past the panel's exact-height contract and the
+  // tail line (typically the footer's keyboard-hints row) is silently dropped.
+  const summaryReserved = options.section.appendWindowSummary
+    && options.section.scrollableLines.length > budget
+    ? 1
+    : 0;
+  const windowBudget = Math.max(0, budget - summaryReserved);
   const window = options.section.selectedIndex === undefined
     ? getVisibleWindow(
         options.section.scrollableLines.length,
         options.section.scrollOffset,
-        budget,
+        windowBudget,
       )
     : getTrackedVisibleWindow(
         options.section.scrollableLines.length,
         options.section.selectedIndex,
-        budget,
+        windowBudget,
         options.section.scrollOffset,
         options.section.guardRows ?? 1,
       );
@@ -650,12 +539,21 @@ export function resolveStackedScrollableSections(
 
   return options.sections.map((section, index) => {
     const fixedLines = [...(section.fixedLines ?? [])];
+    // Same reservation as resolveScrollablePanelSection: a window-summary row
+    // occupies one of this section's allocated rows, so shrink the visible
+    // window rather than overflowing the stack's exact-height budget.
+    const budget = budgets[index]!;
+    const summaryReserved = section.appendWindowSummary
+      && section.scrollableLines.length > budget
+      ? 1
+      : 0;
+    const windowBudget = Math.max(0, budget - summaryReserved);
     const window = section.selectedIndex === undefined
-      ? getVisibleWindow(section.scrollableLines.length, section.scrollOffset, budgets[index]!)
+      ? getVisibleWindow(section.scrollableLines.length, section.scrollOffset, windowBudget)
       : getTrackedVisibleWindow(
           section.scrollableLines.length,
           section.selectedIndex,
-          budgets[index]!,
+          windowBudget,
           section.scrollOffset,
           section.guardRows ?? 1,
         );
@@ -680,6 +578,26 @@ export function resolveStackedScrollableSections(
   });
 }
 
+/**
+ * Standardized footer keyboard-hint row so every panel's hints look identical.
+ * Each hint renders as `keys` (info color) + `label` (dim).
+ */
+export function buildKeyboardHints(
+  width: number,
+  hints: ReadonlyArray<{ keys: string; label: string }>,
+  palette: PanelPalette,
+): Line {
+  const segments: Array<[string, string, string?]> = [];
+  hints.forEach((hint, i) => {
+    if (i > 0) segments.push(['   ', palette.dim]);
+    else segments.push([' ', palette.dim]);
+    segments.push([hint.keys, palette.info]);
+    segments.push([' ', palette.dim]);
+    segments.push([hint.label, palette.dim]);
+  });
+  return buildPanelLine(width, segments);
+}
+
 export function buildPanelWorkspace(
   width: number,
   height: number,

package/src/panels/project-planning-answer-actions.ts

@@ -0,0 +1,134 @@
+import type { ProjectPlanningQuestion } from '@pellux/goodvibes-sdk/platform/knowledge';
+
+// ---------------------------------------------------------------------------
+// Answer-action helpers for the Project Planning panel.
+//
+// Extracted from project-planning-panel.ts to keep that module under the
+// architecture line-count cap. Leaf module (only the SDK question type);
+// the panel is their public import site.
+// ---------------------------------------------------------------------------
+
+export interface PlanningAnswerAction {
+  readonly id: string;
+  readonly label: string;
+  readonly detail: string;
+  readonly answer: string;
+  readonly kind?: 'answer' | 'approve' | 'dismiss';
+  readonly disabled?: boolean;
+}
+
+/** SDK placeholder recommendations that carry no real signal — never surfaced as an answer action. */
+export function isGenericRecommendation(value: string): boolean {
+  return /\bdefine the first-pass scope\b/i.test(value)
+    || /\bcreate task records\b/i.test(value)
+    || /\brecord concrete tests\b/i.test(value)
+    || /\bseparate out-of-scope work\b/i.test(value);
+}
+
+function compactAnswerDetail(text: string): string {
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  return normalized.length > 86 ? `${normalized.slice(0, 83)}...` : normalized;
+}
+
+/**
+ * Builds the answer-action list for the current question: keyword-matched
+ * canned suggestions first (de-duplicated by normalized answer text — a
+ * question that matches more than one keyword category, e.g. scope +
+ * recommendedAnswer echoing one of the scope answers verbatim, must not show
+ * the same suggested answer twice), then the fixed ask-narrower/custom/
+ * dismiss actions.
+ */
+export function buildAnswerActions(question: ProjectPlanningQuestion, draftAnswer: string): PlanningAnswerAction[] {
+  const canned: PlanningAnswerAction[] = [];
+  const prompt = question.prompt.toLowerCase();
+  const isScopeQuestion = prompt.includes('scope') || prompt.includes('in or out');
+  const isTaskQuestion = prompt.includes('task') || prompt.includes('dependency') || prompt.includes('work breakdown');
+  const isVerificationQuestion = prompt.includes('verification') || prompt.includes('test') || prompt.includes('prove');
+  const isApprovalQuestion = prompt.includes('approved') || prompt.includes('approve') || prompt.includes('execution');
+  if (isApprovalQuestion) {
+    canned.push({
+      id: 'approve-execution',
+      label: 'Approve execution',
+      detail: 'Mark this plan approved so execution may proceed.',
+      answer: 'Approve this planning state for execution.',
+      kind: 'approve',
+    });
+  }
+  if (isScopeQuestion) {
+    canned.push({
+      id: 'scope-focused-first-pass',
+      label: 'Use focused first-pass scope',
+      detail: 'Fill a concrete end-to-end scope for this goal and keep unrelated work out.',
+      answer: 'Use a focused first-pass scope for this goal.',
+    });
+  }
+  if (isTaskQuestion) {
+    canned.push({
+      id: 'tasks-default-breakdown',
+      label: 'Create default task breakdown',
+      detail: 'Create inspect, implement, wire, and verify tasks with dependencies.',
+      answer: 'Create the default task breakdown for this goal.',
+    });
+  }
+  if (isVerificationQuestion) {
+    canned.push({
+      id: 'verification-default-gates',
+      label: 'Use standard verification gates',
+      detail: 'Require focused regression coverage, typecheck/build validation, and a runtime smoke where feasible.',
+      answer: 'Use standard verification gates for this goal.',
+    });
+  }
+  if (question.recommendedAnswer?.trim() && !isGenericRecommendation(question.recommendedAnswer)) {
+    canned.push({
+      id: 'recommended',
+      label: 'Use recommended answer',
+      detail: compactAnswerDetail(question.recommendedAnswer),
+      answer: question.recommendedAnswer,
+    });
+  }
+  if (isScopeQuestion) {
+    canned.push({
+      id: 'scope-end-to-end',
+      label: 'End-to-end required scope',
+      detail: 'Let the plan include every component needed to make this work, but avoid unrelated cleanup.',
+      answer: 'Scope is everything required to make the requested outcome work end-to-end. Include TUI, daemon composition, configuration, docs, and tests if they are required. Do not include unrelated cleanup or broad refactors unless they are necessary for this task.',
+    });
+    canned.push({
+      id: 'scope-tui-first',
+      label: 'TUI-first scope',
+      detail: 'Fix TUI behavior here; report SDK blockers instead of patching around SDK-owned bugs.',
+      answer: 'Scope is TUI-owned behavior first. If a blocker is SDK-owned, report the exact SDK contract/runtime issue instead of patching around it in the TUI. Include daemon composition only where the TUI owns the wiring.',
+    });
+  }
+
+  const seenAnswers = new Set<string>();
+  const actions: PlanningAnswerAction[] = [];
+  for (const action of canned) {
+    const key = action.answer.trim().toLowerCase().replace(/\s+/g, ' ');
+    if (key.length > 0 && seenAnswers.has(key)) continue;
+    if (key.length > 0) seenAnswers.add(key);
+    actions.push(action);
+  }
+
+  actions.push({
+    id: 'ask-narrower',
+    label: 'I am not sure yet',
+    detail: 'Break this into smaller concrete choices with examples and a recommended default.',
+    answer: `I do not know enough to answer "${question.prompt}" as asked. Break it into smaller concrete questions with 2-4 specific choices, explain the tradeoffs, recommend a default, and ask me the first one.`,
+  });
+  actions.push({
+    id: 'custom',
+    label: 'Submit typed answer',
+    detail: draftAnswer ? compactAnswerDetail(draftAnswer) : 'Type an answer first; this row becomes the custom answer.',
+    answer: draftAnswer.trim(),
+    disabled: !draftAnswer.trim(),
+  });
+  actions.push({
+    id: 'dismiss-planning',
+    label: 'Close planning and continue without it',
+    detail: 'Pause project planning for this workspace. Normal chat continues; /plan can reopen it later.',
+    answer: 'Pause project planning for this workspace and continue without the planning panel.',
+    kind: 'dismiss',
+  });
+  return actions;
+}