@xenonbyte/da-vinci-workflow 0.2.2 → 0.2.4

package/tui/index.js

@@ -1,15 +1,17 @@
+const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const readline = require("readline");
 const { spawnSync } = require("child_process");
+const { version: PACKAGE_VERSION } = require("../package.json");
 const {
+  SCENES,
   COMMANDS,
-  STAGES,
   buildCommandArgs,
   buildDisplayCommand,
   getCommandParameterItems,
   getCommandById,
   getDefaultLanguage,
-  getStageById,
   hasPlaceholders,
   normalizeLanguage,
   resolveLocalizedText,
@@ -17,112 +19,282 @@ const {
 } = require("./catalog");
 
 const DA_VINCI_BIN = path.resolve(__dirname, "..", "bin", "da-vinci.js");
+const PREFERENCES_PATH = path.join(os.homedir(), ".da-vinci", "tui-preferences.json");
+const LOGS_DIR_RELATIVE = path.join(".da-vinci", "logs");
+const BRAND_LOGO_MIN_INNER_WIDTH = 51;
+const MIN_TUI_WIDTH = 36;
+const DEFAULT_TUI_WIDTH = 100;
+const MIN_TUI_HEIGHT = 16;
+const DEFAULT_TUI_HEIGHT = 40;
+
+const PROMPT_PRESET_FILES = {
+  mobile: "mobile-app.md",
+  desktop: "desktop-app.md",
+  tablet: "tablet-app.md",
+  web: "web-app.md"
+};
+
+const PROMPT_MODE_TO_HEADING = {
+  mode1: "Simple Redesign",
+  mode2: "Complex Redesign",
+  mode3: "Redesign With Reference Directory",
+  mode4: "Design-Only",
+  mode5: "Continue"
+};
+
+const QUALITY_TO_VARIANT = {
+  normal: 1,
+  "high quality": 2,
+  masterpiece: 3
+};
+
+const DESIGN_PLATFORM_OPTIONS = [
+  {
+    value: "mobile",
+    label: { en: "Mobile", zh: "移动端" }
+  },
+  {
+    value: "desktop",
+    label: { en: "Desktop", zh: "桌面端" }
+  },
+  {
+    value: "tablet",
+    label: { en: "Tablet", zh: "平板端" }
+  },
+  {
+    value: "web",
+    label: { en: "Web", zh: "Web 端" }
+  }
+];
+
+const DESIGN_QUALITY_OPTIONS = [
+  {
+    value: "normal",
+    variant: 1,
+    label: { en: "Normal", zh: "普通" }
+  },
+  {
+    value: "high quality",
+    variant: 2,
+    label: { en: "High Quality", zh: "高质量" }
+  },
+  {
+    value: "masterpiece",
+    variant: 3,
+    label: { en: "Masterpiece", zh: "杰作级" }
+  }
+];
+
+const PLATFORM_INSTALL_OPTIONS = [
+  {
+    value: "codex",
+    label: { en: "Codex", zh: "Codex" }
+  },
+  {
+    value: "claude",
+    label: { en: "Claude Code", zh: "Claude Code" }
+  },
+  {
+    value: "gemini",
+    label: { en: "Gemini", zh: "Gemini" }
+  }
+];
 
 const HELP_TEXT = {
   en: [
     "Da Vinci TUI",
     "",
     "Usage:",
-    "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error]",
-    "  da-vinci-tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error]",
+    "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error] [--tui-width <cols>] [--alt-screen|--no-alt-screen]",
+    "  da-vinci-tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error] [--tui-width <cols>] [--alt-screen|--no-alt-screen]",
+    "",
+    "Model:",
+    "  - root menu is scene-first, not command-first",
+    "  - scene pages focus on operator workflows, not raw command browsing",
+    "  - width defaults to current TTY columns; pin via --tui-width",
     "",
     "Keyboard:",
     "  Up/Down or j/k   move selection",
-    "  Enter or r       run selected command",
-    "  m                edit the preview command before running",
-    "  h                show parameters for the selected command",
-    "  p                set project path context",
-    "  c                set change id context",
-    "  l                toggle UI language",
-    "  s                toggle --strict for supported commands",
-    "  J                toggle --json for supported commands",
-    "  e                toggle --continue-on-error for supported commands",
-    "  ?                toggle help overlay",
-    "  q                quit",
-    "",
-    "Notes:",
-    "  - specialized commands keep placeholders such as <pen-path>; press m to edit them before execution",
-    "  - when the TUI starts inside a project root, --project is omitted because CLI commands already fall back to cwd"
+    "  Enter or r       confirm selected menu item",
+    "  Back/exit        use menu items (Back / Exit)",
+    "  t                cycle theme mode",
+    "  l                toggle language",
+    "  p                set project path",
+    "  c                set change id",
+    "  s                toggle --strict",
+    "  J                toggle --json",
+    "  e                toggle --continue-on-error",
+    "  ?                toggle help",
+    "  Ctrl-C           emergency exit"
   ].join("\n"),
   zh: [
     "Da Vinci TUI",
     "",
     "用法：",
-    "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error]",
-    "  da-vinci-tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error]",
+    "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error] [--tui-width <cols>] [--alt-screen|--no-alt-screen]",
+    "  da-vinci-tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error] [--tui-width <cols>] [--alt-screen|--no-alt-screen]",
+    "",
+    "模型：",
+    "  - 首屏按场景组织，不再先暴露命令目录",
+    "  - 场景页聚焦操作流程，不暴露原子命令浏览",
+    "  - 宽度默认跟随当前 TTY 列数；可用 --tui-width 固定",
     "",
     "键位：",
     "  上/下 或 j/k     移动选中项",
-    "  Enter 或 r       执行当前命令",
-    "  m                先编辑预览命令，再执行",
-    "  h                查看当前命令参数",
-    "  p                设置项目路径上下文",
-    "  c                设置 change id 上下文",
-    "  l                切换中英文界面",
-    "  s                为支持的命令切换 --strict",
-    "  J                为支持的命令切换 --json",
-    "  e                为支持的命令切换 --continue-on-error",
-    "  ?                打开或关闭帮助层",
-    "  q                退出",
-    "",
-    "说明：",
-    "  - 特殊命令会保留 <pen-path> 这类占位符，执行前按 m 编辑即可",
-    "  - 当 TUI 在项目根目录启动时，CLI 已默认使用 cwd，所以不会额外拼接 --project"
+    "  Enter 或 r       确认当前菜单项",
+    "  返回/退出         通过菜单项（上一步/退出）",
+    "  t                切换主题",
+    "  l                切换语言",
+    "  p                设置项目路径",
+    "  c                设置 change id",
+    "  s                切换 --strict",
+    "  J                切换 --json",
+    "  e                切换 --continue-on-error",
+    "  ?                打开或关闭帮助",
+    "  Ctrl-C           紧急退出"
   ].join("\n")
 };
 
-function formatTuiHelp(lang) {
-  const normalized = normalizeLanguage(lang || getDefaultLanguage());
-  return HELP_TEXT[normalized];
+const ANSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+
+function detectTerminalThemeMode() {
+  const forced = String(process.env.DA_VINCI_TUI_THEME || "").trim().toLowerCase();
+  if (forced === "light" || forced === "dark" || forced === "mono") {
+    return forced;
+  }
+  const colorfgbg = String(process.env.COLORFGBG || "").trim();
+  if (colorfgbg) {
+    const tokens = colorfgbg
+      .split(";")
+      .map((token) => Number.parseInt(token, 10))
+      .filter((token) => Number.isFinite(token));
+    if (tokens.length > 0) {
+      const background = tokens[tokens.length - 1];
+      if (background >= 7) {
+        return "light";
+      }
+      return "dark";
+    }
+  }
+  return "dark";
 }
 
-function formatCommandParameterHelp(command, lang, width) {
-  const items = getCommandParameterItems(command);
-  const lines = [];
-  const normalized = normalizeLanguage(lang || getDefaultLanguage());
-  lines.push(normalized === "zh" ? "命令参数 (h):" : "Command Parameters (h):");
+function createTheme(mode) {
+  if (mode === "light") {
+    return {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      textStrong: "\x1b[38;5;234m",
+      soft: "\x1b[38;5;238m",
+      muted: "\x1b[38;5;240m",
+      border: "\x1b[38;5;245m",
+      accent: "\x1b[38;5;18m",
+      green: "\x1b[38;5;22m",
+      amber: "\x1b[38;5;94m",
+      red: "\x1b[38;5;88m",
+      info: "\x1b[38;5;24m"
+    };
+  }
+  if (mode === "mono") {
+    return {
+      reset: "\x1b[0m",
+      bold: "",
+      dim: "",
+      textStrong: "",
+      soft: "",
+      muted: "",
+      border: "",
+      accent: "",
+      green: "",
+      amber: "",
+      red: "",
+      info: ""
+    };
+  }
+  return {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    textStrong: "\x1b[38;5;255m",
+    soft: "\x1b[38;5;252m",
+    muted: "\x1b[38;5;244m",
+    border: "\x1b[38;5;240m",
+    accent: "\x1b[38;5;45m",
+    green: "\x1b[38;5;78m",
+    amber: "\x1b[38;5;221m",
+    red: "\x1b[38;5;203m",
+    info: "\x1b[38;5;117m"
+  };
+}
 
-  if (items.length === 0) {
-    lines.push(
-      normalized === "zh"
-        ? "这条命令在 TUI 里没有额外可调参数，直接按预览命令执行即可。"
-        : "This command has no extra adjustable parameters in the TUI. Run it exactly as previewed."
-    );
-    return lines;
+let THEME_MODE = detectTerminalThemeMode();
+let THEME = createTheme(THEME_MODE);
+
+function applyThemeMode(mode) {
+  THEME_MODE = mode;
+  THEME = createTheme(mode);
+}
+
+function cycleThemeMode(mode) {
+  const ordered = ["dark", "light", "mono"];
+  const currentIndex = ordered.indexOf(mode);
+  return ordered[(currentIndex + 1 + ordered.length) % ordered.length];
+}
+
+function supportsAnsiStyling(stream = process.stdout) {
+  return Boolean(stream && stream.isTTY && process.env.NO_COLOR == null);
+}
+
+function paint(text, ...styles) {
+  if (!supportsAnsiStyling()) {
+    return String(text || "");
   }
+  return `${styles.join("")}${text}${THEME.reset}`;
+}
 
-  for (const item of items) {
-    const signature = [item.flag, item.value].filter(Boolean).join(" ");
-    const requirementLabel = item.required
-      ? normalized === "zh"
-        ? "必填"
-        : "required"
-      : normalized === "zh"
-        ? "可选"
-        : "optional";
-    const body = `${signature} [${requirementLabel}]: ${resolveLocalizedText(item.description, normalized)}`;
-    const wrapped = wrapText(body, Math.max(16, width - 4));
-    if (wrapped.length === 0) {
-      continue;
-    }
-    lines.push(`- ${wrapped[0]}`);
-    for (const line of wrapped.slice(1)) {
-      lines.push(`  ${line}`);
-    }
+function stripAnsi(text) {
+  return String(text || "").replace(ANSI_PATTERN, "");
+}
+
+function visibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+function truncatePlain(text, width) {
+  const source = String(text || "");
+  if (source.length <= width) {
+    return source;
+  }
+  if (width <= 1) {
+    return source.slice(0, width);
   }
+  return `${source.slice(0, Math.max(0, width - 1))}…`;
+}
 
-  if (items.some((item) => item.required)) {
-    lines.push(
-      normalized === "zh"
-        ? "提示: 标记为必填的参数通常需要先按 m 编辑命令并补全占位符。"
-        : "Hint: parameters marked required usually need you to press m and replace placeholders before running."
-    );
+function truncateMiddle(text, width) {
+  const source = String(text || "");
+  if (source.length <= width) {
+    return source;
   }
-  return lines;
+  if (width <= 5) {
+    return truncatePlain(source, width);
+  }
+  const left = Math.ceil((width - 1) / 2);
+  const right = Math.max(1, width - left - 1);
+  return `${source.slice(0, left)}…${source.slice(source.length - right)}`;
 }
 
-function clearScreen() {
-  process.stdout.write("\x1b[2J\x1b[H");
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function padVisible(text, width) {
+  const source = String(text || "");
+  const plain = stripAnsi(source);
+  const fitted = plain.length > width ? truncatePlain(plain, width) : source;
+  const missing = Math.max(0, width - visibleLength(fitted));
+  return `${fitted}${" ".repeat(missing)}`;
 }
 
 function wrapText(text, width) {
@@ -156,82 +328,173 @@ function wrapText(text, width) {
   return lines;
 }
 
-function truncate(text, width) {
-  const source = String(text || "");
-  if (source.length <= width) {
-    return source;
+function centerPlain(text, width) {
+  const source = truncatePlain(String(text || ""), width);
+  const missing = Math.max(0, width - source.length);
+  const left = Math.floor(missing / 2);
+  const right = Math.max(0, missing - left);
+  return `${" ".repeat(left)}${source}${" ".repeat(right)}`;
+}
+
+function parsePositiveInteger(value) {
+  const parsed = Number.parseInt(String(value || "").trim(), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
   }
-  if (width <= 1) {
-    return source.slice(0, width);
+  return Math.floor(parsed);
+}
+
+function normalizeLayoutWidth(value) {
+  const parsed = parsePositiveInteger(value);
+  if (!parsed) {
+    return null;
   }
-  return `${source.slice(0, Math.max(0, width - 1))}…`;
+  return Math.max(MIN_TUI_WIDTH, parsed);
 }
 
-function buildCatalogRows(lang) {
-  const rows = [];
-  for (const stage of STAGES) {
-    rows.push({
-      type: "stage",
-      id: stage.id,
-      label: resolveLocalizedText(stage.title, lang)
-    });
-    for (const command of COMMANDS.filter((item) => item.stageId === stage.id)) {
-      rows.push({
-        type: "command",
-        id: command.id,
-        label: resolveLocalizedText(command.title, lang),
-        command
-      });
-    }
+function resolveRenderWidth(state, viewport = {}) {
+  const ttyWidth = parsePositiveInteger(viewport.columns) || parsePositiveInteger(process.stdout.columns) || DEFAULT_TUI_WIDTH;
+  const explicit =
+    normalizeLayoutWidth(viewport.layoutWidth) ||
+    normalizeLayoutWidth(state && state.layoutWidth) ||
+    normalizeLayoutWidth(process.env.DA_VINCI_TUI_WIDTH) ||
+    normalizeLayoutWidth(process.env.DA_VINCI_TUI_LAYOUT_WIDTH);
+  const bounded = explicit ? Math.min(ttyWidth, explicit) : ttyWidth;
+  return Math.max(MIN_TUI_WIDTH, bounded);
+}
+
+function resolveRenderHeight(viewport = {}) {
+  const ttyHeight = parsePositiveInteger(viewport.rows) || parsePositiveInteger(process.stdout.rows) || DEFAULT_TUI_HEIGHT;
+  return Math.max(MIN_TUI_HEIGHT, ttyHeight);
+}
+
+function parseBooleanPreference(value) {
+  if (value === true || value === false) {
+    return value;
   }
-  return rows;
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return null;
 }
 
-function countCommandIndex(rows, rowIndex) {
-  let count = -1;
-  for (let index = 0; index <= rowIndex; index += 1) {
-    if (rows[index] && rows[index].type === "command") {
-      count += 1;
-    }
+function resolveAltScreenMode(options = {}, preferences = {}) {
+  const explicit = parseBooleanPreference(options.altScreen);
+  if (explicit !== null) {
+    return explicit;
   }
-  return count;
+  const persisted = parseBooleanPreference(preferences.altScreen);
+  if (persisted !== null) {
+    return persisted;
+  }
+  const fromEnv = parseBooleanPreference(process.env.DA_VINCI_TUI_ALT_SCREEN);
+  if (fromEnv !== null) {
+    return fromEnv;
+  }
+  return false;
 }
 
-function getRowIndexForCommand(rows, commandIndex) {
-  let seen = -1;
-  for (let index = 0; index < rows.length; index += 1) {
-    if (rows[index].type === "command") {
-      seen += 1;
-      if (seen === commandIndex) {
-        return index;
-      }
-    }
+function createPanel(title, lines, width) {
+  const panelWidth = Math.max(24, width);
+  const innerWidth = panelWidth - 2;
+  const top = `${paint("╔", THEME.border)}${paint("═".repeat(innerWidth), THEME.border)}${paint("╗", THEME.border)}`;
+  const titleLine = title
+    ? `${paint("║", THEME.border)}${paint(centerPlain(title, innerWidth), THEME.accent, THEME.bold)}${paint("║", THEME.border)}`
+    : null;
+  const divider = title
+    ? `${paint("╠", THEME.border)}${paint("═".repeat(innerWidth), THEME.border)}${paint("╣", THEME.border)}`
+    : null;
+  const body = (lines || []).map((line) => `${paint("║", THEME.border)}${padVisible(line, innerWidth)}${paint("║", THEME.border)}`);
+  const bottom = `${paint("╚", THEME.border)}${paint("═".repeat(innerWidth), THEME.border)}${paint("╝", THEME.border)}`;
+  return [top, ...(titleLine ? [titleLine, divider] : []), ...body, bottom];
+}
+
+function enterAlternateScreen() {
+  process.stdout.write("\x1b[?1049h");
+}
+
+function exitAlternateScreen() {
+  process.stdout.write("\x1b[?1049l");
+}
+
+function hideCursor() {
+  process.stdout.write("\x1b[?25l");
+}
+
+function showCursor() {
+  process.stdout.write("\x1b[?25h");
+}
+
+function insetBlock(lines, screenWidth, blockWidth, options = {}) {
+  const align = options.align || "left";
+  const gutter = Number.isFinite(options.gutter) ? Math.max(0, options.gutter) : 0;
+  const left = align === "center" ? Math.max(0, Math.floor((screenWidth - blockWidth) / 2)) : Math.max(0, gutter);
+  const prefix = " ".repeat(left);
+  return (lines || []).map((line) => `${prefix}${line}`);
+}
+
+function createMenuLine(label, selected) {
+  if (selected) {
+    return `${paint("❯", THEME.green, THEME.bold)} ${paint(label, THEME.accent, THEME.bold)}`;
   }
-  return 0;
+  return `${paint("›", THEME.soft)} ${paint(label, THEME.soft)}`;
 }
 
-function getVisibleRows(rows, selectedRowIndex, limit) {
-  if (rows.length <= limit) {
-    return {
-      start: 0,
-      items: rows
-    };
+function formatThemeLabel(mode, lang) {
+  if (lang === "zh") {
+    if (mode === "light") {
+      return "浅色";
+    }
+    if (mode === "mono") {
+      return "单色";
+    }
+    return "深色";
   }
-  const commandWindowStart = Math.max(0, selectedRowIndex - Math.floor(limit / 2));
-  const start = Math.min(commandWindowStart, Math.max(0, rows.length - limit));
-  return {
-    start,
-    items: rows.slice(start, start + limit)
-  };
+  return mode;
 }
 
-function buildPreviewCommand(state) {
-  const command = getCommandById(state.selectedCommandId);
-  return {
-    command,
-    args: buildCommandArgs(command, state),
-    display: buildDisplayCommand(command, state)
-  };
+function formatTuiHelp(lang) {
+  const normalized = normalizeLanguage(lang || getDefaultLanguage());
+  return HELP_TEXT[normalized];
+}
+
+function formatCommandParameterHelp(command, lang, width) {
+  const normalized = normalizeLanguage(lang || getDefaultLanguage());
+  const items = getCommandParameterItems(command);
+  const lines = [];
+  lines.push(normalized === "zh" ? "命令参数 (h):" : "Command Parameters (h):");
+  if (items.length === 0) {
+    lines.push(
+      normalized === "zh"
+        ? "这条命令在 TUI 里没有额外可调参数，直接按预览执行即可。"
+        : "This command has no extra adjustable parameters in the TUI. Run it exactly as previewed."
+    );
+    return lines;
+  }
+  for (const item of items) {
+    const signature = [item.flag, item.value].filter(Boolean).join(" ");
+    const requirementLabel = item.required
+      ? normalized === "zh"
+        ? "必填"
+        : "required"
+      : normalized === "zh"
+        ? "可选"
+        : "optional";
+    const content = `${signature} [${requirementLabel}]: ${resolveLocalizedText(item.description, normalized)}`;
+    const wrapped = wrapText(content, Math.max(16, width - 4));
+    if (wrapped.length === 0) {
+      continue;
+    }
+    lines.push(`- ${wrapped[0]}`);
+    for (const line of wrapped.slice(1)) {
+      lines.push(`  ${line}`);
+    }
+  }
+  return lines;
 }
 
 function normalizeEditedCommand(input) {
@@ -247,15 +510,9 @@ function normalizeEditedCommand(input) {
 
 function parseEditedCommandInput(input) {
   try {
-    return {
-      args: normalizeEditedCommand(input),
-      error: null
-    };
+    return { args: normalizeEditedCommand(input), error: null };
   } catch (error) {
-    return {
-      args: null,
-      error
-    };
+    return { args: null, error };
   }
 }
 
@@ -263,290 +520,1735 @@ function getExecutionCwd(projectPath) {
   return path.resolve(projectPath || process.cwd());
 }
 
-function teardownInput(input, onKeypress) {
-  if (!input) {
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function loadJsonFile(filePath, fallback = null) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+function saveJsonFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function loadPreferences() {
+  return loadJsonFile(PREFERENCES_PATH, {});
+}
+
+function savePreferences(updates) {
+  const current = loadPreferences() || {};
+  saveJsonFile(PREFERENCES_PATH, { ...current, ...updates });
+}
+
+function formatDateToken(date = new Date()) {
+  const y = date.getFullYear();
+  const m = `${date.getMonth() + 1}`.padStart(2, "0");
+  const d = `${date.getDate()}`.padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+function resolveDailyLogPath(projectPath, date = new Date()) {
+  return path.join(getExecutionCwd(projectPath), LOGS_DIR_RELATIVE, `${formatDateToken(date)}.ndjson`);
+}
+
+function appendLogEvent(state, scene, event, status = "ok", details = "") {
+  try {
+    const logPath = resolveDailyLogPath(state.projectPath);
+    ensureDir(path.dirname(logPath));
+    const payload = {
+      time: new Date().toISOString(),
+      scene,
+      event,
+      status,
+      project: getExecutionCwd(state.projectPath),
+      change: String(state.changeId || "auto"),
+      details: String(details || "")
+    };
+    fs.appendFileSync(logPath, `${JSON.stringify(payload)}\n`, "utf8");
+  } catch (_error) {
+    // Logging is diagnostic-only. Never block interactive flows.
+  }
+}
+
+function parseJsonEnvelope(output) {
+  const text = String(output || "").trim();
+  if (!text) {
+    return null;
+  }
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end < 0 || end <= start) {
+    return null;
+  }
+  try {
+    return JSON.parse(text.slice(start, end + 1));
+  } catch (_error) {
+    return null;
+  }
+}
+
+function resolveActiveChangeId(projectPath, requestedChangeId) {
+  const requested = String(requestedChangeId || "").trim();
+  if (requested) {
+    return requested;
+  }
+  const changesRoot = path.join(getExecutionCwd(projectPath), ".da-vinci", "changes");
+  if (!fs.existsSync(changesRoot)) {
+    return "";
+  }
+  let dirs = [];
+  try {
+    dirs = fs
+      .readdirSync(changesRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+  } catch (_error) {
+    return "";
+  }
+  const nonEmpty = dirs.filter((name) => {
+    const full = path.join(changesRoot, name);
+    try {
+      return fs.readdirSync(full).length > 0;
+    } catch (_error) {
+      return false;
+    }
+  });
+  if (nonEmpty.length === 1) {
+    return nonEmpty[0];
+  }
+  return "";
+}
+
+function getSceneById(sceneId) {
+  return SCENES.find((scene) => scene.id === sceneId) || null;
+}
+
+function createHeaderLines(state, lang, width) {
+  const innerWidth = Math.max(12, width - 4);
+  const lines = [];
+
+  if (innerWidth >= BRAND_LOGO_MIN_INNER_WIDTH) {
+    lines.push(paint(centerPlain("██████╗  █████╗   ██╗   ██╗██╗███╗   ██╗ ██████╗██╗", innerWidth), THEME.textStrong, THEME.bold));
+    lines.push(paint(centerPlain("██╔══██╗██╔══██╗  ██║   ██║██║████╗  ██║██╔════╝██║", innerWidth), THEME.textStrong, THEME.bold));
+    lines.push(paint(centerPlain("██║  ██║███████║  ██║   ██║██║██╔██╗ ██║██║     ██║", innerWidth), THEME.textStrong, THEME.bold));
+    lines.push(paint(centerPlain("██████╔╝██║  ██║  ╚██████╔╝██║██║ ╚████║╚██████╗██║", innerWidth), THEME.textStrong, THEME.bold));
+  } else {
+    lines.push(paint(centerPlain("DA VINCI", innerWidth), THEME.textStrong, THEME.bold));
+  }
+  lines.push("");
+  lines.push(paint(centerPlain(`Da Vinci Workflow v${PACKAGE_VERSION}`, innerWidth), THEME.accent, THEME.bold));
+
+  const projectText = truncateMiddle(state.projectPath || process.cwd(), Math.max(16, innerWidth - 12));
+  const changeText = resolveHeaderChangeText(state);
+  lines.push(paint(`[Project ${projectText}]`, THEME.soft, THEME.bold));
+  lines.push(paint(`[Change ${changeText}]`, THEME.soft, THEME.bold));
+  return lines;
+}
+
+function resolveHeaderChangeText(state) {
+  const explicit = String(state && state.changeId ? state.changeId : "").trim();
+  if (explicit) {
+    return explicit;
+  }
+  const hasChanges = listExistingChangeIds(state && state.projectPath).length > 0;
+  if (!hasChanges) {
+    return "none";
+  }
+  return "unselected";
+}
+
+function getSceneActions(state, sceneId) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+
+  const sceneActions = {
+    "prompt-templates": [
+      {
+        id: "prompt-mobile",
+        label: zh ? "移动端模板" : "Mobile Templates",
+        summary: zh ? "选择 mode1-5 并预览/复制英文模板" : "Select mode1-5 and preview/copy canonical English template",
+        run: async () => {
+          await runPromptTemplateFlow(state, "mobile");
+        }
+      },
+      {
+        id: "prompt-desktop",
+        label: zh ? "桌面端模板" : "Desktop Templates",
+        summary: zh ? "选择 mode1-5 并预览/复制英文模板" : "Select mode1-5 and preview/copy canonical English template",
+        run: async () => {
+          await runPromptTemplateFlow(state, "desktop");
+        }
+      },
+      {
+        id: "prompt-tablet",
+        label: zh ? "平板模板" : "Tablet Templates",
+        summary: zh ? "选择 mode1-5 并预览/复制英文模板" : "Select mode1-5 and preview/copy canonical English template",
+        run: async () => {
+          await runPromptTemplateFlow(state, "tablet");
+        }
+      },
+      {
+        id: "prompt-web",
+        label: zh ? "Web 模板" : "Web Templates",
+        summary: zh ? "选择 mode1-5 并预览/复制英文模板" : "Select mode1-5 and preview/copy canonical English template",
+        run: async () => {
+          await runPromptTemplateFlow(state, "web");
+        }
+      }
+    ],
+    "design-work": [
+      {
+        id: "design-icon-sync",
+        label: zh ? "同步图标库" : "Sync Icon Library",
+        summary: zh ? "运行 icon-sync" : "Run icon-sync",
+        run: async () => {
+          await runCommandById(state, "icon-sync", {
+            sceneId: "design-work",
+            eventName: "icon_sync",
+            loadingView: {
+              titleZh: "正在同步图标库",
+              titleEn: "Syncing Icon Library",
+              lines: [
+                zh
+                  ? "该操作需要联网拉取多个图标源，通常比普通命令更慢。"
+                  : "This operation fetches multiple icon sources over the network and can take longer than usual commands.",
+                zh
+                  ? "完成后会自动进入结果页。"
+                  : "The result page will appear automatically when sync finishes."
+              ]
+            }
+          });
+        }
+      },
+      {
+        id: "design-save-current",
+        label: zh ? "保存当前设计稿" : "Save Current Design",
+        summary: zh ? "把当前 live 设计回写到项目 .pen" : "Persist the current live design back to project .pen",
+        run: async () => {
+          await runCommandById(state, "save-current-design", {
+            sceneId: "design-work",
+            eventName: "save_current_design",
+            loadingView: {
+              titleZh: "正在保存当前设计稿",
+              titleEn: "Saving Current Design",
+              lines: [
+                zh
+                  ? "正在从 live 设计会话抓取最新快照并写回项目 .pen 文件。"
+                  : "Capturing the latest snapshot from the live design session and writing it back to the project .pen file.",
+                zh
+                  ? "完成后会自动显示保存结果（成功或失败）。"
+                  : "A final result page (success or failure) will be shown automatically."
+              ]
+            }
+          });
+        }
+      },
+      {
+        id: "design-quality",
+        label: zh ? "Visual Assist 预设" : "Visual Assist Preset",
+        summary: zh ? "先选平台再选3档质量，自动写入英文 Visual Assist" : "Pick platform then one of 3 quality levels and auto-write canonical English Visual Assist",
+        run: async () => {
+          await runDesignQualityFlow(state);
+        }
+      }
+    ],
+    "install-uninstall": [
+      {
+        id: "platform-status",
+        label: zh ? "状态" : "Status",
+        summary: zh ? "查看 da-vinci 当前安装状态" : "Show current da-vinci installation status",
+        run: async () => {
+          await runCommandById(state, "status", {
+            sceneId: "install-uninstall",
+            eventName: "install_uninstall_status"
+          });
+        }
+      },
+      {
+        id: "platform-install",
+        label: zh ? "安装" : "Install",
+        summary: zh ? "一键安装所有平台（Codex/Claude Code/Gemini）" : "Install all platforms in one step (Codex/Claude Code/Gemini)",
+        run: async () => {
+          await runPlatformLifecycleFlow(state, "install");
+        }
+      },
+      {
+        id: "platform-uninstall",
+        label: zh ? "卸载" : "Uninstall",
+        summary: zh ? "一键卸载所有平台（Codex/Claude Code/Gemini）" : "Uninstall all platforms in one step (Codex/Claude Code/Gemini)",
+        run: async () => {
+          await runPlatformLifecycleFlow(state, "uninstall");
+        }
+      }
+    ],
+    more: [
+      {
+        id: "more-language",
+        label: zh ? "语言" : "Language",
+        summary: zh ? "设置并持久化 TUI 语言" : "Set and persist TUI language",
+        run: async () => {
+          await chooseLanguage(state);
+        }
+      },
+      {
+        id: "more-logs",
+        label: zh ? "日志" : "Logs",
+        summary: zh ? "按天查看并复制项目日志" : "View and copy daily project logs",
+        run: async () => {
+          await showLogsFlow(state);
+        }
+      }
+    ]
+  };
+
+  return sceneActions[sceneId] || [];
+}
+
+function getSceneActionIndex(state) {
+  const key = state.activeSceneId;
+  const value = state.sceneSelectionById[key];
+  const actions = getSceneActions(state, state.activeSceneId);
+  const menuSize = actions.length + 1;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (menuSize <= 0) {
+      return 0;
+    }
+    return ((value % menuSize) + menuSize) % menuSize;
+  }
+  return 0;
+}
+
+function setSceneActionIndex(state, value) {
+  const actions = getSceneActions(state, state.activeSceneId);
+  const menuSize = actions.length + 1;
+  if (menuSize <= 0) {
+    state.sceneSelectionById[state.activeSceneId] = 0;
+    return;
+  }
+  const next = (value + menuSize) % menuSize;
+  state.sceneSelectionById[state.activeSceneId] = next;
+}
+
+function buildSceneMenuLines(state, lang, width) {
+  const lines = [];
+  const menuSize = SCENES.length + 1;
+  const selectedIndex =
+    Number.isFinite(state.rootSelectionIndex) && menuSize > 0
+      ? ((state.rootSelectionIndex % menuSize) + menuSize) % menuSize
+      : 0;
+  for (let index = 0; index < SCENES.length; index += 1) {
+    const scene = SCENES[index];
+    const selected = selectedIndex === index;
+    lines.push(createMenuLine(truncatePlain(resolveLocalizedText(scene.title, lang), Math.max(12, width - 4)), selected));
+  }
+  lines.push("");
+  lines.push(createMenuLine(lang === "zh" ? "退出" : "Exit", selectedIndex === SCENES.length));
+  return lines;
+}
+
+function buildSceneSummaryLines(state, lang, width) {
+  if (state.rootSelectionIndex === SCENES.length) {
+    const exitTitle = lang === "zh" ? "退出" : "Exit";
+    const exitSummary =
+      lang === "zh"
+        ? "结束当前 TUI 会话并返回终端。"
+        : "Close the current TUI session and return to the terminal.";
+    return [paint(exitTitle, THEME.accent, THEME.bold), paint(exitSummary, THEME.soft)];
+  }
+  const scene = getSceneById(state.activeSceneId) || SCENES[0];
+  const lines = [paint(resolveLocalizedText(scene.title, lang), THEME.accent, THEME.bold)];
+  for (const line of wrapText(resolveLocalizedText(scene.summary, lang), width)) {
+    lines.push(paint(line, THEME.soft));
+  }
+  return lines;
+}
+
+function buildSceneActionsLines(state, lang, width) {
+  const actions = getSceneActions(state, state.activeSceneId);
+  const selectedIndex = getSceneActionIndex(state);
+  const lines = [];
+  for (let index = 0; index < actions.length; index += 1) {
+    const action = actions[index];
+    lines.push(createMenuLine(truncatePlain(action.label, Math.max(12, width - 4)), index === selectedIndex));
+  }
+  lines.push("");
+  lines.push(createMenuLine(lang === "zh" ? "上一步" : "Back", selectedIndex === actions.length));
+  return lines;
+}
+
+function buildSceneActionSummaryLines(state, lang, width) {
+  const actions = getSceneActions(state, state.activeSceneId);
+  const selectedIndex = getSceneActionIndex(state);
+  if (selectedIndex >= actions.length) {
+    return [
+      paint(lang === "zh" ? "上一步" : "Back", THEME.accent, THEME.bold),
+      paint(
+        lang === "zh"
+          ? "返回场景选择列表。"
+          : "Return to the workflow scene list.",
+        THEME.soft
+      )
+    ];
+  }
+  const selected = actions[selectedIndex] || null;
+  const lines = [];
+  if (!selected) {
+    lines.push(paint(lang === "zh" ? "当前场景没有可执行动作。" : "No actions configured for this scene.", THEME.soft));
+    return lines;
+  }
+  lines.push(paint(selected.label, THEME.textStrong, THEME.bold));
+  for (const line of wrapText(selected.summary, width)) {
+    lines.push(paint(line, THEME.soft));
+  }
+  return lines;
+}
+
+function getWorkItemSelectionIndex(state) {
+  const choices = Array.isArray(state.workItemChoices) ? state.workItemChoices : [];
+  const menuSize = choices.length + 1;
+  const value = Number.isFinite(state.workItemSelectionIndex) ? state.workItemSelectionIndex : 0;
+  if (menuSize <= 0) {
+    return 0;
+  }
+  return ((value % menuSize) + menuSize) % menuSize;
+}
+
+function setWorkItemSelectionIndex(state, value) {
+  const choices = Array.isArray(state.workItemChoices) ? state.workItemChoices : [];
+  const menuSize = choices.length + 1;
+  if (menuSize <= 0) {
+    state.workItemSelectionIndex = 0;
+    return;
+  }
+  state.workItemSelectionIndex = ((value % menuSize) + menuSize) % menuSize;
+}
+
+function buildWorkItemSwitchLines(state, lang, width) {
+  const choices = Array.isArray(state.workItemChoices) ? state.workItemChoices : [];
+  const selectedIndex = getWorkItemSelectionIndex(state);
+  const lines = [];
+  for (let index = 0; index < choices.length; index += 1) {
+    const label = choices[index] === state.changeId
+      ? `${choices[index]} ${lang === "zh" ? "(当前)" : "(current)"}`
+      : choices[index];
+    lines.push(createMenuLine(truncatePlain(label, Math.max(12, width - 4)), index === selectedIndex));
+  }
+  lines.push("");
+  lines.push(createMenuLine(lang === "zh" ? "上一步" : "Back", selectedIndex === choices.length));
+  return lines;
+}
+
+function buildWorkItemSwitchSummaryLines(state, lang, width) {
+  const choices = Array.isArray(state.workItemChoices) ? state.workItemChoices : [];
+  const selectedIndex = getWorkItemSelectionIndex(state);
+  if (selectedIndex >= choices.length) {
+    return [
+      paint(lang === "zh" ? "上一步" : "Back", THEME.accent, THEME.bold),
+      paint(
+        lang === "zh"
+          ? "返回场景列表。"
+          : "Return to the scene list.",
+        THEME.soft
+      )
+    ];
+  }
+  const selected = choices[selectedIndex] || "";
+  const lines = [
+    paint(lang === "zh" ? "切换到工作项" : "Switch To Work Item", THEME.accent, THEME.bold),
+    paint(selected, THEME.textStrong, THEME.bold)
+  ];
+  for (const line of wrapText(
+    lang === "zh"
+      ? "按 Enter 将当前上下文切换到这个 change。"
+      : "Press Enter to switch the active context to this change.",
+    width
+  )) {
+    lines.push(paint(line, THEME.soft));
+  }
+  return lines;
+}
+
+function buildScreenLines(state, viewport = {}) {
+  const lang = normalizeLanguage(state.lang);
+  const width = resolveRenderWidth(state, viewport);
+  const height = resolveRenderHeight(viewport);
+  const horizontalGutter = width >= 120 ? 3 : width >= 84 ? 2 : 1;
+  const contentWidth = Math.max(24, width - horizontalGutter * 2);
+  const headerWidth = contentWidth;
+  const compactHeight = height < 32;
+  const lines = [];
+
+  lines.push(
+    ...insetBlock(
+      createPanel("", createHeaderLines(state, lang, headerWidth), headerWidth),
+      width,
+      headerWidth,
+      { align: "left", gutter: horizontalGutter }
+    )
+  );
+  lines.push("");
+
+  if (state.viewMode === "scene_list") {
+    lines.push(
+      ...insetBlock(
+        buildSceneMenuLines(state, lang, contentWidth - 4),
+        width,
+        contentWidth,
+        { align: "left", gutter: horizontalGutter }
+      )
+    );
+    if (!compactHeight) {
+      lines.push("");
+      lines.push(
+        ...insetBlock(
+          createPanel(lang === "zh" ? "场景说明" : "Scene Summary", buildSceneSummaryLines(state, lang, contentWidth - 4), contentWidth),
+          width,
+          contentWidth,
+          { align: "left", gutter: horizontalGutter }
+        )
+      );
+    }
+  } else if (state.viewMode === "scene_actions") {
+    lines.push(
+      ...insetBlock(
+        buildSceneActionsLines(state, lang, contentWidth - 4),
+        width,
+        contentWidth,
+        { align: "left", gutter: horizontalGutter }
+      )
+    );
+    if (!compactHeight) {
+      lines.push("");
+      lines.push(
+        ...insetBlock(
+          createPanel(lang === "zh" ? "动作说明" : "Action Summary", buildSceneActionSummaryLines(state, lang, contentWidth - 4), contentWidth),
+          width,
+          contentWidth,
+          { align: "left", gutter: horizontalGutter }
+        )
+      );
+    }
+  } else if (state.viewMode === "work_item_switch") {
+    lines.push(
+      ...insetBlock(
+        buildWorkItemSwitchLines(state, lang, contentWidth - 4),
+        width,
+        contentWidth,
+        { align: "left", gutter: horizontalGutter }
+      )
+    );
+    if (!compactHeight) {
+      lines.push("");
+      lines.push(
+        ...insetBlock(
+          createPanel(
+            lang === "zh" ? "工作项说明" : "Work Item Summary",
+            buildWorkItemSwitchSummaryLines(state, lang, contentWidth - 4),
+            contentWidth
+          ),
+          width,
+          contentWidth,
+          { align: "left", gutter: horizontalGutter }
+        )
+      );
+    }
+  } else {
+    lines.push(
+      ...insetBlock(
+        buildSceneMenuLines(state, lang, contentWidth - 4),
+        width,
+        contentWidth,
+        { align: "left", gutter: horizontalGutter }
+      )
+    );
+    if (!compactHeight) {
+      lines.push("");
+      lines.push(
+        ...insetBlock(
+          createPanel(lang === "zh" ? "场景说明" : "Scene Summary", buildSceneSummaryLines(state, lang, contentWidth - 4), contentWidth),
+          width,
+          contentWidth,
+          { align: "left", gutter: horizontalGutter }
+        )
+      );
+    }
+  }
+
+  if (state.helpVisible) {
+    lines.push("");
+    lines.push(
+      ...insetBlock(
+        createPanel(lang === "zh" ? "帮助" : "Help", formatTuiHelp(lang).split("\n").slice(1), contentWidth),
+        width,
+        contentWidth,
+        { align: "left", gutter: horizontalGutter }
+      )
+    );
+  }
+
+  if (lines.length <= height) {
+    return lines;
+  }
+  const clipped = lines.slice(0, Math.max(1, height - 1));
+  clipped.push(paint("[output clipped to viewport height]", THEME.muted));
+  return clipped;
+}
+
+function clearScreen() {
+  process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+}
+
+function renderState(state) {
+  clearScreen();
+  process.stdout.write(buildScreenLines(state).join("\n"));
+}
+
+function teardownInput(input, onKeypress) {
+  if (!input) {
+    return;
+  }
+  if (typeof input.off === "function" && onKeypress) {
+    input.off("keypress", onKeypress);
+  }
+  if (input.isTTY && typeof input.setRawMode === "function") {
+    input.setRawMode(false);
+  }
+  if (typeof input.pause === "function") {
+    input.pause();
+  }
+}
+
+function getKeyAction(str, key = {}) {
+  if (key.ctrl && key.name === "c") {
+    return "quit";
+  }
+  if (key.name === "up" || (key.name === "k" && key.shift !== true)) {
+    return "move_up";
+  }
+  if (key.name === "down" || (key.name === "j" && key.shift !== true)) {
+    return "move_down";
+  }
+  if (key.name === "l") {
+    return "toggle_lang";
+  }
+  if (key.name === "t") {
+    return "toggle_theme";
+  }
+  if (key.name === "s") {
+    return "toggle_strict";
+  }
+  if ((key.name === "j" && key.shift === true) || str === "J") {
+    return "toggle_json";
+  }
+  if (key.name === "e") {
+    return "toggle_continue_on_error";
+  }
+  if (key.name === "p") {
+    return "set_project";
+  }
+  if (key.name === "c") {
+    return "set_change";
+  }
+  if (key.name === "return" || key.name === "r") {
+    return "run";
+  }
+  if (str === "?") {
+    return "toggle_help";
+  }
+  return null;
+}
+
+function waitForAnyKey() {
+  return new Promise((resolve) => {
+    const handler = () => {
+      process.stdin.off("keypress", handler);
+      resolve();
+    };
+    process.stdin.on("keypress", handler);
+  });
+}
+
+async function promptInput(state, label, currentValue, options = {}) {
+  state.rawModeEnabled = false;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.pause();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const promptLabel = currentValue ? `${label} [${currentValue}]: ` : `${label}: `;
+  const answer = await new Promise((resolve) => {
+    rl.question(promptLabel, (value) => resolve(value));
+  });
+  rl.close();
+  process.stdin.resume();
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  state.rawModeEnabled = true;
+  const normalized = String(answer || "").trim();
+  if (!normalized && options.allowBlank) {
+    return "";
+  }
+  return normalized || String(currentValue || "").trim();
+}
+
+function resolveOptionLabel(option, lang) {
+  const label = option && option.label != null ? option.label : option;
+  if (typeof label === "string") {
+    return label;
+  }
+  return resolveLocalizedText(label, lang);
+}
+
+function resolveOptionSummary(option, lang) {
+  if (!option || option.summary == null) {
+    return "";
+  }
+  if (typeof option.summary === "string") {
+    return option.summary;
+  }
+  return resolveLocalizedText(option.summary, lang);
+}
+
+function clampOptionIndex(index, size) {
+  if (!Number.isFinite(index)) {
+    return 0;
+  }
+  if (size <= 0) {
+    return 0;
+  }
+  const normalized = index % size;
+  return normalized < 0 ? normalized + size : normalized;
+}
+
+function renderPromptHeader(state, lang) {
+  const width = resolveRenderWidth(state, {});
+  const horizontalGutter = width >= 120 ? 3 : width >= 84 ? 2 : 1;
+  const contentWidth = Math.max(24, width - horizontalGutter * 2);
+  const headerLines = insetBlock(
+    createPanel("", createHeaderLines(state, lang, contentWidth), contentWidth),
+    width,
+    contentWidth,
+    { align: "left", gutter: horizontalGutter }
+  );
+  return `${headerLines.join("\n")}\n\n`;
+}
+
+async function promptSelection(state, options = {}) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+  const entries = Array.isArray(options.items) ? options.items.filter(Boolean) : [];
+  if (entries.length === 0) {
+    return null;
+  }
+
+  const includeBack = options.includeBack === true;
+  const backLabel = options.backLabel || (zh ? "上一步" : "Back");
+  const showSummary = options.showSummary !== false;
+  const showFooter = options.showFooter !== false;
+  const menuSize = entries.length + (includeBack ? 1 : 0);
+  let selectedIndex = clampOptionIndex(options.initialIndex, menuSize);
+  const title = options.title || (zh ? "请选择" : "Select");
+  const subtitle = options.subtitle || "";
+  const footer = options.footer || (zh ? "Enter 确认，Esc 返回" : "Enter to confirm, Esc to go back");
+
+  const render = () => {
+    clearScreen();
+    process.stdout.write(renderPromptHeader(state, lang));
+    process.stdout.write(`${title}\n\n`);
+    if (subtitle) {
+      process.stdout.write(`${subtitle}\n\n`);
+    }
+    for (let index = 0; index < entries.length; index += 1) {
+      process.stdout.write(`${createMenuLine(resolveOptionLabel(entries[index], lang), index === selectedIndex)}\n`);
+    }
+    if (includeBack) {
+      process.stdout.write("\n");
+      process.stdout.write(`${createMenuLine(backLabel, selectedIndex === entries.length)}\n`);
+    }
+    if (showSummary && selectedIndex < entries.length) {
+      const selected = entries[selectedIndex];
+      const summary = resolveOptionSummary(selected, lang);
+      if (summary) {
+        process.stdout.write(`\n${summary}\n`);
+      }
+    }
+    if (showFooter) {
+      process.stdout.write(`\n${footer}\n`);
+    }
+  };
+
+  return await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Interrupted"));
+        return;
+      }
+      if (key.name === "up" || (key.name === "k" && key.shift !== true)) {
+        selectedIndex = (selectedIndex - 1 + menuSize) % menuSize;
+        render();
+        return;
+      }
+      if (key.name === "down" || (key.name === "j" && key.shift !== true)) {
+        selectedIndex = (selectedIndex + 1) % menuSize;
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "r") {
+        cleanup();
+        if (includeBack && selectedIndex === entries.length) {
+          resolve(null);
+          return;
+        }
+        resolve(entries[selectedIndex]);
+        return;
+      }
+      if (key.name === "escape" || key.name === "b" || key.name === "q") {
+        cleanup();
+        resolve(null);
+      }
+    };
+
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
+}
+
+function commandArgsWithOverrides(command, state, options = {}) {
+  let args = buildCommandArgs(command, state);
+  if (Array.isArray(options.appendArgs) && options.appendArgs.length > 0) {
+    args = args.concat(options.appendArgs);
+  }
+  return args;
+}
+
+function executeDaVinci(state, args) {
+  return spawnSync(process.execPath, [DA_VINCI_BIN, ...args], {
+    cwd: getExecutionCwd(state.projectPath),
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024
+  });
+}
+
+function renderExecutionReport(lang, title, lines) {
+  clearScreen();
+  process.stdout.write(`${title}\n\n`);
+  for (const line of lines) {
+    process.stdout.write(`${line}\n`);
+  }
+  process.stdout.write(`\n${lang === "zh" ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`);
+}
+
+function renderExecutionLoading(lang, title, lines = []) {
+  clearScreen();
+  process.stdout.write(`⏳ ${title}\n\n`);
+  for (const line of lines) {
+    process.stdout.write(`${line}\n`);
+  }
+  process.stdout.write(
+    `\n${lang === "zh" ? "命令执行中，请稍候..." : "Command is running, please wait..."}\n`
+  );
+}
+
+async function runCommandById(state, commandId, options = {}) {
+  const lang = normalizeLanguage(state.lang);
+  const command = getCommandById(commandId);
+  if (!command) {
+    state.lastStatus = `${commandId} -> missing command`; 
+    return;
+  }
+
+  let args = Array.isArray(options.overrideArgs) && options.overrideArgs.length > 0
+    ? options.overrideArgs.slice()
+    : commandArgsWithOverrides(command, state, options);
+  let display = ["da-vinci", ...args].join(" ");
+
+  if (options.forceEdit || hasPlaceholders(args)) {
+    renderState(state);
+    const edited = await promptInput(
+      state,
+      lang === "zh" ? "编辑命令" : "Edit command",
+      display
+    );
+    if (!edited) {
+      state.lastStatus = `${commandId} -> skipped`;
+      return;
+    }
+    const parsed = parseEditedCommandInput(edited);
+    if (parsed.error) {
+      clearScreen();
+      process.stdout.write(
+        `${lang === "zh" ? "命令编辑失败" : "Command edit failed"}\n\n${parsed.error.message || String(parsed.error)}\n\n`
+      );
+      process.stdout.write(`${lang === "zh" ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`);
+      state.lastStatus = `${commandId} -> edit error`; 
+      await waitForAnyKey();
+      return;
+    }
+    if (!parsed.args || parsed.args.length === 0) {
+      state.lastStatus = `${commandId} -> skipped`;
+      return;
+    }
+    args = parsed.args;
+    display = ["da-vinci", ...args].join(" ");
+  }
+
+  if (options.loadingView) {
+    const loadingTitle =
+      (lang === "zh" ? options.loadingView.titleZh : options.loadingView.titleEn) ||
+      (lang === "zh" ? "正在执行命令" : "Running Command");
+    const loadingLines = Array.isArray(options.loadingView.lines)
+      ? options.loadingView.lines.filter((line) => String(line || "").trim().length > 0)
+      : [];
+    renderExecutionLoading(lang, loadingTitle, loadingLines);
+  }
+
+  appendLogEvent(state, options.sceneId || "advanced", options.eventName || commandId, "start", display);
+  const result = executeDaVinci(state, args);
+  const stdout = String(result.stdout || "").trim();
+  const stderr = String(result.stderr || "").trim();
+  const merged = [stdout, stderr].filter(Boolean);
+  const statusCode = result.status == null ? "null" : String(result.status);
+  const success = result.status === 0;
+  const reportLines = [
+    lang === "zh" ? `结果: ${success ? "成功" : "失败"}` : `Result: ${success ? "PASS" : "FAIL"}`,
+    `${lang === "zh" ? "退出码" : "Exit code"}: ${statusCode}`,
+    "",
+    ...(merged.length > 0 ? merged : [lang === "zh" ? "没有输出。" : "No output."])
+  ];
+
+  renderExecutionReport(
+    lang,
+    `${lang === "zh" ? "执行结果" : "Execution Result"}: ${display}`,
+    reportLines
+  );
+  await waitForAnyKey();
+
+  state.lastStatus = `${display} -> ${statusCode}`;
+  appendLogEvent(
+    state,
+    options.sceneId || "advanced",
+    options.eventName || commandId,
+    result.status === 0 ? "ok" : "error",
+    `exit=${statusCode}`
+  );
+
+  return {
+    status: result.status,
+    stdout,
+    stderr,
+    args,
+    display,
+    json: parseJsonEnvelope(stdout)
+  };
+}
+
+async function runCommandChain(state, sceneId, chain) {
+  const lang = normalizeLanguage(state.lang);
+  const lines = [];
+  let finalStatus = 0;
+
+  for (const step of chain) {
+    const label = step.label;
+    const command = getCommandById(step.commandId);
+    if (!command) {
+      lines.push(`- ${label}: missing command ${step.commandId}`);
+      finalStatus = 1;
+      if (step.stopOnFailure) {
+        break;
+      }
+      continue;
+    }
+
+    const args = commandArgsWithOverrides(command, state, step.options || {});
+    const display = ["da-vinci", ...args].join(" ");
+    appendLogEvent(state, sceneId, step.eventName || step.commandId, "start", display);
+    const result = executeDaVinci(state, args);
+    const statusCode = result.status == null ? "null" : String(result.status);
+    const statusText = result.status === 0 ? "PASS" : "FAIL";
+    lines.push(`- ${label}: ${statusText} (${display})`);
+
+    const stdout = String(result.stdout || "").trim();
+    const stderr = String(result.stderr || "").trim();
+    if (stdout) {
+      for (const line of wrapText(stdout, 100).slice(0, 6)) {
+        lines.push(`  ${line}`);
+      }
+    }
+    if (stderr) {
+      for (const line of wrapText(stderr, 100).slice(0, 4)) {
+        lines.push(`  ${line}`);
+      }
+    }
+
+    appendLogEvent(state, sceneId, step.eventName || step.commandId, result.status === 0 ? "ok" : "error", `exit=${statusCode}`);
+    if (result.status !== 0) {
+      finalStatus = result.status || 1;
+      if (step.stopOnFailure) {
+        break;
+      }
+    }
+  }
+
+  renderExecutionReport(
+    lang,
+    lang === "zh" ? "组合动作执行结果" : "Compound action execution report",
+    lines
+  );
+  await waitForAnyKey();
+  state.lastStatus = `${sceneId} chain -> ${finalStatus === 0 ? "PASS" : "FAIL"}`;
+}
+
+function normalizeHeadingToken(text) {
+  return String(text || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim();
+}
+
+function findLevelTwoSectionRange(markdown, heading) {
+  const text = String(markdown || "").replace(/\r\n?/g, "\n");
+  const headingPattern = new RegExp(`^##\\s+${escapeRegExp(heading)}\\b.*$`, "m");
+  const headingMatch = headingPattern.exec(text);
+  if (!headingMatch || headingMatch.index == null) {
+    return null;
+  }
+
+  const start = headingMatch.index;
+  const bodyStart = start + headingMatch[0].length;
+  const remainder = text.slice(bodyStart);
+  const nextHeadingMatch = /\n(?=##\s+)/.exec(remainder);
+  const end = nextHeadingMatch ? bodyStart + nextHeadingMatch.index + 1 : text.length;
+
+  return {
+    text,
+    start,
+    end
+  };
+}
+
+function readPromptPresetSection(platform, modeKey) {
+  const fileName = PROMPT_PRESET_FILES[platform];
+  const heading = PROMPT_MODE_TO_HEADING[modeKey];
+  if (!fileName || !heading) {
+    throw new Error(`Unknown platform/mode pair: ${platform}/${modeKey}`);
+  }
+
+  const absolutePath = path.join(__dirname, "..", "docs", "prompt-presets", fileName);
+  const markdown = fs.readFileSync(absolutePath, "utf8");
+  const lines = markdown.split(/\r?\n/);
+  const target = normalizeHeadingToken(heading);
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index].match(/^##\s+(.+)$/);
+    if (!match) {
+      continue;
+    }
+    if (normalizeHeadingToken(match[1]) === target) {
+      start = index + 1;
+      break;
+    }
+  }
+  if (start < 0) {
+    throw new Error(`Preset heading not found: ${heading} in ${fileName}`);
+  }
+
+  let end = lines.length;
+  for (let index = start; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index])) {
+      end = index;
+      break;
+    }
+  }
+  const section = lines.slice(start, end).join("\n");
+  const blockMatch = section.match(/```text\s*\n([\s\S]*?)\n```/i);
+  if (!blockMatch) {
+    throw new Error(`No text code block found in ${fileName} / ${heading}`);
+  }
+  return blockMatch[1].trim();
+}
+
+function readVisualAssistVariant(platform, quality) {
+  const fileName = PROMPT_PRESET_FILES[platform];
+  const variant = QUALITY_TO_VARIANT[String(quality || "").toLowerCase()];
+  if (!fileName || !variant) {
+    throw new Error(`Unknown visual-assist selection: ${platform}/${quality}`);
+  }
+
+  const absolutePath = path.join(__dirname, "..", "docs", "visual-assist-presets", fileName);
+  const markdown = fs.readFileSync(absolutePath, "utf8");
+  const lines = markdown.split(/\r?\n/);
+  const headingPattern = new RegExp(`^###\\s+Variant\\s+${variant}\\b`, "i");
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (headingPattern.test(lines[index])) {
+      start = index + 1;
+      break;
+    }
+  }
+  if (start < 0) {
+    throw new Error(`Variant heading not found: ${variant} in ${fileName}`);
+  }
+
+  let end = lines.length;
+  for (let index = start; index < lines.length; index += 1) {
+    if (/^###\s+Variant\s+\d+\b/i.test(lines[index])) {
+      end = index;
+      break;
+    }
+  }
+  const section = lines.slice(start, end).join("\n");
+  const blockMatch = section.match(/```md\s*\n([\s\S]*?)\n```/i);
+  if (!blockMatch) {
+    throw new Error(`No markdown code block found in ${fileName} / variant ${variant}`);
+  }
+  return blockMatch[1].trim();
+}
+
+function parseVisualAssistOverrides(existingSection) {
+  const overrides = {};
+  const preserveKeys = [
+    "Preferred adapters",
+    "Design-supervisor reviewers",
+    "Require Adapter",
+    "Require Supervisor Review"
+  ];
+  const lines = String(existingSection || "").split(/\r?\n/);
+  for (const key of preserveKeys) {
+    const matcher = new RegExp(`^-\\s*${escapeRegExp(key)}\\s*:\\s*(.+)$`, "i");
+    const matchLine = lines.find((line) => matcher.test(line.trim()));
+    if (!matchLine) {
+      continue;
+    }
+    const valueMatch = matchLine.trim().match(matcher);
+    if (!valueMatch) {
+      continue;
+    }
+    overrides[key] = String(valueMatch[1] || "").trim();
+  }
+  return overrides;
+}
+
+function applyVisualAssistOverrides(blockText, overrides) {
+  const lines = String(blockText || "").split(/\r?\n/);
+  const keys = Object.keys(overrides || {});
+  if (keys.length === 0) {
+    return String(blockText || "").trim();
+  }
+  const updated = lines.map((line) => {
+    for (const key of keys) {
+      const matcher = new RegExp(`^(-\\s*${escapeRegExp(key)}\\s*:\\s*)(.+)$`, "i");
+      const match = line.match(matcher);
+      if (!match) {
+        continue;
+      }
+      return `${match[1]}${overrides[key]}`;
+    }
+    return line;
+  });
+  return updated.join("\n").trim();
+}
+
+function extractVisualAssistSection(markdown) {
+  const range = findLevelTwoSectionRange(markdown, "Visual Assist");
+  return range ? range.text.slice(range.start, range.end).trim() : "";
+}
+
+function applyManagedVisualAssistBlock(originalContent, visualAssistBlock) {
+  const original = String(originalContent || "").replace(/\r\n?/g, "\n");
+  const normalizedBlock = String(visualAssistBlock || "").trim();
+  if (!original.trim()) {
+    return `# DA-VINCI\n\n${normalizedBlock}\n`;
+  }
+
+  const range = findLevelTwoSectionRange(original, "Visual Assist");
+  if (range) {
+    const before = range.text.slice(0, range.start).trimEnd();
+    const after = range.text.slice(range.end).trimStart();
+    if (!before && !after) {
+      return `${normalizedBlock}\n`;
+    }
+    if (!before) {
+      return `${normalizedBlock}\n\n${after}`.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+    }
+    if (!after) {
+      return `${before}\n\n${normalizedBlock}\n`;
+    }
+    return `${before}\n\n${normalizedBlock}\n\n${after}`.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  }
+
+  const base = original.trimEnd();
+  return `${base}\n\n${normalizedBlock}\n`;
+}
+
+function copyToClipboard(text) {
+  const payload = String(text || "");
+  const candidates = [
+    { bin: "pbcopy", args: [] },
+    { bin: "clip", args: [] },
+    { bin: "xclip", args: ["-selection", "clipboard"] },
+    { bin: "xsel", args: ["--clipboard", "--input"] }
+  ];
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate.bin, candidate.args, {
+      input: payload,
+      encoding: "utf8"
+    });
+    if (!result.error && result.status === 0) {
+      return { ok: true, method: candidate.bin };
+    }
+  }
+  return { ok: false, method: "" };
+}
+
+async function runPlatformLifecycleFlow(state, commandId) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+  const isInstall = commandId === "install";
+  const selectedPlatforms = PLATFORM_INSTALL_OPTIONS.map((item) => item.value);
+  const platformValue = selectedPlatforms.join(",");
+  await runCommandById(state, commandId, {
+    overrideArgs: [commandId, "--platform", platformValue],
+    sceneId: "install-uninstall",
+    eventName: `${commandId}_all_platforms`,
+    loadingView: {
+      titleZh: isInstall ? "正在安装资产" : "正在卸载资产",
+      titleEn: isInstall ? "Installing Assets" : "Uninstalling Assets",
+      lines: [
+        `${zh ? "目标平台" : "Platforms"}: ${selectedPlatforms.join(", ")}`,
+        zh
+          ? "完成后会自动显示执行结果。"
+          : "The execution result will be shown automatically when done."
+      ]
+    }
+  });
+}
+
+async function runPromptTemplateFlow(state, platform) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+  appendLogEvent(state, "prompt-templates", "prompt_template_start", "ok", `platform=${platform}`);
+
+  const modeInput = await promptInput(
+    state,
+    zh ? "选择模式 (mode1-mode5)" : "Select mode (mode1-mode5)",
+    "mode1"
+  );
+  const mode = String(modeInput || "").trim().toLowerCase();
+  if (!PROMPT_MODE_TO_HEADING[mode]) {
+    state.lastStatus = `${platform} prompt -> invalid mode`;
+    appendLogEvent(state, "prompt-templates", "prompt_template_invalid_mode", "error", mode);
+    return;
+  }
+
+  let template = readPromptPresetSection(platform, mode);
+  if (mode === "mode3") {
+    const referenceDir = await promptInput(
+      state,
+      zh
+        ? "<reference-directory>（可留空保留占位符）"
+        : "<reference-directory> (leave blank to keep placeholder)",
+      "",
+      { allowBlank: true }
+    );
+    if (referenceDir) {
+      template = template.replace(/<reference-directory>/g, referenceDir);
+    }
+  }
+
+  clearScreen();
+  process.stdout.write(`${zh ? "模板预览" : "Template Preview"} (${platform} / ${mode})\n\n`);
+  process.stdout.write(`${template}\n\n`);
+  const copyAnswer = await promptInput(
+    state,
+    zh ? "复制到剪贴板? (Y/n)" : "Copy to clipboard? (Y/n)",
+    "Y",
+    { allowBlank: true }
+  );
+
+  const wantsCopy = !String(copyAnswer || "").trim() || !/^n/i.test(String(copyAnswer || "").trim());
+  if (wantsCopy) {
+    const copied = copyToClipboard(template);
+    if (copied.ok) {
+      state.lastStatus = `${platform}/${mode} template copied via ${copied.method}`;
+      appendLogEvent(state, "prompt-templates", "prompt_template_copy", "ok", `${platform}/${mode}`);
+    } else {
+      state.lastStatus = `${platform}/${mode} template ready (clipboard unavailable)`;
+      appendLogEvent(state, "prompt-templates", "prompt_template_copy", "warn", "clipboard unavailable");
+    }
+  } else {
+    state.lastStatus = `${platform}/${mode} template previewed`;
+  }
+
+  process.stdout.write(`${zh ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`);
+  await waitForAnyKey();
+}
+
+async function runDesignQualityFlow(state) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+
+  while (true) {
+    const platformChoice = await promptSelection(state, {
+      title: zh ? "Visual Assist 预设：选择平台" : "Visual Assist Preset: Choose Platform",
+      items: DESIGN_PLATFORM_OPTIONS,
+      includeBack: true,
+      showSummary: false,
+      showFooter: false,
+      initialIndex: Number.isFinite(state.designQualityPlatformSelectionIndex) ? state.designQualityPlatformSelectionIndex : 0
+    });
+    if (!platformChoice || !PROMPT_PRESET_FILES[platformChoice.value]) {
+      state.lastStatus = zh ? "Visual Assist 预设已返回上一级" : "Visual Assist preset returned to previous level";
+      appendLogEvent(state, "design-work", "visual_assist_platform_back", "ok", "back");
+      return;
+    }
+    state.designQualityPlatformSelectionIndex = DESIGN_PLATFORM_OPTIONS.findIndex((item) => item.value === platformChoice.value);
+
+    const platform = platformChoice.value;
+
+    const qualityChoice = await promptSelection(state, {
+      title: zh ? "Visual Assist 预设：选择质量" : "Visual Assist Preset: Choose Quality",
+      items: DESIGN_QUALITY_OPTIONS,
+      includeBack: true,
+      showSummary: false,
+      showFooter: false,
+      initialIndex: Number.isFinite(state.designQualityQualitySelectionIndex) ? state.designQualityQualitySelectionIndex : 1
+    });
+    if (!qualityChoice || !QUALITY_TO_VARIANT[qualityChoice.value]) {
+      state.lastStatus = zh ? "Visual Assist 预设：返回平台选择" : "Visual Assist preset: back to platform selection";
+      appendLogEvent(state, "design-work", "visual_assist_quality_back", "ok", "back_to_platform");
+      continue;
+    }
+    state.designQualityQualitySelectionIndex = DESIGN_QUALITY_OPTIONS.findIndex((item) => item.value === qualityChoice.value);
+
+    const quality = qualityChoice.value;
+    const presetBlock = readVisualAssistVariant(platform, quality);
+    const projectRoot = getExecutionCwd(state.projectPath);
+    const daVinciPath = path.join(projectRoot, "DA-VINCI.md");
+    const existingContent = fs.existsSync(daVinciPath) ? fs.readFileSync(daVinciPath, "utf8") : "";
+    const existingSection = extractVisualAssistSection(existingContent);
+    const overrides = parseVisualAssistOverrides(existingSection);
+    const finalBlock = applyVisualAssistOverrides(presetBlock, overrides);
+
+    const nextContent = applyManagedVisualAssistBlock(existingContent, finalBlock);
+    ensureDir(path.dirname(daVinciPath));
+    fs.writeFileSync(daVinciPath, nextContent, "utf8");
+    const variant = qualityChoice.variant || QUALITY_TO_VARIANT[quality];
+    state.lastStatus = `Visual Assist updated (${platform}, variant ${variant}) -> ${daVinciPath}`;
+    appendLogEvent(
+      state,
+      "design-work",
+      "visual_assist_write",
+      "ok",
+      `platform=${platform};quality=${quality};variant=${variant};path=${daVinciPath}`
+    );
     return;
   }
-  if (typeof input.off === "function" && onKeypress) {
-    input.off("keypress", onKeypress);
-  }
-  if (input.isTTY && typeof input.setRawMode === "function") {
-    input.setRawMode(false);
-  }
-  if (typeof input.pause === "function") {
-    input.pause();
-  }
 }
 
-function getKeyAction(str, key = {}) {
-  if (key.ctrl && key.name === "c") {
-    return "quit";
-  }
-  if (key.name === "q") {
-    return "quit";
-  }
-  if (key.name === "up" || (key.name === "k" && key.shift !== true)) {
-    return "move_up";
-  }
-  if (key.name === "down" || (key.name === "j" && key.shift !== true)) {
-    return "move_down";
-  }
-  if (key.name === "l") {
-    return "toggle_lang";
-  }
-  if (key.name === "h") {
-    return "toggle_command_help";
-  }
-  if (key.name === "s") {
-    return "toggle_strict";
+function mapRouteToScene(route) {
+  const value = String(route || "").trim();
+  if (!value) {
+    return "current-status";
   }
-  if ((key.name === "j" && key.shift === true) || str === "J") {
-    return "toggle_json";
+  if (value === "/dv:design") {
+    return "design-work";
   }
-  if (key.name === "e") {
-    return "toggle_continue_on_error";
+  if (value === "/dv:verify") {
+    return "pre-completion-validation";
   }
-  if (key.name === "p") {
-    return "set_project";
+  if (value === "select-change") {
+    return "switch-work-item";
   }
-  if (key.name === "c") {
-    return "set_change";
+  if (
+    value === "/dv:tasks" ||
+    value === "/dv:build" ||
+    value === "/dv:bootstrap" ||
+    value === "bootstrap-project"
+  ) {
+    return null;
   }
-  if (key.name === "m") {
-    return "edit_and_run";
+  return "current-status";
+}
+
+async function runCurrentStatusFlow(state) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+
+  const command = getCommandById("workflow-status");
+  const statusArgs = commandArgsWithOverrides(command, state, { appendArgs: ["--json"] });
+  const workflowStatusResult = executeDaVinci(state, statusArgs);
+  const workflowPayload = parseJsonEnvelope(workflowStatusResult.stdout);
+
+  const nextCommand = getCommandById("next-step");
+  const nextArgs = commandArgsWithOverrides(nextCommand, state, {});
+  const nextStepResult = executeDaVinci(state, nextArgs);
+
+  const stage = workflowPayload && workflowPayload.stage ? String(workflowPayload.stage) : "unknown";
+  const blockers = workflowPayload && Array.isArray(workflowPayload.failures) ? workflowPayload.failures : [];
+  const nextRoute = workflowPayload && workflowPayload.nextStep && workflowPayload.nextStep.route
+    ? String(workflowPayload.nextStep.route)
+    : "";
+  const recommendedScene = mapRouteToScene(nextRoute);
+  const nextStepText = String(nextStepResult.stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim().length > 0);
+
+  const lines = [];
+  lines.push(`${zh ? "当前阶段" : "Stage"}: ${stage}`);
+  lines.push(`${zh ? "阻塞项" : "Blockers"}: ${blockers.length}`);
+  if (blockers.length > 0) {
+    for (const blocker of blockers.slice(0, 5)) {
+      lines.push(`- ${blocker}`);
+    }
   }
-  if (key.name === "return" || key.name === "r") {
-    return "run";
+  if (nextRoute) {
+    lines.push(`${zh ? "建议路由" : "Suggested route"}: ${nextRoute}`);
   }
-  if (str === "?") {
-    return "toggle_help";
+  const sceneRecord = recommendedScene ? getSceneById(recommendedScene) : null;
+  const sceneTitle = sceneRecord
+    ? resolveLocalizedText(sceneRecord.title, lang)
+    : zh
+      ? "直接执行命令"
+      : "Run Recommended CLI Command";
+  lines.push(`${zh ? "建议模块" : "Suggested module"}: ${sceneTitle}`);
+  if (nextStepText.length > 0) {
+    lines.push("");
+    lines.push(zh ? "下一步总结:" : "Next-step summary:");
+    for (const line of nextStepText.slice(0, 8)) {
+      lines.push(`- ${line}`);
+    }
   }
-  return null;
+
+  renderExecutionReport(
+    lang,
+    zh ? "当前状态" : "Current Status",
+    lines
+  );
+  await waitForAnyKey();
+
+  state.lastStatus = `current-status -> stage=${stage}; route=${nextRoute || "n/a"}`;
+  appendLogEvent(
+    state,
+    "current-status",
+    "current_status",
+    workflowStatusResult.status === 0 && nextStepResult.status === 0 ? "ok" : "error",
+    `stage=${stage};route=${nextRoute}`
+  );
+  state.activeSceneId = "current-status";
+  state.rootSelectionIndex = Math.max(0, SCENES.findIndex((scene) => scene.id === "current-status"));
+  state.viewMode = "scene_list";
 }
 
-function waitForAnyKey() {
-  return new Promise((resolve) => {
-    const handler = () => {
-      process.stdin.off("keypress", handler);
-      resolve();
+function getArtifactReadiness(state) {
+  const projectRoot = getExecutionCwd(state.projectPath);
+  const changeId = resolveActiveChangeId(projectRoot, state.changeId);
+  if (!changeId) {
+    return {
+      changeId: "",
+      changeRoot: "",
+      missingTasks: true,
+      missingBindings: true,
+      hasDesign: false,
+      hasBindings: false,
+      hasTasks: false
     };
-    process.stdin.on("keypress", handler);
-  });
+  }
+
+  const changeRoot = path.join(projectRoot, ".da-vinci", "changes", changeId);
+  const hasTasks = fs.existsSync(path.join(changeRoot, "tasks.md"));
+  const hasDesign = fs.existsSync(path.join(changeRoot, "pencil-design.md"));
+  const hasBindings = fs.existsSync(path.join(changeRoot, "pencil-bindings.md"));
+
+  const missingTasks = !hasTasks;
+  const missingBindings = hasDesign && !hasBindings;
+
+  return {
+    changeId,
+    changeRoot,
+    missingTasks,
+    missingBindings,
+    hasDesign,
+    hasBindings,
+    hasTasks
+  };
 }
 
-async function promptInput(state, label, currentValue, options = {}) {
-  state.rawModeEnabled = false;
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(false);
-  }
-  process.stdin.pause();
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const promptLabel = currentValue
-    ? `${label} [${currentValue}]: `
-    : `${label}: `;
-  const answer = await new Promise((resolve) => {
-    rl.question(promptLabel, (value) => resolve(value));
-  });
-  rl.close();
-  process.stdin.resume();
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
-  state.rawModeEnabled = true;
-  const normalized = String(answer || "").trim();
-  if (!normalized && options.allowBlank) {
-    return "";
-  }
-  return normalized || String(currentValue || "").trim();
+function resolvePreImplementationResult(readiness, stepResults) {
+  const hasBlocker = Boolean(readiness && (readiness.missingTasks || readiness.missingBindings));
+  const hasCommandFailure = (stepResults || []).some((step) => !step || step.status !== 0);
+  const exitCode = hasBlocker || hasCommandFailure ? 1 : 0;
+  const summaryStatus = hasBlocker ? "BLOCK" : hasCommandFailure ? "FAIL" : "PASS";
+  return {
+    hasBlocker,
+    hasCommandFailure,
+    exitCode,
+    summaryStatus,
+    logStatus: exitCode === 0 ? "ok" : "error"
+  };
 }
 
-function renderState(state) {
-  clearScreen();
+async function runPreImplementationChecks(state) {
   const lang = normalizeLanguage(state.lang);
-  const width = process.stdout.columns || 100;
-  const rows = buildCatalogRows(lang);
-  const selectedRowIndex = getRowIndexForCommand(
-    rows,
-    COMMANDS.findIndex((command) => command.id === state.selectedCommandId)
-  );
-  const listHeight = Math.max(10, Math.min(16, (process.stdout.rows || 40) - 20));
-  const visible = getVisibleRows(rows, selectedRowIndex, listHeight);
-  const preview = buildPreviewCommand(state);
-  const stage = getStageById(preview.command.stageId);
-  const selectedNumber = COMMANDS.findIndex((command) => command.id === preview.command.id) + 1;
+  const zh = lang === "zh";
+  const readiness = getArtifactReadiness(state);
   const lines = [];
+  const chain = [];
+  const stepResults = [];
 
-  lines.push(lang === "zh" ? "Da Vinci TUI 终端导航" : "Da Vinci TUI");
-  lines.push(
-    lang === "zh"
-      ? `语言: ${lang === "zh" ? "中文" : "English"} (l) | 项目: ${state.projectPath || process.cwd()} (p) | Change: ${
-          state.changeId || "auto"
-        } (c)`
-      : `Language: ${lang === "zh" ? "Chinese" : "English"} (l) | Project: ${
-          state.projectPath || process.cwd()
-        } (p) | Change: ${state.changeId || "auto"} (c)`
-  );
-  lines.push(
-    lang === "zh"
-      ? `开关: strict=${state.strict ? "on" : "off"} (s) | json=${state.jsonOutput ? "on" : "off"} (J) | continue-on-error=${
-          state.continueOnError ? "on" : "off"
-        } (e)`
-      : `Flags: strict=${state.strict ? "on" : "off"} (s) | json=${state.jsonOutput ? "on" : "off"} (J) | continue-on-error=${
-          state.continueOnError ? "on" : "off"
-        } (e)`
-  );
-  lines.push(
-    lang === "zh"
-      ? "操作: ↑↓/j/k 移动 | Enter/r 执行 | h 参数 | m 编辑命令 | ? 帮助 | q 退出"
-      : "Keys: Up/Down/j/k move | Enter/r run | h params | m edit command | ? help | q quit"
-  );
-  lines.push("");
-  lines.push(lang === "zh" ? "命令目录" : "Command Catalog");
-  for (let index = 0; index < visible.items.length; index += 1) {
-    const row = visible.items[index];
-    const absoluteIndex = visible.start + index;
-    if (row.type === "stage") {
-      lines.push(`  [${row.label}]`);
-      continue;
-    }
-    const selected = absoluteIndex === selectedRowIndex;
-    const prefix = selected ? ">" : " ";
-    const title = truncate(row.label, Math.max(16, width - 8));
-    lines.push(` ${prefix} ${title}`);
-  }
-  lines.push("");
-  lines.push(
-    lang === "zh"
-      ? `当前命令 (${selectedNumber}/${COMMANDS.length}): ${resolveLocalizedText(preview.command.title, lang)}`
-      : `Selected (${selectedNumber}/${COMMANDS.length}): ${resolveLocalizedText(preview.command.title, lang)}`
-  );
-  lines.push(
-    lang === "zh"
-      ? `阶段: ${resolveLocalizedText(stage.title, lang)}`
-      : `Phase: ${resolveLocalizedText(stage.title, lang)}`
-  );
-  for (const line of wrapText(resolveLocalizedText(preview.command.summary, lang), width - 2)) {
-    lines.push(line);
-  }
-  lines.push("");
-  for (const line of wrapText(resolveLocalizedText(preview.command.details, lang), width - 2)) {
-    lines.push(line);
-  }
-  lines.push("");
-  lines.push(lang === "zh" ? "预览命令:" : "Preview:");
-  for (const line of wrapText(preview.display, width - 2)) {
-    lines.push(line);
+  chain.push({
+    commandId: "lint-spec",
+    label: "lint-spec",
+    eventName: "preimpl_lint_spec",
+    options: {},
+    stopOnFailure: false
+  });
+  chain.push({
+    commandId: "scope-check",
+    label: "scope-check",
+    eventName: "preimpl_scope_check",
+    options: {},
+    stopOnFailure: false
+  });
+
+  if (readiness.hasTasks) {
+    chain.push({
+      commandId: "lint-tasks",
+      label: "lint-tasks",
+      eventName: "preimpl_lint_tasks",
+      options: {},
+      stopOnFailure: false
+    });
+  } else {
+    lines.push(zh ? "- BLOCK: 缺少 tasks.md，实施前检查不满足实现就绪。" : "- BLOCK: tasks.md is missing; implementation readiness is not met.");
   }
-  if (hasPlaceholders(preview.args)) {
+
+  if (readiness.hasBindings) {
+    chain.push({
+      commandId: "lint-bindings",
+      label: "lint-bindings",
+      eventName: "preimpl_lint_bindings",
+      options: {},
+      stopOnFailure: false
+    });
+  } else if (readiness.missingBindings) {
     lines.push(
-      lang === "zh"
-        ? "提示: 当前命令包含占位符，按 m 编辑后再执行。"
-        : "Hint: this command still contains placeholders; press m to edit before running."
+      zh
+        ? "- BLOCK: 已存在 pencil-design.md 但缺少 pencil-bindings.md。"
+        : "- BLOCK: pencil-design.md exists but pencil-bindings.md is missing."
     );
-  }
-  if (!state.commandHelpVisible) {
+  } else {
     lines.push(
-      lang === "zh"
-        ? "提示: 按 h 查看当前命令支持的参数。"
-        : "Hint: press h to inspect parameters for the selected command."
+      zh
+        ? "- SKIP: 当前没有 design/bindings 对，跳过 lint-bindings。"
+        : "- SKIP: no design/bindings pair found, lint-bindings skipped safely."
     );
   }
-  if (state.lastStatus) {
-    lines.push("");
-    lines.push(
-      lang === "zh"
-        ? `最近结果: ${state.lastStatus}`
-        : `Last result: ${state.lastStatus}`
-    );
+
+  const reportLines = [];
+  for (const item of chain) {
+    const command = getCommandById(item.commandId);
+    const args = commandArgsWithOverrides(command, state, item.options || {});
+    const display = ["da-vinci", ...args].join(" ");
+    appendLogEvent(state, "pre-implementation-checks", item.eventName, "start", display);
+    const result = executeDaVinci(state, args);
+    const code = result.status == null ? "null" : String(result.status);
+    stepResults.push({
+      commandId: item.commandId,
+      status: result.status
+    });
+    reportLines.push(`- ${item.label}: ${result.status === 0 ? "PASS" : "FAIL"} (${code})`);
+    appendLogEvent(state, "pre-implementation-checks", item.eventName, result.status === 0 ? "ok" : "error", `exit=${code}`);
   }
-  if (state.helpVisible) {
-    lines.push("");
-    lines.push("-".repeat(Math.max(20, Math.min(width - 2, 48))));
-    for (const line of formatTuiHelp(lang).split("\n")) {
-      lines.push(line);
+
+  const finalLines = [...lines, ...reportLines];
+  const outcome = resolvePreImplementationResult(readiness, stepResults);
+  renderExecutionReport(
+    lang,
+    zh ? "实施前检查结果" : "Pre-Implementation Check Result",
+    finalLines
+  );
+  await waitForAnyKey();
+
+  state.lastStatus = `pre-implementation -> ${outcome.summaryStatus}`;
+  appendLogEvent(
+    state,
+    "pre-implementation-checks",
+    "preimpl_summary",
+    outcome.logStatus,
+    `missingTasks=${readiness.missingTasks};missingBindings=${readiness.missingBindings};commandFailures=${outcome.hasCommandFailure}`
+  );
+}
+
+async function runPreCompletionValidation(state) {
+  await runCommandChain(state, "pre-completion-validation", [
+    {
+      commandId: "verify-bindings",
+      label: "verify-bindings",
+      eventName: "verify_bindings",
+      options: {},
+      stopOnFailure: false
+    },
+    {
+      commandId: "verify-implementation",
+      label: "verify-implementation",
+      eventName: "verify_implementation",
+      options: {},
+      stopOnFailure: false
+    },
+    {
+      commandId: "verify-structure",
+      label: "verify-structure",
+      eventName: "verify_structure",
+      options: {},
+      stopOnFailure: false
+    },
+    {
+      commandId: "verify-coverage",
+      label: "verify-coverage",
+      eventName: "verify_coverage",
+      options: {},
+      stopOnFailure: false
     }
+  ]);
+}
+
+function listExistingChangeIds(projectPath) {
+  const changesRoot = path.join(getExecutionCwd(projectPath), ".da-vinci", "changes");
+  if (!fs.existsSync(changesRoot)) {
+    return [];
   }
-  if (state.commandHelpVisible) {
-    lines.push("");
-    lines.push("-".repeat(Math.max(20, Math.min(width - 2, 48))));
-    for (const line of formatCommandParameterHelp(preview.command, lang, width).flat()) {
-      lines.push(line);
-    }
+  try {
+    return fs
+      .readdirSync(changesRoot, { withFileTypes: true })
+      .filter((entry) => entry && entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+  } catch (_error) {
+    return [];
   }
+}
 
-  process.stdout.write(`${lines.join("\n")}\n`);
+async function chooseExistingChange(state) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+  const changeIds = listExistingChangeIds(state.projectPath);
+  if (changeIds.length === 0) {
+    clearScreen();
+    process.stdout.write(`${zh ? "没有可切换的工作项。" : "No work items found."}\n\n`);
+    process.stdout.write(`${zh ? "当前项目下还没有可供切换的 change。" : "This project does not have any switchable changes yet."}\n\n`);
+    process.stdout.write(`${zh ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`);
+    state.lastStatus = zh ? "暂无可切换工作项" : "no work items available";
+    appendLogEvent(state, "switch-work-item", "change_switch", "warn", "no work items");
+    await waitForAnyKey();
+    return;
+  }
+  state.workItemChoices = changeIds;
+  state.workItemSelectionIndex = Math.max(0, changeIds.findIndex((item) => item === state.changeId));
+  state.viewMode = "work_item_switch";
+  appendLogEvent(state, "switch-work-item", "change_switch_open", "ok", `${changeIds.length} items`);
 }
 
-async function runPreview(state, options = {}) {
+async function chooseLanguage(state) {
   const lang = normalizeLanguage(state.lang);
-  const preview = buildPreviewCommand(state);
-  let args = preview.args;
+  const zh = lang === "zh";
+  const selected = await promptInput(
+    state,
+    zh ? "语言 (en/zh)" : "Language (en/zh)",
+    state.lang
+  );
+  const next = normalizeLanguage(selected);
+  state.lang = next;
+  savePreferences({ lang: next });
+  state.lastStatus = `language -> ${next}`;
+  appendLogEvent(state, "more", "language_set", "ok", next);
+}
 
-  if (options.forceEdit || hasPlaceholders(args)) {
-    renderState(state);
-    const edited = await promptInput(
-      state,
-      lang === "zh" ? "编辑命令" : "Edit command",
-      preview.display
-    );
-    if (!edited) {
-      return;
-    }
-    const parsed = parseEditedCommandInput(edited);
-    if (parsed.error) {
-      clearScreen();
-      process.stdout.write(
-        `${lang === "zh" ? "命令编辑失败" : "Command edit failed"}\n\n${parsed.error.message || String(parsed.error)}\n\n`
-      );
-      process.stdout.write(
-        `${lang === "zh" ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`
-      );
-      state.lastStatus = `${lang === "zh" ? "命令编辑失败" : "Command edit failed"}: ${
-        parsed.error.message || String(parsed.error)
-      }`;
-      await waitForAnyKey();
-      return;
-    }
-    args = parsed.args;
-    if (args.length === 0) {
-      return;
-    }
+function listDailyLogFiles(projectPath) {
+  const logsRoot = path.join(getExecutionCwd(projectPath), LOGS_DIR_RELATIVE);
+  if (!fs.existsSync(logsRoot)) {
+    return [];
+  }
+  let files = [];
+  try {
+    files = fs
+      .readdirSync(logsRoot)
+      .filter((name) => /^\d{4}-\d{2}-\d{2}\.ndjson$/.test(name))
+      .sort()
+      .reverse();
+  } catch (_error) {
+    return [];
   }
+  return files.map((name) => path.join(logsRoot, name));
+}
 
-  clearScreen();
-  process.stdout.write(
-    `${lang === "zh" ? "正在执行" : "Running"}: ${["da-vinci", ...args].join(" ")}\n\n`
-  );
-  const result = spawnSync(process.execPath, [DA_VINCI_BIN, ...args], {
-    cwd: getExecutionCwd(state.projectPath),
-    encoding: "utf8",
-    maxBuffer: 16 * 1024 * 1024
-  });
-  if (result.error) {
-    process.stdout.write(
-      `${lang === "zh" ? "执行失败" : "Execution failed"}: ${result.error.message || String(result.error)}\n\n`
-    );
-    process.stdout.write(
-      `${lang === "zh" ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`
-    );
-    state.lastStatus = `${["da-vinci", ...args].join(" ")} -> error`;
-    await waitForAnyKey();
+async function showLogsFlow(state) {
+  const lang = normalizeLanguage(state.lang);
+  const zh = lang === "zh";
+
+  const files = listDailyLogFiles(state.projectPath);
+  if (files.length === 0) {
+    state.lastStatus = zh ? "日志为空" : "No logs found";
     return;
   }
-  const stdout = String(result.stdout || "");
-  const stderr = String(result.stderr || "");
-  const combined = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n\n");
-  process.stdout.write(`${combined || (lang === "zh" ? "没有输出。" : "No output.")}\n\n`);
-  process.stdout.write(
-    `${lang === "zh" ? "退出码" : "Exit code"}: ${result.status == null ? "null" : result.status}\n`
+
+  const promptLines = files
+    .slice(0, 10)
+    .map((absolutePath, index) => `${index + 1}. ${path.basename(absolutePath)}`)
+    .join("\n");
+  clearScreen();
+  process.stdout.write(`${zh ? "可用日志" : "Available logs"}\n\n${promptLines}\n\n`);
+
+  const indexRaw = await promptInput(
+    state,
+    zh ? "选择日志编号" : "Pick log number",
+    "1"
   );
-  process.stdout.write(
-    `${lang === "zh" ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`
+  const selectedIndex = Math.max(1, Number.parseInt(indexRaw, 10) || 1);
+  const selectedPath = files[Math.min(files.length - 1, selectedIndex - 1)];
+  const content = fs.readFileSync(selectedPath, "utf8");
+
+  clearScreen();
+  process.stdout.write(`${path.basename(selectedPath)}\n\n${content}\n`);
+
+  const copyAnswer = await promptInput(
+    state,
+    zh ? "复制当天日志? (Y/n)" : "Copy this day log? (Y/n)",
+    "Y",
+    { allowBlank: true }
   );
-  state.lastStatus = `${["da-vinci", ...args].join(" ")} -> ${result.status == null ? "null" : result.status}`;
+
+  const wantsCopy = !String(copyAnswer || "").trim() || !/^n/i.test(String(copyAnswer || "").trim());
+  if (wantsCopy) {
+    const copied = copyToClipboard(content);
+    if (copied.ok) {
+      state.lastStatus = `${path.basename(selectedPath)} copied via ${copied.method}`;
+      appendLogEvent(state, "more", "logs_copy", "ok", path.basename(selectedPath));
+    } else {
+      state.lastStatus = `${path.basename(selectedPath)} ready (clipboard unavailable)`;
+      appendLogEvent(state, "more", "logs_copy", "warn", "clipboard unavailable");
+    }
+  } else {
+    state.lastStatus = `${path.basename(selectedPath)} viewed`;
+  }
+
+  process.stdout.write(`\n${zh ? "按任意键返回 TUI。" : "Press any key to return to the TUI."}\n`);
   await waitForAnyKey();
 }
 
@@ -555,26 +2257,45 @@ async function launchTui(options = {}) {
     throw new Error("`da-vinci tui` requires an interactive terminal. Use `--help` for usage.");
   }
 
+  const preferences = loadPreferences();
+  const initialLang = options.lang ? normalizeLanguage(options.lang) : normalizeLanguage(preferences.lang || getDefaultLanguage());
   const initialProject = String(options.projectPath || process.cwd()).trim() || process.cwd();
   const initialChange = String(options.changeId || "").trim();
+  const initialLayoutWidth = normalizeLayoutWidth(
+    options.tuiWidth != null ? options.tuiWidth : options.layoutWidth != null ? options.layoutWidth : preferences.layoutWidth
+  );
+  const useAltScreen = resolveAltScreenMode(options, preferences);
+
   const state = {
-    lang: normalizeLanguage(options.lang || getDefaultLanguage()),
+    lang: initialLang,
     projectPath: initialProject,
     changeId: initialChange,
+    layoutWidth: initialLayoutWidth,
     strict: options.strict === true,
     jsonOutput: options.jsonOutput === true,
     continueOnError: options.continueOnError === true,
-    selectedCommandId: COMMANDS[0].id,
+    themeMode: THEME_MODE,
+    viewMode: "scene_list",
+    activeSceneId: SCENES[0].id,
+    rootSelectionIndex: 0,
+    sceneSelectionById: {},
+    designQualityPlatformSelectionIndex: 0,
+    designQualityQualitySelectionIndex: 1,
     helpVisible: false,
-    commandHelpVisible: false,
     lastStatus: "",
     rawModeEnabled: true,
     busy: false
   };
 
+  appendLogEvent(state, "system", "tui_start", "ok", `lang=${state.lang};theme=${state.themeMode}`);
+
   readline.emitKeypressEvents(process.stdin);
   process.stdin.setRawMode(true);
   process.stdin.resume();
+  if (useAltScreen) {
+    enterAlternateScreen();
+  }
+  hideCursor();
 
   let closed = false;
   return await new Promise((resolve) => {
@@ -583,28 +2304,48 @@ async function launchTui(options = {}) {
         return;
       }
       closed = true;
+      appendLogEvent(state, "system", "tui_exit", "ok", "quit");
       teardownInput(process.stdin, onKeypress);
-      clearScreen();
+      if (useAltScreen) {
+        exitAlternateScreen();
+      }
+      showCursor();
       resolve();
     };
 
     const moveSelection = (delta) => {
-      const currentIndex = COMMANDS.findIndex((command) => command.id === state.selectedCommandId);
-      const nextIndex = (currentIndex + delta + COMMANDS.length) % COMMANDS.length;
-      state.selectedCommandId = COMMANDS[nextIndex].id;
-    };
+      if (state.viewMode === "scene_list") {
+        const menuSize = SCENES.length + 1;
+        const currentIndex = Number.isFinite(state.rootSelectionIndex) ? state.rootSelectionIndex : 0;
+        const nextIndex = (currentIndex + delta + menuSize) % menuSize;
+        state.rootSelectionIndex = nextIndex;
+        if (nextIndex < SCENES.length) {
+          state.activeSceneId = SCENES[nextIndex].id;
+        }
+        return;
+      }
 
-    const onKeypress = async (str, key = {}) => {
-      if (closed) {
+      if (state.viewMode === "scene_actions") {
+        const next = getSceneActionIndex(state) + delta;
+        setSceneActionIndex(state, next);
         return;
       }
-      if (state.busy) {
+
+      if (state.viewMode === "work_item_switch") {
+        const next = getWorkItemSelectionIndex(state) + delta;
+        setWorkItemSelectionIndex(state, next);
+      }
+    };
+
+    const onKeypress = async (str, key = {}) => {
+      if (closed || state.busy) {
         return;
       }
       const action = getKeyAction(str, key);
       if (!action) {
         return;
       }
+
       if (action === "quit") {
         close();
         return;
@@ -621,26 +2362,35 @@ async function launchTui(options = {}) {
       }
       if (action === "toggle_lang") {
         state.lang = state.lang === "zh" ? "en" : "zh";
+        savePreferences({ lang: state.lang });
+        state.lastStatus = `language -> ${state.lang}`;
+        appendLogEvent(state, "system", "language_toggle", "ok", state.lang);
         renderState(state);
         return;
       }
-      if (action === "toggle_command_help") {
-        state.commandHelpVisible = !state.commandHelpVisible;
+      if (action === "toggle_theme") {
+        state.themeMode = cycleThemeMode(state.themeMode);
+        applyThemeMode(state.themeMode);
+        state.lastStatus = `theme -> ${state.themeMode}`;
+        appendLogEvent(state, "system", "theme_toggle", "ok", state.themeMode);
         renderState(state);
         return;
       }
       if (action === "toggle_strict") {
         state.strict = !state.strict;
+        appendLogEvent(state, "system", "strict_toggle", "ok", String(state.strict));
         renderState(state);
         return;
       }
       if (action === "toggle_json") {
         state.jsonOutput = !state.jsonOutput;
+        appendLogEvent(state, "system", "json_toggle", "ok", String(state.jsonOutput));
         renderState(state);
         return;
       }
       if (action === "toggle_continue_on_error") {
         state.continueOnError = !state.continueOnError;
+        appendLogEvent(state, "system", "continue_toggle", "ok", String(state.continueOnError));
         renderState(state);
         return;
       }
@@ -653,6 +2403,8 @@ async function launchTui(options = {}) {
             state.projectPath
           );
           state.projectPath = value || process.cwd();
+          state.lastStatus = `project -> ${state.projectPath}`;
+          appendLogEvent(state, "system", "project_set", "ok", state.projectPath);
         } finally {
           state.busy = false;
         }
@@ -669,16 +2421,8 @@ async function launchTui(options = {}) {
             { allowBlank: true }
           );
           state.changeId = value;
-        } finally {
-          state.busy = false;
-        }
-        renderState(state);
-        return;
-      }
-      if (action === "edit_and_run") {
-        state.busy = true;
-        try {
-          await runPreview(state, { forceEdit: true });
+          state.lastStatus = `change -> ${state.changeId || "auto"}`;
+          appendLogEvent(state, "system", "change_set", "ok", state.changeId || "auto");
         } finally {
           state.busy = false;
         }
@@ -686,18 +2430,112 @@ async function launchTui(options = {}) {
         return;
       }
       if (action === "run") {
-        state.busy = true;
-        try {
-          await runPreview(state, { forceEdit: false });
-        } finally {
-          state.busy = false;
+        if (state.viewMode === "scene_list") {
+          const menuSize = SCENES.length + 1;
+          const rootIndex =
+            Number.isFinite(state.rootSelectionIndex) && menuSize > 0
+              ? ((state.rootSelectionIndex % menuSize) + menuSize) % menuSize
+              : 0;
+          state.rootSelectionIndex = rootIndex;
+          if (rootIndex === SCENES.length) {
+            close();
+            return;
+          }
+          const selectedScene = SCENES[rootIndex] || SCENES[0];
+          state.activeSceneId = selectedScene.id;
+          if (
+            selectedScene.id === "current-status" ||
+            selectedScene.id === "switch-work-item" ||
+            selectedScene.id === "pre-implementation-checks" ||
+            selectedScene.id === "pre-completion-validation"
+          ) {
+            state.busy = true;
+            try {
+              if (selectedScene.id === "current-status") {
+                appendLogEvent(state, state.activeSceneId, "scene_run", "ok", "run current status summary");
+                await runCurrentStatusFlow(state);
+                appendLogEvent(state, state.activeSceneId, "scene_complete", "ok", "run current status summary");
+              } else if (selectedScene.id === "pre-implementation-checks") {
+                appendLogEvent(state, state.activeSceneId, "scene_run", "ok", "run implementation readiness checks");
+                await runPreImplementationChecks(state);
+                appendLogEvent(state, state.activeSceneId, "scene_complete", "ok", "run implementation readiness checks");
+              } else if (selectedScene.id === "pre-completion-validation") {
+                appendLogEvent(state, state.activeSceneId, "scene_run", "ok", "run standard completion validation");
+                await runPreCompletionValidation(state);
+                appendLogEvent(state, state.activeSceneId, "scene_complete", "ok", "run standard completion validation");
+              } else {
+                appendLogEvent(state, state.activeSceneId, "scene_run", "ok", "open work item switcher");
+                await chooseExistingChange(state);
+                appendLogEvent(state, state.activeSceneId, "scene_complete", "ok", "open work item switcher");
+              }
+            } catch (error) {
+              state.lastStatus = `${selectedScene.id} -> error: ${error.message || String(error)}`;
+              appendLogEvent(state, state.activeSceneId, "scene_complete", "error", error.message || String(error));
+            } finally {
+              state.busy = false;
+            }
+            renderState(state);
+            return;
+          }
+          state.viewMode = "scene_actions";
+          appendLogEvent(state, state.activeSceneId, "scene_enter", "ok", "open scene actions");
+          renderState(state);
+          return;
+        }
+
+        if (state.viewMode === "scene_actions") {
+          const actions = getSceneActions(state, state.activeSceneId);
+          const selectedIndex = getSceneActionIndex(state);
+          if (selectedIndex >= actions.length) {
+            state.viewMode = "scene_list";
+            state.rootSelectionIndex = Math.max(0, SCENES.findIndex((scene) => scene.id === state.activeSceneId));
+            renderState(state);
+            return;
+          }
+          const actionItem = actions[selectedIndex] || null;
+          if (!actionItem) {
+            renderState(state);
+            return;
+          }
+          state.busy = true;
+          try {
+            appendLogEvent(state, state.activeSceneId, "action_start", "ok", actionItem.id);
+            await actionItem.run(state);
+            appendLogEvent(state, state.activeSceneId, "action_complete", "ok", actionItem.id);
+          } catch (error) {
+            state.lastStatus = `${actionItem.id} -> error: ${error.message || String(error)}`;
+            appendLogEvent(state, state.activeSceneId, "action_complete", "error", `${actionItem.id}: ${error.message || String(error)}`);
+          } finally {
+            state.busy = false;
+          }
+          renderState(state);
+          return;
+        }
+
+        if (state.viewMode === "work_item_switch") {
+          const choices = Array.isArray(state.workItemChoices) ? state.workItemChoices : [];
+          const selectedIndex = getWorkItemSelectionIndex(state);
+          if (selectedIndex >= choices.length) {
+            state.viewMode = "scene_list";
+            state.activeSceneId = "switch-work-item";
+            state.rootSelectionIndex = Math.max(0, SCENES.findIndex((scene) => scene.id === "switch-work-item"));
+            renderState(state);
+            return;
+          }
+          state.changeId = choices[selectedIndex];
+          state.lastStatus = `change -> ${state.changeId || "auto"}`;
+          appendLogEvent(state, "switch-work-item", "change_switch", "ok", state.changeId || "auto");
+          state.viewMode = "scene_list";
+          state.activeSceneId = "switch-work-item";
+          state.rootSelectionIndex = Math.max(0, SCENES.findIndex((scene) => scene.id === "switch-work-item"));
+          renderState(state);
+          return;
         }
-        renderState(state);
-        return;
       }
       if (action === "toggle_help") {
         state.helpVisible = !state.helpVisible;
         renderState(state);
+        return;
       }
     };
 
@@ -707,10 +2545,11 @@ async function launchTui(options = {}) {
 }
 
 module.exports = {
+  SCENES,
   COMMANDS,
-  STAGES,
   buildCommandArgs,
   buildDisplayCommand,
+  buildScreenLines,
   formatCommandParameterHelp,
   formatTuiHelp,
   getExecutionCwd,
@@ -719,9 +2558,26 @@ module.exports = {
   getDefaultLanguage,
   getKeyAction,
   launchTui,
+  cycleThemeMode,
+  detectTerminalThemeMode,
+  enterAlternateScreen,
+  exitAlternateScreen,
+  hideCursor,
+  showCursor,
   normalizeEditedCommand,
   parseEditedCommandInput,
+  resolveActiveChangeId,
+  resolveDailyLogPath,
+  resolvePreImplementationResult,
+  readPromptPresetSection,
+  readVisualAssistVariant,
+  applyManagedVisualAssistBlock,
+  applyVisualAssistOverrides,
+  extractVisualAssistSection,
+  parseVisualAssistOverrides,
   resolveLocalizedText,
+  mapRouteToScene,
+  stripAnsi,
   teardownInput,
   tokenizeCommandLine
 };