@causyne/agent 1.10.17 → 1.10.19

package/src/tui/banner.ts

@@ -0,0 +1,407 @@
+/**
+ * Canonical Causyne Agent terminal identity: aperture, pixel wordmark, status,
+ * and adaptive fallbacks. TypeScript is the source; the repository build emits
+ * the readable ESM file imported by the CLI.
+ *
+ * Environment: NO_COLOR, CAUSYNE_NO_COLOR, FORCE_COLOR=1|2|3,
+ * CAUSYNE_ASCII=1 (7-bit only), and CAUSYNE_NO_ANIM=1.
+ */
+import { homedir } from 'node:os';
+
+export type ColorMode = 'truecolor' | '256' | '16' | 'none';
+export type Variant = 'full' | 'compact' | 'mini';
+
+export interface BannerInfo {
+  version?: string;
+  provider?: string;
+  model?: string;
+  mode?: string;
+  cwd?: string;
+  autonomyMode?: string;
+  tier?: string;
+  workspace?: string;
+}
+export interface BannerOptions extends BannerInfo {
+  /** 'auto' picks from the terminal size: full >= 80x24, compact >= 44 cols, otherwise mini. */
+  variant?: Variant | 'auto';
+  /** 'auto' honours NO_COLOR / FORCE_COLOR / TTY / COLORTERM. */
+  color?: ColorMode | 'auto' | boolean;
+  unicode?: boolean; width?: number; height?: number;
+  /** Which blade is lime (0-5, clockwise from top-right). Used by the boot animation. */
+  active?: number;
+  animate?: boolean; frameMs?: number;
+  /** Print even when stdout is not a TTY. */
+  force?: boolean;
+}
+export interface TermStream { isTTY?: boolean; columns?: number; rows?: number; getColorDepth?: () => number; write(chunk: string): unknown }
+export interface Caps { tty: boolean; width: number; height: number; color: ColorMode; unicode: boolean; variant: Variant }
+
+type Key = 'lime' | 'gray' | 'white' | 'dim';
+type Px = Key | null;
+type Canvas = Px[][];
+type Font = Record<string, readonly string[]>;
+type RGB = readonly [number, number, number];
+
+export const TAGLINE = 'From intention to meaningful progress.';
+
+// ---- Logo -----------------------------------------------------------------------------------------------
+// One character = one "pixel". A terminal cell holds two stacked pixels (drawn with the half blocks ▀ ▄ █).
+// '.' is empty, 0-5 is the blade id. Blade 0 is the lime one (top-right); ids run clockwise.
+const LOGO_L: readonly string[] = [
+  '......................',
+  '.........5555.........',
+  '.......555555.........',
+  '.....5555555.0000.....',
+  '....5555555.0000000...',
+  '...5555555.000000000..',
+  '....55555.00000000000.',
+  '.44.5555.......000000.',
+  '.444.55...........000.',
+  '.444..5........111..0.',
+  '.4444..........11111..',
+  '.4444...........11111.',
+  '.44444...........1111.',
+  '.444444..........1111.',
+  '..44444........2..111.',
+  '......4........22.111.',
+  '.3333.........222..11.',
+  '.33333333333.22222.11.',
+  '..333333333.2222222...',
+  '....333333.2222222....',
+  '.....3333.2222222.....',
+  '.........222222.......',
+  '.........2222.........',
+  '......................',
+];
+const LOGO_S: readonly string[] = [
+  '..................',
+  '.......555........',
+  '.....55555..0.....',
+  '...555555.00000...',
+  '...55555.0000000..',
+  '.4.5555..00000000.',
+  '.44.55.......0000.',
+  '.44.55......1...0.',
+  '.444........1111..',
+  '.444.........1111.',
+  '.4444.........111.',
+  '.44444........111.',
+  '...444......22.11.',
+  '.33.........22.11.',
+  '.333333333.2222.1.',
+  '..3333333.22222...',
+  '...33333.222222...',
+  '.....33.22222.....',
+  '........222.......',
+  '..................',
+];
+
+// ---- Wordmark: pixel fonts ('#' = lit pixel). CAUSYNE is 6x7, AGENT is 5x5. The A has no crossbar, like the brand wordmark.
+const F7: Font = {
+  C: ['.####.', '#....#', '#.....', '#.....', '#.....', '#....#', '.####.'],
+  A: ['..##..', '.#..#.', '.#..#.', '#....#', '#....#', '#....#', '#....#'],
+  U: ['#....#', '#....#', '#....#', '#....#', '#....#', '#....#', '.####.'],
+  S: ['.#####', '#.....', '#.....', '.####.', '.....#', '.....#', '#####.'],
+  Y: ['#....#', '.#..#.', '..##..', '..##..', '..##..', '..##..', '..##..'],
+  N: ['#....#', '##...#', '#.#..#', '#..#.#', '#...##', '#....#', '#....#'],
+  E: ['######', '#.....', '#.....', '####..', '#.....', '#.....', '######'],
+};
+const F5: Font = {
+  A: ['..#..', '.#.#.', '.#.#.', '#...#', '#...#'],
+  G: ['.####', '#....', '#.###', '#...#', '.###.'],
+  E: ['#####', '#....', '###..', '#....', '#####'],
+  N: ['#...#', '##..#', '#.#.#', '#..##', '#...#'],
+  T: ['#####', '..#..', '..#..', '..#..', '..#..'],
+};
+
+// ---- Colour ---------------------------------------------------------------------------------------------
+const ESC = '\x1b[';
+const RESET = ESC + '0m';
+const PAL: Record<Key, RGB> = { lime: [182, 224, 111], gray: [95, 102, 114], white: [244, 246, 248], dim: [140, 148, 160] };
+const C16: Record<Key, number> = { lime: 92, gray: 90, white: 97, dim: 90 };
+const STRONG: Record<Key, boolean> = { lime: true, white: true, gray: false, dim: false };
+const LV = [0, 95, 135, 175, 215, 255] as const;
+const FORCE: Record<string, ColorMode> = { '0': 'none', false: 'none', '1': '16', true: '16', '2': '256', '3': 'truecolor' };
+
+function to256(c: RGB): number {
+  const [r, g, b] = c;
+  const near = (v: number): number => LV.reduce<number>((bi, x, i) => (Math.abs(x - v) < Math.abs((LV[bi] ?? 0) - v) ? i : bi), 0);
+  const ri = near(r), gi = near(g), bi = near(b), cube = 16 + 36 * ri + 6 * gi + bi;
+  const gl = Math.max(0, Math.min(23, Math.round(((r + g + b) / 3 - 8) / 10))), gv = 8 + 10 * gl;
+  const dc = (r - (LV[ri] ?? 0)) ** 2 + (g - (LV[gi] ?? 0)) ** 2 + (b - (LV[bi] ?? 0)) ** 2;
+  const dg = (r - gv) ** 2 + (g - gv) ** 2 + (b - gv) ** 2;
+  return dg < dc ? 232 + gl : cube;
+}
+function fgCode(k: Key, d: ColorMode): string {
+  const rgb = PAL[k];
+  return d === 'truecolor' ? `38;2;${rgb.join(';')}` : d === '256' ? `38;5;${to256(rgb)}` : String(C16[k]);
+}
+function bgCode(k: Key, d: ColorMode): string {
+  const rgb = PAL[k];
+  return d === 'truecolor' ? `48;2;${rgb.join(';')}` : d === '256' ? `48;5;${to256(rgb)}` : String(C16[k] + 10);
+}
+
+// ---- Capability detection -------------------------------------------------------------------------------
+function pickVariant(c: Pick<Caps, 'width' | 'height' | 'unicode'>): Variant {
+  if (c.width < 44 || c.height < 14) return 'mini';
+  if (c.width < 80 || c.height < 24 || !c.unicode) return 'compact';
+  return 'full';
+}
+export function detect(o: BannerOptions = {}, stream: TermStream = process.stdout): Caps {
+  const env = process.env, tty = Boolean(stream.isTTY);
+  const width = o.width || stream.columns || 80, height = o.height || stream.rows || 24;
+  const want = o.color;
+  let color: ColorMode;
+  if (want === true) color = 'truecolor';
+  else if (want === false) color = 'none';
+  else if (want !== undefined && want !== 'auto') color = want;
+  else {
+    const f = env['FORCE_COLOR'];
+    if (f !== undefined && f !== '') color = FORCE[f] ?? '16';
+    else if (env['NO_COLOR'] || env['CAUSYNE_NO_COLOR'] === '1') color = 'none';
+    else if (!tty || env['TERM'] === 'dumb') color = 'none';
+    else {
+      const d = stream.getColorDepth?.() ?? 4;
+      color = /truecolor|24bit/i.test(env['COLORTERM'] ?? '') || d >= 24 ? 'truecolor' : d >= 8 ? '256' : d >= 4 ? '16' : 'none';
+    }
+  }
+  let unicode = o.unicode;
+  if (unicode === undefined) {
+    const loc = env['LC_ALL'] || env['LC_CTYPE'] || env['LANG'] || '', ascii = env['CAUSYNE_ASCII'];
+    unicode = !(ascii && ascii !== '0') && !(process.platform !== 'win32' && loc !== '' && !/utf-?8/i.test(loc));
+  }
+  const caps: Caps = { tty, width, height, color, unicode, variant: 'full' };
+  caps.variant = o.variant && o.variant !== 'auto' ? o.variant : pickVariant(caps);
+  return caps;
+}
+
+// ---- Pixel canvas -> terminal cells ---------------------------------------------------------------------
+const blank = (w: number, h: number): Canvas => Array.from({ length: h }, () => Array<Px>(w).fill(null));
+function blit(dst: Canvas, src: Canvas, x: number, y: number): void {
+  src.forEach((row, j) => row.forEach((k, i) => { const d = dst[y + j]; if (d && k) d[x + i] = k; }));
+}
+const pixLogo = (g: readonly string[], active: number): Canvas => g.map((r) => [...r].map((ch): Px => (ch === '.' ? null : Number(ch) === active ? 'lime' : 'gray')));
+function pixText(str: string, font: Font, h: number, gap: number, key: Key): Canvas {
+  const rows: Canvas = Array.from({ length: h }, () => []);
+  [...str].forEach((ch, i) => {
+    const glyph = font[ch];
+    if (!glyph) return;
+    rows.forEach((row, y) => {
+      if (i) for (let k = 0; k < gap; k++) row.push(null);
+      for (const c of glyph[y] ?? '') row.push(c === '#' ? key : null);
+    });
+  });
+  return rows;
+}
+function cells(px: Canvas, caps: Caps): string[] {
+  const { color, unicode } = caps, lines: string[] = [];
+  for (let y = 0; y < px.length; y += 2) {
+    const top = px[y] ?? [], bot = px[y + 1] ?? [], w = Math.max(top.length, bot.length);
+    let s = '', fg: Key | null = null, bg: Key | null = null;
+    for (let x = 0; x < w; x++) {
+      const t = top[x] ?? null, b = bot[x] ?? null;
+      let ch = ' ', f: Key | null = null, g: Key | null = null;
+      if (t || b) {
+        if (unicode) {
+          if (color === 'none') ch = t && b ? ((t && STRONG[t]) || (b && STRONG[b]) ? '█' : '▒') : t ? '▀' : '▄';
+          else if (t === b) { ch = '█'; f = t; }
+          else if (!b) { ch = '▀'; f = t; }
+          else if (!t) { ch = '▄'; f = b; }
+          else { ch = '▀'; f = t; g = b; }
+        } else {
+          const k: Key | null = (t && STRONG[t] ? t : null) || (b && STRONG[b] ? b : null) || t || b, st = k ? STRONG[k] : false;
+          ch = t && b ? (st ? '@' : '%') : t ? (st ? "'" : '"') : st ? '.' : ',';
+          f = color === 'none' ? null : k;
+        }
+      }
+      if (color !== 'none') {
+        if (g !== bg) { s += ESC + (g ? bgCode(g, color) : '49') + 'm'; bg = g; }
+        if (f && f !== fg) { s += ESC + fgCode(f, color) + 'm'; fg = f; }
+      }
+      s += ch;
+    }
+    if (fg || bg) s += RESET;
+    lines.push(s);
+  }
+  return lines;
+}
+function txt(str: string, key: Key, caps: Caps, maxw?: number, bold?: boolean): string {
+  if (maxw !== undefined && str.length > maxw) str = str.slice(0, Math.max(0, maxw - 1)) + (caps.unicode ? '…' : '~');
+  if (caps.color === 'none') return str;
+  return ESC + (bold ? '1;' : '') + fgCode(key, caps.color) + 'm' + str + RESET;
+}
+
+// ---- Status line ----------------------------------------------------------------------------------------
+function shortPath(p: string, maxw: number): string {
+  const home = homedir();
+  if (home && (p === home || p.startsWith(home + '/') || p.startsWith(home + '\\'))) p = '~' + p.slice(home.length);
+  if (p.length <= maxw) return p;
+  return (maxw > 4 ? '...' : '') + p.slice(p.length - Math.max(1, maxw - 3));
+}
+function statusLine(info: BannerInfo, maxw: number, unicode: boolean): string {
+  const sep = unicode ? '  ·  ' : '  |  ';
+  const parts = [info.version ? 'v' + String(info.version).replace(/^v/, '') : '', [info.provider, info.model].filter(Boolean).join('/'), info.mode ?? '', info.cwd ?? ''].filter(Boolean);
+  const fits = (): boolean => parts.join(sep).length <= maxw;
+  if (!fits() && info.cwd) {
+    const others = parts.slice(0, -1).join(sep).length + (parts.length > 1 ? sep.length : 0);
+    parts[parts.length - 1] = shortPath(info.cwd, Math.max(8, maxw - others));
+  }
+  while (!fits() && parts.length > 1) parts.pop();
+  return parts.join(sep);
+}
+
+// ---- Layouts --------------------------------------------------------------------------------------------
+function layoutFull(caps: Caps, info: BannerInfo, active: number): string[] {
+  const R = LOGO_L.length / 2, logo = cells(pixLogo(LOGO_L, active), caps), gap = '   ';
+  const right = blank(48, R * 2);
+  blit(right, pixText('CAUSYNE', F7, 7, 1, 'white'), 0, 2); // rows 1-4
+  blit(right, pixText('AGENT', F5, 5, 2, 'lime'), 0, 12); // rows 6-8
+  // Keep the metadata inside the wordmark's 48-pixel measure. Letting a long
+  // workspace consume every spare terminal column made the mark look detached
+  // from its own status line and prevented the prompt from widening once a
+  // session began.
+  const maxw = Math.min(48, caps.width - 2 - (LOGO_L[0]?.length ?? 0) - gap.length);
+  return cells(right, caps).map((tail, r) => {
+    if (r === R - 2) tail = txt(TAGLINE, 'dim', caps, maxw);
+    if (r === R - 1) tail = txt(statusLine(info, maxw, caps.unicode), 'dim', caps, maxw);
+    return ' ' + (logo[r] ?? '') + gap + tail;
+  });
+}
+function layoutCompact(caps: Caps, info: BannerInfo, active: number): string[] {
+  const logo = cells(pixLogo(LOGO_S, active), caps), gap = '   ';
+  const maxw = Math.max(10, caps.width - 2 - (LOGO_S[0]?.length ?? 0) - gap.length), wide = maxw >= 24;
+  return logo.map((l, r) => {
+    let tail = '';
+    if (r === 3) tail = txt(wide ? 'C A U S Y N E' : 'CAUSYNE', 'white', caps, undefined, true) + txt(wide ? '  A G E N T' : ' AGENT', 'lime', caps, undefined, true);
+    else if (r === 4) tail = txt(TAGLINE, 'dim', caps, maxw);
+    else if (r === 6) tail = txt(statusLine(info, maxw, caps.unicode), 'dim', caps, maxw);
+    return ' ' + l + (tail ? gap + tail : '');
+  });
+}
+function layoutMini(caps: Caps, info: BannerInfo): string[] {
+  const ver = info.version ? '  v' + String(info.version).replace(/^v/, '') : '';
+  let line = txt(caps.unicode ? '■' : '#', 'lime', caps) + ' ' + txt('CAUSYNE', 'white', caps, undefined, true) + txt(' AGENT', 'lime', caps, undefined, true);
+  if (ver && 'x CAUSYNE AGENT'.length + ver.length <= caps.width - 2) line += txt(ver, 'dim', caps);
+  return [' ' + line];
+}
+
+// ---- Public API -----------------------------------------------------------------------------------------
+/** Returns the banner as a string (no trailing newline). */
+export function renderBanner(o: BannerOptions = {}, stream: TermStream = process.stdout): string {
+  const caps = detect(o, stream), active = o.active ?? 0;
+  if (caps.variant === 'full' && !caps.unicode) caps.variant = 'compact';
+  const lines = caps.variant === 'mini' ? layoutMini(caps, o) : caps.variant === 'compact' ? layoutCompact(caps, o, active) : layoutFull(caps, o, active);
+  return lines.join('\n');
+}
+
+/**
+ * Preserve the TUI's established banner API while rendering the canonical
+ * aperture and wordmark above. The returned rows are ordinary terminal history;
+ * callers decide when to write them and never need to repaint the screen.
+ */
+export function wordmark(width = 80, options: Pick<BannerOptions, 'unicode' | 'color' | 'height'> = {}): string[] {
+  return renderBanner({ ...options, width, height: options.height ?? 24 }, process.stdout).split('\n');
+}
+
+/** A single display spelling for configured providers. */
+export function providerLabel(provider: unknown): string {
+  const raw = String(provider ?? '').trim();
+  if (!raw) return '';
+  const known: Record<string, string> = {
+    openai: 'OpenAI', anthropic: 'Anthropic', gemini: 'Gemini', ollama: 'Ollama',
+    deepseek: 'DeepSeek', dashscope: 'DashScope', 'dashscope-byok': 'DashScope',
+    qwen: 'Qwen', xai: 'xAI', grok: 'xAI', moonshot: 'Moonshot', kimi: 'Moonshot',
+    muse: 'Meta', meta: 'Meta', 'openai-compatible': 'OpenAI-compatible'
+  };
+  return known[raw.toLowerCase()] ?? raw;
+}
+
+function sessionInfo(info: BannerInfo): BannerInfo {
+  const provider = providerLabel(info.provider);
+  const modeParts = [
+    info.autonomyMode ? `mode ${info.autonomyMode}` : info.mode,
+    info.tier ? `tier ${info.tier}` : undefined
+  ].filter((part): part is string => Boolean(part));
+  return {
+    ...(info.version ? { version: info.version } : {}),
+    ...(provider ? { provider } : {}),
+    ...(info.model ? { model: info.model } : {}),
+    ...(modeParts.length ? { mode: modeParts.join(' / ') } : {}),
+    ...(info.workspace || info.cwd ? { cwd: info.workspace ?? info.cwd } : {})
+  };
+}
+
+/** Render the adaptive session identity block used by ChatRenderer. */
+export function sessionBanner(
+  info: BannerInfo = {},
+  width = 80,
+  options: Pick<BannerOptions, 'unicode' | 'color' | 'height'> = {}
+): string[] {
+  const height = options.height ?? process.stdout.rows ?? 24;
+  // The chat surface also needs room for its input band and hint row. The
+  // standalone renderer keeps the source design's 80x24 full-banner threshold,
+  // while the integrated session header chooses the same artwork at a size that
+  // cannot push the first prompt off short terminals.
+  const variant: Variant = height < 22 || width < 44
+    ? 'mini'
+    : width < 96 || height < 28 || options.unicode === false
+      ? 'compact'
+      : 'full';
+  return renderBanner({
+    ...sessionInfo(info),
+    ...options,
+    variant,
+    width,
+    height
+  }, process.stdout).split('\n');
+}
+
+/** Prints the banner. Returns false (prints nothing) when stdout is not a TTY, unless `force` is set. */
+export function printBanner(o: BannerOptions = {}, stream: TermStream = process.stdout): boolean {
+  if (!stream.isTTY && !o.force) return false;
+  stream.write(renderBanner(o, stream) + '\n');
+  return true;
+}
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** Optional standalone boot animation. The main chat TUI deliberately writes once to preserve scrollback. */
+export async function animateBanner(o: BannerOptions = {}, stream: TermStream = process.stdout): Promise<boolean> {
+  const caps = detect(o, stream), env = process.env;
+  if (!stream.isTTY || caps.color === 'none' || !caps.unicode || caps.variant === 'mini' || o.animate === false || env['CI'] || env['CAUSYNE_NO_ANIM'] || env['TERM'] === 'dumb') return printBanner(o, stream);
+  const frames = [0, 1, 2, 3, 4, 5, 0].map((active) => renderBanner({ ...o, active }, stream).split('\n'));
+  const first = frames[0] ?? [], count = first.length, show = (): void => { stream.write('\x1b[?25h'); };
+  process.once('exit', show);
+  try {
+    stream.write('\x1b[?25l' + first.join('\n') + '\n');
+    for (const frame of frames.slice(1)) {
+      await sleep(o.frameMs ?? 70);
+      stream.write(`\x1b[${count}A` + frame.map((line) => line + '\x1b[K').join('\n') + '\n');
+    }
+  } finally {
+    show();
+    process.removeListener('exit', show);
+  }
+  return true;
+}
+
+export const EXAMPLES = [
+  'summarise what changed in this repo today',
+  'find every TODO left in src/ and group them by file',
+  'explain what this project does and how it is wired',
+  'run the tests and tell me what broke',
+  'review my last commit for anything risky'
+] as const;
+
+/** One example, chosen once per session rather than once per keystroke. */
+export function pickExample(): string {
+  return EXAMPLES[Math.floor(Math.random() * EXAMPLES.length)] ?? EXAMPLES[0];
+}
+
+/** Drop complete hint fragments until the remaining line fits. */
+export function fitHints(parts: string[], width: number, fallback: string): string {
+  const separator = '  ·  ';
+  const kept = parts.slice();
+  while (kept.length > 1 && kept.join(separator).length > width) kept.pop();
+  const line = kept.join(separator);
+  return line.length <= width ? line : fallback;
+}

package/src/tui/chatRenderer.js

@@ -211,6 +211,7 @@ export class ChatRenderer {
     this.spinnerIndex = 0;
     this.currentStatus = '';
     this.pendingApprovals = new Map();
+    this.latestPlan = [];
     this.status = new StatusLine();
     this.turnStartedAt = null;
 
@@ -383,7 +384,7 @@ export class ChatRenderer {
     // nineteen rows of chrome before the user could type. Both references open
     // in eight or fewer, with the identity and the facts as a single object.
     this.write();
-    for (const row of sessionBanner(info, width)) this.write(row);
+    for (const row of sessionBanner(info, width, { height: this.out?.rows })) this.write(row);
     this.write();
 
     const hints = [
@@ -548,9 +549,34 @@ export class ChatRenderer {
   onAgentPlan(msg) {
     if (!Array.isArray(msg.plan) || msg.plan.length === 0) return;
     const plan = msg.plan.slice();
+    this.latestPlan = plan;
+    if (this.onPlanChange) this.onPlanChange(plan);
     this.frame('plan', () => this.renderPlan(plan), { items: plan.length });
   }
 
+  onDecisionRequest(msg) {
+    if (this.dialogWillAsk) return;
+    const request = msg.request || {};
+    this.frame('approval', () => {
+      this.write();
+      this.write(`${paint('accent', GLYPHS.arrow)} ${bold(safeDisplay(request.header || 'decision required'))}`);
+      for (const row of wrapBlock(safeDisplay(request.question || ''), Math.max(20, this.width() - 4))) this.write(`  ${row}`);
+      this.write();
+    }, { kind: request.kind || 'other' });
+  }
+
+  onDecisionResult(msg) {
+    const request = msg.request || {};
+    const answer = msg.answer;
+    this.frame('approval', () => {
+      if (!answer) {
+        this.write(`  ${paint('muted', 'decision dismissed')}  ${safeDisplay(request.header || '')}`);
+        return;
+      }
+      this.write(`  ${paint('success', GLYPHS.check)} ${bold(safeDisplay(answer.label || ''))}${answer.custom ? dim('  custom choice') : ''}`);
+    }, { kind: request.kind || 'other', answered: Boolean(answer) });
+  }
+
   renderPlan(plan) {
     const width = this.width();
     this.write();
@@ -940,6 +966,8 @@ export class ChatRenderer {
       case 'step_error':       this.onStepError(msg); return true;
       case 'checkpoint':       this.onCheckpoint(msg); return true;
       case 'approval_request': this.onApprovalRequest(msg); return true;
+      case 'decision_request': this.onDecisionRequest(msg); return true;
+      case 'decision_result':  this.onDecisionResult(msg); return true;
       case 'error':            this.onError(msg); return true;
       case 'budget_warning':   this.onBudgetWarning(msg); return true;
       case 'notice':           this.onNotice(msg); return true;

package/src/tui/dialogs.js

@@ -489,6 +489,97 @@ export class ApprovalLayer extends Layer {
   }
 }
 
+/** A structured product or architecture choice, separate from permissions. */
+export class DecisionLayer extends Layer {
+  constructor(options = {}) {
+    super({ width: options.width || 82, height: options.height || 24, ...options });
+    this.request = options.request || {};
+    this.onAnswer = options.onAnswer || null;
+    this.options = Array.isArray(this.request.options) ? this.request.options.slice(0, 4) : [];
+    this.selected = 0;
+    this.customIndex = this.options.length;
+    this.customMode = false;
+    this.editor = new LineEditor();
+    this.answered = false;
+    this.title = safeDisplay(this.request.header || 'decision required');
+    this.footer = `↑↓ choose  ${GLYPHS.dot}  enter select  ${GLYPHS.dot}  esc cancel`;
+  }
+
+  preferredHeight() {
+    const questionRows = wrap(safeDisplay(this.request.question || ''), Math.max(20, this.width - 6)).length;
+    const reasonRows = wrap(safeDisplay(this.request.reason || ''), Math.max(20, this.width - 6)).length;
+    return Math.min(this.height, questionRows + reasonRows + (this.options.length * 2) + 7);
+  }
+
+  body(width, height) {
+    const rows = [];
+    rows.push(...wrap(bold(safeDisplay(this.request.question || 'Choose a direction')), width).slice(0, 4));
+    if (this.request.reason) rows.push(...wrap(dim(safeDisplay(this.request.reason)), width).slice(0, 3));
+    rows.push('');
+
+    for (const [index, option] of this.options.entries()) {
+      const selected = index === this.selected;
+      const marker = selected ? paint('accent', GLYPHS.arrow) : paint('muted', GLYPHS.dot);
+      rows.push(`${marker} ${selected ? bold(safeDisplay(option.label || '')) : safeDisplay(option.label || '')}`);
+      if (option.description) rows.push(`  ${dim(truncate(safeDisplay(option.description), Math.max(1, width - 2), GLYPHS.ellipsis))}`);
+    }
+
+    const customSelected = this.selected === this.customIndex;
+    rows.push(`${customSelected ? paint('accent', GLYPHS.arrow) : paint('muted', GLYPHS.dot)} ${customSelected ? bold('Type your own answer') : 'Type your own answer'}`);
+    if (this.customMode) {
+      const value = this.editor.getText();
+      rows.push(`${paint('accent', `${GLYPHS.arrow} `)}${value || dim('Describe the direction you want')}`);
+      this.cursor = { x: 2 + visibleWidth(value.slice(0, this.editor.col)), y: rows.length - 1 };
+      this.footer = `enter submit  ${GLYPHS.dot}  esc choices`;
+    } else {
+      this.cursor = null;
+      this.footer = `↑↓ choose  ${GLYPHS.dot}  enter select  ${GLYPHS.dot}  esc cancel`;
+    }
+    return rows.slice(0, height);
+  }
+
+  key(event) {
+    if (!event) return null;
+    if (this.customMode) {
+      if (event.name === 'escape') { this.customMode = false; return 'handled'; }
+      if (event.name === 'enter' || event.name === 'return') {
+        const label = this.editor.getText().replace(/\s+/g, ' ').trim();
+        if (!label) return 'handled';
+        this.answer({ requestId: this.request.id, optionId: null, label, custom: true });
+        return 'close';
+      }
+      if (event.name === 'backspace') { this.editor.backspace(); return 'handled'; }
+      if (event.name === 'delete') { this.editor.deleteForward(); return 'handled'; }
+      if (event.name === 'left') { this.editor.moveLeft(); return 'handled'; }
+      if (event.name === 'right') { this.editor.moveRight(); return 'handled'; }
+      if (event.name === 'home') { this.editor.moveHome(); return 'handled'; }
+      if (event.name === 'end') { this.editor.moveEnd(); return 'handled'; }
+      if (event.name === 'paste') { this.editor.insert(event.text); return 'handled'; }
+      if (event.name === 'char') { this.editor.insert(event.text); return 'handled'; }
+      return 'handled';
+    }
+
+    if (event.name === 'escape') { this.answer(null); return 'close'; }
+    const count = this.options.length + 1;
+    if (event.name === 'up') { this.selected = (this.selected - 1 + count) % count; return 'handled'; }
+    if (event.name === 'down') { this.selected = (this.selected + 1) % count; return 'handled'; }
+    if (event.name === 'enter' || event.name === 'return') {
+      if (this.selected === this.customIndex) { this.customMode = true; return 'handled'; }
+      const option = this.options[this.selected];
+      if (!option) return 'handled';
+      this.answer({ requestId: this.request.id, optionId: option.id, label: option.label, custom: false });
+      return 'close';
+    }
+    return 'handled';
+  }
+
+  answer(value = null) {
+    if (this.answered) return;
+    this.answered = true;
+    if (this.onAnswer) this.onAnswer(value);
+  }
+}
+
 /** A yes/no confirm, for destructive commands that are not tool approvals. */
 export class ConfirmLayer extends Layer {
   constructor(options = {}) {

package/src/tui/prompt.js

@@ -26,7 +26,7 @@ import { barBlock, GUTTER } from './block.js';
 import { visibleWidth, truncate, wrapBlock, shortenHome, safeDisplay } from './text.js';
 import { pickExample, fitHints } from './banner.js';
 import { panelRows } from './overlay.js';
-import { commandPalette, skillPicker, ApprovalLayer, ConfirmLayer, HomeLayer, TextLayer } from './dialogs.js';
+import { commandPalette, skillPicker, ApprovalLayer, DecisionLayer, ConfirmLayer, HomeLayer, TextLayer } from './dialogs.js';
 import { describeTool } from './toolDisplay.js';
 
 const CTRL_C_WINDOW_MS = 2000;
@@ -264,6 +264,7 @@ export class ChatPrompt {
       this.statusMessage = message;
       this.scheduleDraw();
     };
+    renderer.onPlanChange = () => this.scheduleDraw();
   }
 
   /**
@@ -321,6 +322,26 @@ export class ChatPrompt {
     return visibleWidth(full) > width ? truncate(full, width, GLYPHS.ellipsis) : full;
   }
 
+  /** Persistent checklist shown outside the chat transcript. */
+  planRows(width) {
+    const plan = this.renderer && Array.isArray(this.renderer.latestPlan) ? this.renderer.latestPlan : [];
+    if (plan.length === 0) return [];
+    const completed = plan.filter(item => item.status === 'completed').length;
+    const rows = [`${bold(paint('accent', 'implementation plan'))}  ${dim(`${completed}/${plan.length}`)}`];
+    const limit = Math.min(plan.length, 5);
+    for (const item of plan.slice(0, limit)) {
+      const mark = item.status === 'completed'
+        ? paint('success', GLYPHS.check)
+        : item.status === 'in_progress'
+          ? paint('accent', GLYPHS.arrow)
+          : paint('muted', GLYPHS.dot);
+      rows.push(`  ${mark} ${truncate(safeDisplay(item.text || item.step || ''), Math.max(8, width - 5), GLYPHS.ellipsis)}`);
+    }
+    if (plan.length > limit) rows.push(`  ${dim(`${GLYPHS.ellipsis} ${plan.length - limit} more`)}`);
+    rows.push('');
+    return rows;
+  }
+
   startTick() {
     if (this.tickTimer) return;
     this.tickTimer = setInterval(() => {
@@ -456,6 +477,13 @@ export class ChatPrompt {
     });
   }
 
+  /** Ask for a durable implementation choice, with a free-form option. */
+  decide(request = {}) {
+    return new Promise((resolve) => {
+      this.openLayer(new DecisionLayer({ request, onAnswer: resolve }));
+    });
+  }
+
   /** A plain yes/no, for the questions that are not tool approvals. */
   confirm(message, options = {}) {
     return new Promise((resolve) => {
@@ -1136,12 +1164,13 @@ export class ChatPrompt {
     const status = this.statusRow(width);
     const gap = status.length > 0 ? new Array(FOOTER_GAP).fill('') : [];
 
+    const planRows = this.planRows(width);
     const all = this.clampRows(
-      boxRows.concat(pickerRows, noticeRows, gap, status), width
+      planRows.concat(boxRows, pickerRows, noticeRows, gap, status), width
     );
 
     // Park the cursor where the user is typing, not at the end of the picker.
-    this.present(all, caretRow + padTop, layout.cursorCol + inset);
+    this.present(all, planRows.length + caretRow + padTop, layout.cursorCol + inset);
   }
 
   /**

package/src/tui/toolDisplay.js

@@ -82,7 +82,6 @@ const TOOL_DISPLAY = new Map([
   ['code_verify_syntax',  (a) => ({ verb: 'verify', detail: pathDetail(firstString(a, ['path', 'file_path'])) })],
 
   ['memory_write',  (a) => ({ verb: 'remember', detail: firstString(a, ['fact', 'key', 'project']) })],
-  ['TodoWrite',     (a) => ({ verb: 'plan',     detail: countDetail(a.todos, 'item') })],
   ['update_plan',   (a) => ({ verb: 'plan',     detail: countDetail(a.plan, 'step') })],
   ['tool_search',   (a) => ({ verb: 'discover', detail: firstString(a, ['query', 'description']) })],
   ['fs_read_skill', (a) => ({ verb: 'skill',    detail: firstString(a, ['id', 'skillId', 'domain']) })],