@imricci/zaker 0.1.1 → 0.1.3

package/dist/commands/dialog.js

@@ -3,23 +3,217 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommandCompletionCandidates = buildCommandCompletionCandidates;
+exports.resolveSlashMenuCandidates = resolveSlashMenuCandidates;
+exports.createTaskBoardState = createTaskBoardState;
+exports.buildTuiFramePreview = buildTuiFramePreview;
+exports.normalizeInteractiveInputChunk = normalizeInteractiveInputChunk;
+exports.parseMouseWheelDeltas = parseMouseWheelDeltas;
+exports.shouldAppendInteractiveTextChunk = shouldAppendInteractiveTextChunk;
+exports.shouldSubmitOnUnparsedLineBreak = shouldSubmitOnUnparsedLineBreak;
+exports.isPlainSubmitSequence = isPlainSubmitSequence;
+exports.resolveAutocompleteCommandCandidatesForTest = resolveAutocompleteCommandCandidatesForTest;
+exports.renderCommandMenuWithSelectListForTest = renderCommandMenuWithSelectListForTest;
+exports.moveCommandSelectionWithSelectListForTest = moveCommandSelectionWithSelectListForTest;
+exports.applyInteractiveBufferEdit = applyInteractiveBufferEdit;
+exports.runInteractiveEditorKeySequenceForTest = runInteractiveEditorKeySequenceForTest;
+exports.shouldTreatCtrlDAsExit = shouldTreatCtrlDAsExit;
+exports.resolveMenuEnterOutcome = resolveMenuEnterOutcome;
+exports.resolveInteractiveLoginCommand = resolveInteractiveLoginCommand;
+exports.handleDialogInput = handleDialogInput;
 exports.runDialogueSession = runDialogueSession;
 exports.registerDialogCommand = registerDialogCommand;
-const node_readline_1 = __importDefault(require("node:readline"));
 const chalk_1 = __importDefault(require("chalk"));
+const pi_tui_1 = require("@mariozechner/pi-tui");
 const verdict_panel_1 = require("../core/verdict-panel");
 const config_1 = require("../infra/config");
+const dialog_session_1 = require("../infra/dialog-session");
+const openai_codex_oauth_1 = require("../infra/openai-codex-oauth");
+const model_accounts_1 = require("../infra/model-accounts");
+const tui_view_1 = require("../infra/tui-view");
+const provider_registry_1 = require("../infra/provider-registry");
 const intent_1 = require("../infra/intent");
+const session_status_1 = require("../infra/session-status");
+const dialog_handlers_1 = require("./dialog-handlers");
 const init_1 = require("./init");
 const run_1 = require("./run");
 const MAX_DIALOG_HISTORY = 200;
 const MAX_DIALOG_ROUNDS = 50;
 const MAX_SCREEN_HISTORY = 14;
+const ESC_DOUBLE_PRESS_WINDOW_MS = 700;
+const MOUSE_REPORT_ENABLE = "\u001b[?1002h\u001b[?1006h";
+const MOUSE_REPORT_DISABLE = "\u001b[?1002l\u001b[?1006l";
+const SGR_MOUSE_EVENT_PATTERN = /\u001b\[<(\d+);(\d+);(\d+)([mM])/g;
+const BASE_COMMAND_COMPLETION_CANDIDATES = [
+    "/init",
+    "/new",
+    "/resume",
+    "/model",
+    "/login",
+    "/logout",
+    "/build",
+    "/run",
+    "/edit ",
+    "/status",
+    "/debug ",
+    "/help",
+    "/exit"
+];
+const LOGOUT_SECOND_LEVEL_CANDIDATES = (0, provider_registry_1.buildLogoutCommandTemplates)();
+const TOP_LEVEL_SUBMENU_COMMANDS = new Set(["/resume", "/model", "/login", "/logout"]);
+const EMPTY_MODEL_MENU_SNAPSHOT = {
+    providers: [],
+    providerCommands: [],
+    directModelCommands: [],
+    providerModelCommands: {}
+};
+const INTERACTIVE_COMMAND_MENU_MAX_VISIBLE = 5;
+const INTERACTIVE_COMMAND_MENU_MIN_WIDTH = 24;
+const INTERACTIVE_COMMAND_MENU_HORIZONTAL_PADDING = 2;
+function isTopLevelSubmenuCommand(command) {
+    return TOP_LEVEL_SUBMENU_COMMANDS.has(command.trim());
+}
+function isLoginProviderSubmenuCommand(command) {
+    const tokens = command.trim().split(/\s+/).filter(Boolean);
+    return tokens.length === 2 && tokens[0] === "/login" && (0, provider_registry_1.isLoginProviderToken)(tokens[1] || "");
+}
+function isModelProviderSubmenuCommand(command, modelMenu) {
+    const tokens = command.trim().split(/\s+/).filter(Boolean);
+    return (tokens.length === 2 &&
+        tokens[0] === "/model" &&
+        (0, model_accounts_1.isModelProviderToken)(tokens[1] || "", modelMenu));
+}
+function uniqueCommandCandidates(values) {
+    const seen = new Set();
+    const ordered = [];
+    for (const value of values) {
+        if (!value.trim() || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        ordered.push(value);
+    }
+    return ordered;
+}
+function buildCommandCompletionCandidates() {
+    return uniqueCommandCandidates([...BASE_COMMAND_COMPLETION_CANDIDATES]);
+}
+function buildResumeSecondLevelCandidates(sessionIds = []) {
+    const resumeCandidates = sessionIds
+        .map((id) => id.trim())
+        .filter((id) => /^[a-zA-Z0-9_-]{1,40}$/.test(id))
+        .map((id) => `/resume ${id}`);
+    return uniqueCommandCandidates(["/resume", ...resumeCandidates]);
+}
+function resolveModelSlashCandidates(buffer, modelMenu) {
+    const normalized = buffer.trimEnd();
+    if (normalized === "/model" && !buffer.endsWith(" ")) {
+        return ["/model"];
+    }
+    if (!buffer.startsWith("/model ")) {
+        return [];
+    }
+    if (modelMenu.providers.length === 0) {
+        return ["/model"];
+    }
+    if (modelMenu.providers.length === 1) {
+        const commands = modelMenu.directModelCommands;
+        return commands.length > 0 ? commands : ["/model"];
+    }
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    if (tokens.length <= 1) {
+        return modelMenu.providerCommands;
+    }
+    const providerToken = tokens[1] || "";
+    if (tokens.length === 2) {
+        if (buffer.endsWith(" ") && (0, model_accounts_1.isModelProviderToken)(providerToken, modelMenu)) {
+            return modelMenu.providerModelCommands[providerToken] || [];
+        }
+        return modelMenu.providerCommands;
+    }
+    return modelMenu.providerModelCommands[providerToken] || [];
+}
+function resolveSlashMenuCandidates(buffer, sessionIds = [], modelMenu = EMPTY_MODEL_MENU_SNAPSHOT) {
+    if (!buffer.startsWith("/")) {
+        return [];
+    }
+    const normalized = buffer.trimEnd();
+    if (buffer.startsWith("/resume ")) {
+        return buildResumeSecondLevelCandidates(sessionIds);
+    }
+    if (buffer.startsWith("/model")) {
+        return resolveModelSlashCandidates(buffer, modelMenu);
+    }
+    if (buffer.startsWith("/login ")) {
+        const tokens = normalized.split(/\s+/).filter(Boolean);
+        if (tokens.length <= 1) {
+            return (0, provider_registry_1.buildLoginProviderCommandTemplates)();
+        }
+        const providerToken = tokens[1] ?? "";
+        if (tokens.length === 2) {
+            if (buffer.endsWith(" ") && (0, provider_registry_1.isLoginProviderToken)(providerToken)) {
+                return (0, provider_registry_1.buildLoginModeCommandTemplates)(providerToken);
+            }
+            return (0, provider_registry_1.buildLoginProviderCommandTemplates)();
+        }
+        return (0, provider_registry_1.buildLoginModeCommandTemplates)(providerToken);
+    }
+    if (buffer.startsWith("/logout ")) {
+        return LOGOUT_SECOND_LEVEL_CANDIDATES;
+    }
+    if (isTopLevelSubmenuCommand(normalized)) {
+        return buildCommandCompletionCandidates();
+    }
+    return buildCommandCompletionCandidates();
+}
+function createTaskBoardState() {
+    return {
+        run_stage: "IDLE",
+        run_status: "IDLE",
+        verification_status: "PENDING",
+        verification_passed: 0,
+        verification_total: 0,
+        risk_hit: "-",
+        audit_verdict: "PENDING",
+        audit_reason: "-",
+        audit_conclusion: "-",
+        retry_allowed: "-",
+        budget_plan_calls: 0,
+        budget_audit_calls: 0,
+        budget_challenge_used: 0
+    };
+}
+function resetBoard(board) {
+    const fresh = createTaskBoardState();
+    board.run_stage = fresh.run_stage;
+    board.run_status = fresh.run_status;
+    board.verification_status = fresh.verification_status;
+    board.verification_passed = fresh.verification_passed;
+    board.verification_total = fresh.verification_total;
+    board.risk_hit = fresh.risk_hit;
+    board.audit_verdict = fresh.audit_verdict;
+    board.audit_reason = fresh.audit_reason;
+    board.audit_conclusion = fresh.audit_conclusion;
+    board.retry_allowed = fresh.retry_allowed;
+    board.budget_plan_calls = fresh.budget_plan_calls;
+    board.budget_audit_calls = fresh.budget_audit_calls;
+    board.budget_challenge_used = fresh.budget_challenge_used;
+}
 function now() {
     return new Date().toISOString();
 }
+function isExitLifecycleNoise(entry) {
+    const content = entry.content.trim().toLowerCase();
+    if (entry.role === "user" && entry.kind === "command" && content === "/exit") {
+        return true;
+    }
+    if (entry.role === "system" && entry.kind === "status" && content === "dialog ended") {
+        return true;
+    }
+    return false;
+}
 function helpText() {
-    return "commands: /init | /confirm | /run | /edit <text> | /status | /debug on|off | /help | /exit";
+    return "commands: /init | /new [id] | /resume [id] | /model ... | /login ... | /logout ... | /build | /run | /edit <text> | /status | /debug on|off | /help | /exit";
 }
 function compactLine(input, maxLength = 120) {
     const singleLine = input.replace(/\s+/g, " ").trim();
@@ -28,8 +222,1029 @@ function compactLine(input, maxLength = 120) {
     }
     return `${singleLine.slice(0, maxLength - 3)}...`;
 }
-function divider(width = 80) {
-    return "─".repeat(width);
+function formatTuiModelInfo(config) {
+    const provider = config.model.provider?.trim() || "-";
+    const model = config.model.planner_model?.trim() || "auto";
+    return `${provider}/${model}`;
+}
+function buildTuiFramePreview(params, viewport = {}) {
+    return (0, tui_view_1.buildTuiFramePreview)({
+        ...params,
+        helpText: params.helpText ?? helpText()
+    }, viewport);
+}
+class PiFrameComponent {
+    readSnapshot;
+    readRows;
+    focused = false;
+    constructor(readSnapshot, readRows) {
+        this.readSnapshot = readSnapshot;
+        this.readRows = readRows;
+    }
+    render(width) {
+        const snapshot = this.readSnapshot();
+        if (!snapshot) {
+            return [];
+        }
+        return (0, tui_view_1.buildTwoPaneFrameLines)(snapshot, Math.max(width, tui_view_1.MIN_TUI_COLUMNS), Math.max(this.readRows(), tui_view_1.MIN_TUI_ROWS));
+    }
+    invalidate() {
+        // no-op
+    }
+}
+async function loadPiTuiModule() {
+    const dynamicImport = new Function("specifier", "return import(specifier);");
+    const loaded = await dynamicImport("@mariozechner/pi-tui");
+    return loaded;
+}
+async function createPiFrameRenderer(inputSource) {
+    let tui = null;
+    let detachInputListener = null;
+    try {
+        const module = await loadPiTuiModule();
+        const terminal = new pi_tui_1.ProcessTerminal();
+        tui = new module.TUI(terminal, true);
+        let snapshot = null;
+        const component = new PiFrameComponent(() => snapshot, () => process.stdout.rows || tui_view_1.MIN_TUI_ROWS);
+        tui.addChild(component);
+        tui.setFocus?.(component);
+        detachInputListener = tui.addInputListener((data) => {
+            inputSource.emitSequence(data);
+            return undefined;
+        });
+        tui.start();
+        const activeTui = tui;
+        activeTui.terminal?.write?.(MOUSE_REPORT_ENABLE);
+        return {
+            render(params) {
+                snapshot = {
+                    ...params,
+                    cursorMarker: pi_tui_1.CURSOR_MARKER
+                };
+                activeTui.requestRender();
+            },
+            async dispose() {
+                activeTui.terminal?.write?.(MOUSE_REPORT_DISABLE);
+                activeTui.setFocus?.(null);
+                detachInputListener?.();
+                inputSource.clear();
+                await activeTui.terminal?.drainInput?.(1000);
+                activeTui.stop();
+            }
+        };
+    }
+    catch (error) {
+        try {
+            detachInputListener?.();
+        }
+        catch {
+            // ignore input listener teardown failures during fallback
+        }
+        try {
+            tui?.terminal?.write?.(MOUSE_REPORT_DISABLE);
+        }
+        catch {
+            // ignore mouse-report teardown failures during fallback
+        }
+        try {
+            await tui?.terminal?.drainInput?.(1000);
+        }
+        catch {
+            // ignore terminal drain failures during fallback
+        }
+        try {
+            tui?.stop();
+        }
+        catch {
+            // ignore terminal teardown failures during fallback
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`failed to initialize pi-tui renderer: ${message}`);
+    }
+}
+const NON_TEXT_KEY_NAMES = new Set([
+    "up",
+    "down",
+    "left",
+    "right",
+    "pageup",
+    "pagedown",
+    "home",
+    "end",
+    "insert",
+    "delete",
+    "escape",
+    "tab",
+    "return",
+    "enter",
+    "backspace"
+]);
+function normalizeInteractiveInputChunk(chunk) {
+    if (!chunk) {
+        return { text: "", hasLineBreak: false };
+    }
+    const unwrapped = chunk.replace(/\u001b\[200~/g, "").replace(/\u001b\[201~/g, "");
+    const withoutAnsi = unwrapped
+        .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "")
+        .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\u001bO[ -~]/g, "");
+    const hasLineBreak = /[\r\n]/.test(withoutAnsi);
+    let text = withoutAnsi
+        .replace(/[\r\n]+/g, " ")
+        .replace(/[\u0000-\u0008\u000B-\u001F\u007F]/g, "")
+        .replace(/\uFF0F/g, "/")
+        .replace(/\u3000/g, " ");
+    if (hasLineBreak) {
+        text = text.replace(/\s+$/g, "");
+    }
+    return { text, hasLineBreak };
+}
+function parseMouseWheelDeltas(chunk) {
+    if (!chunk.includes("\u001b[<")) {
+        return [];
+    }
+    SGR_MOUSE_EVENT_PATTERN.lastIndex = 0;
+    const deltas = [];
+    let match = SGR_MOUSE_EVENT_PATTERN.exec(chunk);
+    while (match) {
+        const code = Number(match[1] || "");
+        if (Number.isFinite(code) && (code & 64) === 64) {
+            const isDown = (code & 1) === 1;
+            deltas.push(isDown ? -1 : 1);
+        }
+        match = SGR_MOUSE_EVENT_PATTERN.exec(chunk);
+    }
+    return deltas;
+}
+function shouldAppendInteractiveTextChunk(chunk, key, normalizedChunk) {
+    if (!normalizedChunk.text) {
+        return false;
+    }
+    if (key.ctrl || key.meta) {
+        return false;
+    }
+    const keyName = (key.name || "").toLowerCase();
+    if (NON_TEXT_KEY_NAMES.has(keyName)) {
+        return false;
+    }
+    if (chunk.includes("\u001b") && !isBracketedPasteSequence(chunk) && keyName.length > 0) {
+        return false;
+    }
+    if (keyName && keyName.length > 1 && keyName !== "space") {
+        return false;
+    }
+    return true;
+}
+function shouldSubmitOnUnparsedLineBreak(key, normalizedChunk) {
+    return !key.name && normalizedChunk.hasLineBreak && normalizedChunk.text.trim().length === 0;
+}
+function isPlainSubmitSequence(sequence) {
+    return sequence === "\r" || sequence === "\n" || sequence === "\r\n";
+}
+function isBracketedPasteSequence(sequence) {
+    return sequence.startsWith("\u001b[200~") && sequence.includes("\u001b[201~");
+}
+function isUnparsedControlSequence(sequence, parsedKey) {
+    if (parsedKey || isBracketedPasteSequence(sequence)) {
+        return false;
+    }
+    if (!sequence.includes("\u001b")) {
+        return false;
+    }
+    const normalized = normalizeInteractiveInputChunk(sequence);
+    return normalized.text.length === 0;
+}
+function normalizeParsedKeyName(name) {
+    const normalized = (name || "").toLowerCase();
+    if (normalized === "pageup") {
+        return "pageup";
+    }
+    if (normalized === "pagedown") {
+        return "pagedown";
+    }
+    if (normalized === "esc") {
+        return "escape";
+    }
+    if (normalized === "enter") {
+        return "enter";
+    }
+    return normalized;
+}
+function toReadlineKey(parsedKey) {
+    const key = {
+        name: undefined,
+        ctrl: false,
+        meta: false,
+        shift: false
+    };
+    if (!parsedKey) {
+        return key;
+    }
+    const tokens = parsedKey.split("+").filter((token) => token.length > 0);
+    const baseToken = tokens.pop();
+    key.name = normalizeParsedKeyName(baseToken);
+    key.ctrl = tokens.includes("ctrl");
+    key.meta = tokens.includes("alt");
+    key.shift = tokens.includes("shift");
+    return key;
+}
+class DialogInputBuffer {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    clear() {
+        this.listeners.clear();
+    }
+    emitSequence(sequence) {
+        if ((0, pi_tui_1.isKeyRelease)(sequence)) {
+            return;
+        }
+        const parsedKey = (0, pi_tui_1.parseKey)(sequence);
+        const event = {
+            sequence,
+            parsedKey,
+            key: toReadlineKey(parsedKey)
+        };
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+}
+function buildSlashAutocompleteContext(resolveCandidates) {
+    const templateByName = new Map();
+    const topLevelCandidates = buildCommandCompletionCandidates();
+    for (const candidate of topLevelCandidates) {
+        const trimmed = candidate.trimEnd();
+        const token = trimmed.split(/\s+/).filter(Boolean)[0] || "";
+        if (!token.startsWith("/")) {
+            continue;
+        }
+        const name = token.slice(1);
+        if (!name) {
+            continue;
+        }
+        const previous = templateByName.get(name);
+        if (!previous || (candidate.endsWith(" ") && !previous.endsWith(" "))) {
+            templateByName.set(name, candidate);
+        }
+    }
+    const commands = [];
+    for (const [name, template] of templateByName.entries()) {
+        commands.push({
+            name,
+            description: (0, tui_view_1.describeCommand)(template),
+            getArgumentCompletions: (argumentPrefix) => {
+                const query = argumentPrefix.length > 0 ? `/${name} ${argumentPrefix}` : `/${name} `;
+                const items = resolveCandidates(query)
+                    .filter((command) => command.startsWith(`/${name}`))
+                    .map((command) => ({
+                    value: command,
+                    label: command,
+                    description: (0, tui_view_1.describeCommand)(command)
+                }));
+                return items.length > 0 ? items : null;
+            }
+        });
+    }
+    return {
+        provider: new pi_tui_1.CombinedAutocompleteProvider(commands, process.cwd(), null),
+        templateByName
+    };
+}
+function normalizeAutocompleteCommandItem(item, prefix, templateByName) {
+    if (item.value.startsWith("/")) {
+        return item.value;
+    }
+    if (prefix.startsWith("/")) {
+        return templateByName.get(item.value) ?? `/${item.value}`;
+    }
+    return item.value;
+}
+function resolveAutocompleteCommandCandidates(buffer, cursorIndex, resolveCandidates) {
+    if (!buffer.startsWith("/")) {
+        return [];
+    }
+    const safeCursorIndex = Math.max(0, Math.min(cursorIndex, buffer.length));
+    const beforeCursor = buffer.slice(0, safeCursorIndex);
+    if (!beforeCursor.startsWith("/")) {
+        return [];
+    }
+    const { provider, templateByName } = buildSlashAutocompleteContext(resolveCandidates);
+    const suggestions = provider.getSuggestions([buffer], 0, safeCursorIndex);
+    if (!suggestions || suggestions.items.length === 0) {
+        return [];
+    }
+    const normalized = suggestions.items
+        .map((item) => normalizeAutocompleteCommandItem(item, suggestions.prefix, templateByName))
+        .filter((item) => Boolean(item))
+        .filter((item) => item.startsWith(beforeCursor));
+    return uniqueCommandCandidates(normalized);
+}
+function resolveAutocompleteCommandCandidatesForTest(buffer, cursorIndex, resolveCandidates) {
+    return resolveAutocompleteCommandCandidates(buffer, cursorIndex, resolveCandidates);
+}
+function resolveCompletion(buffer, cursorIndex, resolveCandidates) {
+    const candidates = resolveAutocompleteCommandCandidates(buffer, cursorIndex, resolveCandidates);
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    if (candidates.length > 1) {
+        return undefined;
+    }
+    const fallbackCandidates = resolveCandidates(buffer).filter((command) => command.startsWith(buffer));
+    if (fallbackCandidates.length === 1) {
+        return fallbackCandidates[0];
+    }
+    return undefined;
+}
+function resolveCommandMenu(buffer, cursorIndex, selectedIndex, resolveCandidates) {
+    if (!buffer.startsWith("/")) {
+        return { active: false, items: [], selectedIndex: 0 };
+    }
+    const providerCandidates = resolveAutocompleteCommandCandidates(buffer, cursorIndex, resolveCandidates);
+    const items = providerCandidates.length > 0
+        ? providerCandidates
+        : resolveCandidates(buffer).filter((command) => command.startsWith(buffer));
+    if (items.length === 0) {
+        return { active: false, items: [], selectedIndex: 0 };
+    }
+    const normalizedSelected = Math.max(0, Math.min(selectedIndex, items.length - 1));
+    return {
+        active: true,
+        items,
+        selectedIndex: normalizedSelected
+    };
+}
+function createCommandSelectList(commandMenu) {
+    const selectItems = commandMenu.items.map((command) => ({
+        value: command,
+        label: command,
+        description: (0, tui_view_1.describeCommand)(command)
+    }));
+    const picker = new pi_tui_1.SelectList(selectItems, Math.min(selectItems.length, INTERACTIVE_COMMAND_MENU_MAX_VISIBLE), {
+        selectedPrefix: IDENTITY_STYLE,
+        selectedText: IDENTITY_STYLE,
+        description: IDENTITY_STYLE,
+        scrollInfo: IDENTITY_STYLE,
+        noMatch: IDENTITY_STYLE
+    });
+    picker.setSelectedIndex(Math.max(0, Math.min(commandMenu.selectedIndex, selectItems.length - 1)));
+    return picker;
+}
+function renderCommandMenuWithSelectList(commandMenu) {
+    if (!commandMenu.active || commandMenu.items.length === 0) {
+        return commandMenu;
+    }
+    const picker = createCommandSelectList(commandMenu);
+    const menuWidth = Math.max((process.stdout.columns || tui_view_1.MIN_TUI_COLUMNS) - INTERACTIVE_COMMAND_MENU_HORIZONTAL_PADDING, INTERACTIVE_COMMAND_MENU_MIN_WIDTH);
+    return {
+        active: true,
+        items: picker.render(menuWidth),
+        selectedIndex: 0,
+        renderMode: "raw"
+    };
+}
+function moveCommandSelectionWithSelectList(commandMenu, sequence) {
+    if (!commandMenu.active || commandMenu.items.length === 0) {
+        return commandMenu.selectedIndex;
+    }
+    const picker = createCommandSelectList(commandMenu);
+    let selectedValue = commandMenu.items[commandMenu.selectedIndex] ?? commandMenu.items[0];
+    picker.onSelectionChange = (item) => {
+        selectedValue = item.value;
+    };
+    picker.handleInput(sequence);
+    const nextIndex = commandMenu.items.findIndex((command) => command === selectedValue);
+    if (nextIndex < 0) {
+        return commandMenu.selectedIndex;
+    }
+    return nextIndex;
+}
+function renderCommandMenuWithSelectListForTest(items, selectedIndex = 0, width = tui_view_1.MIN_TUI_COLUMNS) {
+    const commandMenu = {
+        active: true,
+        items: [...items],
+        selectedIndex: Math.max(0, Math.min(selectedIndex, Math.max(0, items.length - 1)))
+    };
+    if (commandMenu.items.length === 0) {
+        return [];
+    }
+    const picker = createCommandSelectList(commandMenu);
+    const menuWidth = Math.max(width, INTERACTIVE_COMMAND_MENU_MIN_WIDTH);
+    return picker.render(menuWidth);
+}
+function moveCommandSelectionWithSelectListForTest(items, selectedIndex, sequence) {
+    if (items.length === 0) {
+        return 0;
+    }
+    return moveCommandSelectionWithSelectList({
+        active: true,
+        items: [...items],
+        selectedIndex: Math.max(0, Math.min(selectedIndex, items.length - 1))
+    }, sequence);
+}
+function applyInteractiveBufferEdit(state, action) {
+    const buffer = state.buffer;
+    const cursorIndex = Math.max(0, Math.min(state.cursorIndex, buffer.length));
+    if (action.type === "move_left") {
+        return { buffer, cursorIndex: Math.max(0, cursorIndex - 1) };
+    }
+    if (action.type === "move_right") {
+        return { buffer, cursorIndex: Math.min(buffer.length, cursorIndex + 1) };
+    }
+    if (action.type === "backspace") {
+        if (cursorIndex <= 0) {
+            return { buffer, cursorIndex };
+        }
+        return {
+            buffer: `${buffer.slice(0, cursorIndex - 1)}${buffer.slice(cursorIndex)}`,
+            cursorIndex: cursorIndex - 1
+        };
+    }
+    if (action.type === "delete") {
+        if (cursorIndex >= buffer.length) {
+            return { buffer, cursorIndex };
+        }
+        return {
+            buffer: `${buffer.slice(0, cursorIndex)}${buffer.slice(cursorIndex + 1)}`,
+            cursorIndex
+        };
+    }
+    if (!action.text) {
+        return { buffer, cursorIndex };
+    }
+    return {
+        buffer: `${buffer.slice(0, cursorIndex)}${action.text}${buffer.slice(cursorIndex)}`,
+        cursorIndex: cursorIndex + action.text.length
+    };
+}
+const IDENTITY_STYLE = (value) => value;
+const INPUT_EDITOR_THEME = {
+    borderColor: IDENTITY_STYLE,
+    selectList: {
+        selectedPrefix: IDENTITY_STYLE,
+        selectedText: IDENTITY_STYLE,
+        description: IDENTITY_STYLE,
+        scrollInfo: IDENTITY_STYLE,
+        noMatch: IDENTITY_STYLE
+    }
+};
+function toAbsoluteCursorIndex(lines, cursorLine, cursorCol) {
+    const safeLines = lines.length > 0 ? lines : [""];
+    const clampedLine = Math.max(0, Math.min(cursorLine, safeLines.length - 1));
+    let index = 0;
+    for (let lineIndex = 0; lineIndex < clampedLine; lineIndex += 1) {
+        index += (safeLines[lineIndex] || "").length + 1;
+    }
+    const line = safeLines[clampedLine] || "";
+    index += Math.max(0, Math.min(cursorCol, line.length));
+    return index;
+}
+function createInteractiveEditorBridge(onSubmit) {
+    const tuiStub = {
+        terminal: {
+            get rows() {
+                return process.stdout.rows || tui_view_1.MIN_TUI_ROWS;
+            },
+            get columns() {
+                return process.stdout.columns || tui_view_1.MIN_TUI_COLUMNS;
+            }
+        },
+        requestRender() {
+            return undefined;
+        }
+    };
+    const editor = new pi_tui_1.Editor(tuiStub, INPUT_EDITOR_THEME);
+    editor.onSubmit = onSubmit;
+    const getSnapshot = () => {
+        const buffer = editor.getText();
+        const cursor = editor.getCursor();
+        const lines = editor.getLines();
+        return {
+            buffer,
+            cursorIndex: toAbsoluteCursorIndex(lines, cursor.line, cursor.col)
+        };
+    };
+    return {
+        getSnapshot,
+        setText(value) {
+            editor.setText(value);
+        },
+        insertText(value) {
+            if (!value) {
+                return;
+            }
+            editor.insertTextAtCursor(value);
+        },
+        handleInput(sequence) {
+            editor.handleInput(sequence);
+            return getSnapshot();
+        }
+    };
+}
+function runInteractiveEditorKeySequenceForTest(initialBuffer, sequences) {
+    const submissions = [];
+    const bridge = createInteractiveEditorBridge((value) => {
+        submissions.push(value);
+    });
+    bridge.setText(initialBuffer);
+    let snapshot = bridge.getSnapshot();
+    for (const sequence of sequences) {
+        snapshot = bridge.handleInput(sequence);
+    }
+    return {
+        buffer: snapshot.buffer,
+        cursorIndex: snapshot.cursorIndex,
+        submissions
+    };
+}
+function shouldTreatCtrlDAsExit(buffer, key) {
+    return key.ctrl === true && key.name === "d" && buffer.length === 0;
+}
+function resolveMenuEnterOutcome(buffer, selected, modelMenu = EMPTY_MODEL_MENU_SNAPSHOT) {
+    if (!selected) {
+        return { buffer, submit: true };
+    }
+    const selectedTrim = selected.trimEnd();
+    const currentTrim = buffer.trim();
+    const requiresArgument = selected.endsWith(" ");
+    if (isTopLevelSubmenuCommand(selectedTrim)) {
+        if (buffer !== `${selectedTrim} `) {
+            return { buffer: `${selectedTrim} `, submit: false };
+        }
+        return { buffer, submit: false };
+    }
+    if (isLoginProviderSubmenuCommand(selectedTrim)) {
+        if (buffer !== `${selectedTrim} `) {
+            return { buffer: `${selectedTrim} `, submit: false };
+        }
+        return { buffer, submit: false };
+    }
+    if (isModelProviderSubmenuCommand(selectedTrim, modelMenu)) {
+        if (buffer !== `${selectedTrim} `) {
+            return { buffer: `${selectedTrim} `, submit: false };
+        }
+        return { buffer, submit: false };
+    }
+    if (currentTrim !== selectedTrim) {
+        if (requiresArgument) {
+            return { buffer: selected, submit: false };
+        }
+        return { buffer: selected, submit: true };
+    }
+    return { buffer, submit: true };
+}
+function parseLoginCommandParts(line) {
+    const tokens = line.trim().split(/\s+/).filter(Boolean);
+    if (tokens[0] !== "/login") {
+        return null;
+    }
+    const providerToken = tokens[1]?.toLowerCase();
+    if (!providerToken) {
+        return null;
+    }
+    const modeToken = tokens[2]?.toLowerCase();
+    const hasModeToken = modeToken === "oauth" || modeToken === "api_key";
+    if (providerToken === "http") {
+        return {
+            provider: "http",
+            authMode: "api_key",
+            apiKey: hasModeToken ? tokens[3] : tokens[2],
+            endpointOrHost: hasModeToken ? tokens[4] : tokens[3]
+        };
+    }
+    if (providerToken === "ollama") {
+        return {
+            provider: "ollama",
+            authMode: "api_key",
+            apiKey: tokens[2],
+            endpointOrHost: tokens[2]
+        };
+    }
+    let provider;
+    try {
+        provider = (0, provider_registry_1.toLoginProviderId)(providerToken);
+    }
+    catch {
+        return null;
+    }
+    const authMode = modeToken === "oauth" ? "oauth" : "api_key";
+    if (providerToken === "openai" && authMode === "oauth") {
+        provider = "openai-codex";
+    }
+    return {
+        provider,
+        authMode,
+        apiKey: hasModeToken ? tokens[3] : tokens[2],
+        endpointOrHost: hasModeToken ? tokens[4] : tokens[3]
+    };
+}
+async function resolveInteractiveLoginCommand(params) {
+    const parts = parseLoginCommandParts(params.line);
+    if (!parts) {
+        return { action: "continue", line: params.line };
+    }
+    const config = await (0, config_1.readConfig)(params.cwd);
+    if (parts.provider !== "http" && parts.provider !== "ollama") {
+        const useOAuth = parts.authMode === "oauth";
+        if (useOAuth && !(0, provider_registry_1.providerSupportsOAuth)(parts.provider)) {
+            return { action: "cancel", notice: `Provider "${parts.provider}" does not support oauth login.` };
+        }
+        if (parts.provider === "openai-codex" &&
+            useOAuth &&
+            !parts.apiKey?.trim() &&
+            params.oauth_browser?.enabled) {
+            const notify = async (notice) => {
+                if (params.oauth_browser?.notify) {
+                    await params.oauth_browser.notify(notice);
+                }
+            };
+            const oauthState = {
+                url: "",
+                instruction: "",
+                status: "ready"
+            };
+            const publishOAuthState = async () => {
+                const lines = [
+                    "OpenAI OAuth",
+                    oauthState.url ? `URL: ${oauthState.url}` : "URL: (pending)",
+                    oauthState.instruction || "Use browser login. If auto-open fails, copy URL manually.",
+                    `Status: ${oauthState.status}`,
+                    "Esc: cancel OAuth flow"
+                ];
+                await notify(lines.join("\n"));
+            };
+            const loader = new pi_tui_1.CancellableLoader({ requestRender: () => undefined }, IDENTITY_STYLE, IDENTITY_STYLE, "OpenAI OAuth");
+            let cancelledByEsc = false;
+            loader.onAbort = () => {
+                cancelledByEsc = true;
+            };
+            const detachEscapeListener = params.input_source?.subscribe((event) => {
+                loader.handleInput(event.sequence);
+            });
+            const runOAuth = params.oauth_browser?.run_openai_oauth ?? (async (input) => await (0, openai_codex_oauth_1.loginOpenAICodexOAuth)({
+                onAuth: input.onAuth,
+                onProgress: input.onProgress,
+                onPrompt: input.onPrompt,
+                open_browser: true,
+                abort_signal: input.abort_signal
+            }));
+            try {
+                await publishOAuthState();
+                const oauthResult = await runOAuth({
+                    onAuth: async ({ url, instructions }) => {
+                        oauthState.url = url;
+                        oauthState.instruction = instructions;
+                        oauthState.status = "authorization URL ready";
+                        await publishOAuthState();
+                    },
+                    onProgress: async (message) => {
+                        oauthState.status = message;
+                        await publishOAuthState();
+                    },
+                    onPrompt: async (notice) => await params.prompt(notice),
+                    abort_signal: loader.signal
+                });
+                const token = oauthResult.access_token?.trim();
+                if (!token) {
+                    return { action: "cancel", notice: "OpenAI OAuth cancelled: missing access token" };
+                }
+                return {
+                    action: "continue",
+                    line: `/login ${parts.provider} oauth ${token}`
+                };
+            }
+            catch (error) {
+                if (cancelledByEsc) {
+                    return { action: "cancel", notice: "OpenAI OAuth cancelled (Esc)." };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                if (/cancel/i.test(message)) {
+                    return { action: "cancel", notice: "OpenAI OAuth cancelled." };
+                }
+                return { action: "cancel", notice: `OpenAI OAuth failed: ${message}` };
+            }
+            finally {
+                detachEscapeListener?.();
+                loader.dispose();
+            }
+        }
+        if (parts.apiKey?.trim()) {
+            const endpoint = parts.endpointOrHost?.trim();
+            return {
+                action: "continue",
+                line: useOAuth
+                    ? `/login ${parts.provider} oauth ${parts.apiKey}${endpoint ? ` ${endpoint}` : ""}`
+                    : `/login ${parts.provider} ${parts.apiKey}${endpoint ? ` ${endpoint}` : ""}`
+            };
+        }
+        const credentialLabel = useOAuth ? "access_token" : "api_key";
+        const credential = (await params.prompt(`login ${parts.provider}: input ${credentialLabel} (Enter cancel)`)).trim();
+        if (credential === "/exit") {
+            return { action: "exit" };
+        }
+        if (credential === "") {
+            return { action: "cancel", notice: "login cancelled" };
+        }
+        const fallbackEndpoint = config.model.endpoint?.trim() || "";
+        const endpointInput = (await params.prompt(fallbackEndpoint
+            ? `login ${parts.provider}: input endpoint (Enter keep ${fallbackEndpoint})`
+            : `login ${parts.provider}: input endpoint (optional; Enter skip)`)).trim();
+        if (endpointInput === "/exit") {
+            return { action: "exit" };
+        }
+        const endpoint = endpointInput || fallbackEndpoint;
+        return {
+            action: "continue",
+            line: useOAuth
+                ? `/login ${parts.provider} oauth ${credential}${endpoint ? ` ${endpoint}` : ""}`
+                : `/login ${parts.provider} ${credential}${endpoint ? ` ${endpoint}` : ""}`
+        };
+    }
+    if (parts.provider === "http") {
+        let apiKey = parts.apiKey?.trim() || "";
+        if (!apiKey) {
+            apiKey = (await params.prompt("login http: input api_key (Enter cancel)")).trim();
+            if (apiKey === "/exit") {
+                return { action: "exit" };
+            }
+            if (!apiKey) {
+                return { action: "cancel", notice: "login cancelled" };
+            }
+        }
+        let endpoint = parts.endpointOrHost?.trim() || "";
+        if (!endpoint) {
+            const fallbackEndpoint = config.model.endpoint?.trim() || "";
+            const endpointInput = (await params.prompt(fallbackEndpoint
+                ? `login http: input endpoint (Enter keep ${fallbackEndpoint})`
+                : "login http: input endpoint (required)")).trim();
+            if (endpointInput === "/exit") {
+                return { action: "exit" };
+            }
+            endpoint = endpointInput || fallbackEndpoint;
+            if (!endpoint) {
+                return { action: "cancel", notice: "login cancelled: endpoint required" };
+            }
+        }
+        return {
+            action: "continue",
+            line: `/login http ${apiKey} ${endpoint}`
+        };
+    }
+    if (parts.endpointOrHost?.trim()) {
+        return { action: "continue", line: params.line };
+    }
+    const fallbackHost = config.execution.ollama_host?.trim() || "http://127.0.0.1:11434";
+    const hostInput = (await params.prompt(`login ollama: input host (Enter keep ${fallbackHost})`)).trim();
+    if (hostInput === "/exit") {
+        return { action: "exit" };
+    }
+    const host = hostInput || fallbackHost;
+    return {
+        action: "continue",
+        line: `/login ollama ${host}`
+    };
+}
+async function readInteractiveInput(render, resolveCandidates, inputSource, modelMenu = EMPTY_MODEL_MENU_SNAPSHOT, onNavigationKey) {
+    return await new Promise((resolve) => {
+        let commandSelectedIndex = 0;
+        const cursorVisible = true;
+        let submittedValue = null;
+        const editor = createInteractiveEditorBridge((value) => {
+            submittedValue = value;
+        });
+        let renderInFlight = false;
+        let pendingRender = null;
+        const readSnapshot = () => editor.getSnapshot();
+        const requestRender = (nextBuffer, nextCompletion, nextCommandMenu, nextCursorVisible, nextCommandMenuLabel, nextInputCursorIndex) => {
+            pendingRender = {
+                buffer: nextBuffer,
+                completion: nextCompletion,
+                commandMenu: nextCommandMenu,
+                cursorVisible: nextCursorVisible,
+                commandMenuLabel: nextCommandMenuLabel,
+                inputCursorIndex: nextInputCursorIndex
+            };
+            if (renderInFlight) {
+                return;
+            }
+            renderInFlight = true;
+            void (async () => {
+                while (pendingRender) {
+                    const next = pendingRender;
+                    pendingRender = null;
+                    await render(next.buffer, next.completion, next.commandMenu, next.cursorVisible, next.commandMenuLabel, next.inputCursorIndex);
+                }
+                renderInFlight = false;
+            })();
+        };
+        const refresh = () => {
+            const snapshot = readSnapshot();
+            const buffer = snapshot.buffer;
+            const completion = resolveCompletion(buffer, snapshot.cursorIndex, resolveCandidates);
+            const commandMenu = resolveCommandMenu(buffer, snapshot.cursorIndex, commandSelectedIndex, resolveCandidates);
+            if (commandMenu.active) {
+                commandSelectedIndex = commandMenu.selectedIndex;
+            }
+            else {
+                commandSelectedIndex = 0;
+            }
+            const menuForRender = renderCommandMenuWithSelectList(commandMenu);
+            requestRender(buffer, completion, menuForRender, cursorVisible, undefined, snapshot.cursorIndex);
+        };
+        const applyCurrentCommandSelection = () => {
+            const snapshot = readSnapshot();
+            const buffer = snapshot.buffer;
+            const commandMenu = resolveCommandMenu(buffer, snapshot.cursorIndex, commandSelectedIndex, resolveCandidates);
+            if (!commandMenu.active || commandMenu.items.length === 0) {
+                return false;
+            }
+            const selected = commandMenu.items[commandMenu.selectedIndex] ?? commandMenu.items[0];
+            if (!selected) {
+                return false;
+            }
+            editor.setText(selected);
+            commandSelectedIndex = commandMenu.selectedIndex;
+            refresh();
+            return true;
+        };
+        const cleanup = () => {
+            unsubscribeInput();
+        };
+        const finish = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const onInput = (event) => {
+            const { sequence, key, parsedKey } = event;
+            const submitCurrentBuffer = (buffer, cursorIndex) => {
+                const commandMenu = resolveCommandMenu(buffer, cursorIndex, commandSelectedIndex, resolveCandidates);
+                if (commandMenu.active && commandMenu.items.length > 0) {
+                    const selected = commandMenu.items[commandMenu.selectedIndex] ?? commandMenu.items[0];
+                    const outcome = resolveMenuEnterOutcome(buffer, selected, modelMenu);
+                    editor.setText(outcome.buffer);
+                    refresh();
+                    if (!outcome.submit) {
+                        return;
+                    }
+                    finish(outcome.buffer);
+                    return;
+                }
+                finish(buffer);
+            };
+            const current = readSnapshot();
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("c")) || (key.ctrl && key.name === "c")) {
+                finish("/exit");
+                return;
+            }
+            if (shouldTreatCtrlDAsExit(current.buffer, key)) {
+                finish("/exit");
+                return;
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("l")) || (key.ctrl && key.name === "l")) {
+                refresh();
+                return;
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("pageUp")) ||
+                (0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("pageDown")) ||
+                (0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("home")) ||
+                (0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("end")) ||
+                (key.ctrl &&
+                    (key.name === "pageup" ||
+                        key.name === "pagedown" ||
+                        key.name === "home" ||
+                        key.name === "end"))) {
+                onNavigationKey?.(key);
+                refresh();
+                return;
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.up) || key.name === "up") {
+                const commandMenu = resolveCommandMenu(current.buffer, current.cursorIndex, commandSelectedIndex, resolveCandidates);
+                if (commandMenu.active && commandMenu.items.length > 0) {
+                    commandSelectedIndex = moveCommandSelectionWithSelectList(commandMenu, sequence);
+                    refresh();
+                    return;
+                }
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.down) || key.name === "down") {
+                const commandMenu = resolveCommandMenu(current.buffer, current.cursorIndex, commandSelectedIndex, resolveCandidates);
+                if (commandMenu.active && commandMenu.items.length > 0) {
+                    commandSelectedIndex = moveCommandSelectionWithSelectList(commandMenu, sequence);
+                    refresh();
+                    return;
+                }
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.tab) || key.name === "tab") {
+                if (!applyCurrentCommandSelection()) {
+                    const completion = resolveCompletion(current.buffer, current.cursorIndex, resolveCandidates);
+                    if (completion) {
+                        editor.setText(completion);
+                    }
+                }
+                refresh();
+                return;
+            }
+            if ((isPlainSubmitSequence(sequence) ||
+                (0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.enter) ||
+                key.name === "return" ||
+                key.name === "enter") &&
+                !key.shift) {
+                submitCurrentBuffer(current.buffer, current.cursorIndex);
+                return;
+            }
+            const normalizedChunk = normalizeInteractiveInputChunk(sequence);
+            if (isUnparsedControlSequence(sequence, parsedKey)) {
+                return;
+            }
+            if (shouldSubmitOnUnparsedLineBreak(key, normalizedChunk) && !isBracketedPasteSequence(sequence)) {
+                submitCurrentBuffer(current.buffer, current.cursorIndex);
+                return;
+            }
+            const before = readSnapshot();
+            if (!parsedKey &&
+                sequence.includes("\u001b") &&
+                !isBracketedPasteSequence(sequence) &&
+                shouldAppendInteractiveTextChunk(sequence, key, normalizedChunk)) {
+                editor.insertText(normalizedChunk.text);
+                refresh();
+                return;
+            }
+            submittedValue = null;
+            const after = editor.handleInput(sequence);
+            if (submittedValue !== null) {
+                finish(submittedValue);
+                return;
+            }
+            if (after.buffer !== before.buffer || after.cursorIndex !== before.cursorIndex) {
+                refresh();
+            }
+        };
+        const unsubscribeInput = inputSource.subscribe(onInput);
+        refresh();
+    });
+}
+async function readInteractiveResumePicker(render, inputSource, items, initialSelectedIndex = 0) {
+    if (items.length === 0) {
+        return { action: "cancel" };
+    }
+    return await new Promise((resolve) => {
+        const pickerItems = items.map((item) => ({
+            value: item.id,
+            label: item.label
+        }));
+        const picker = new pi_tui_1.SelectList(pickerItems, Math.min(items.length, 4), {
+            selectedPrefix: IDENTITY_STYLE,
+            selectedText: IDENTITY_STYLE,
+            description: IDENTITY_STYLE,
+            scrollInfo: IDENTITY_STYLE,
+            noMatch: IDENTITY_STYLE
+        });
+        picker.setSelectedIndex(Math.max(0, Math.min(initialSelectedIndex, items.length - 1)));
+        const refresh = () => {
+            const menuWidth = Math.max((process.stdout.columns || tui_view_1.MIN_TUI_COLUMNS) - 2, 24);
+            const menuLines = picker.render(menuWidth);
+            void render("/resume", "resume: ↑/↓ select · Enter confirm · Esc back", {
+                active: true,
+                items: menuLines,
+                selectedIndex: 0,
+                renderMode: "raw"
+            }, true, "sessions:");
+        };
+        picker.onSelectionChange = () => {
+            refresh();
+        };
+        picker.onSelect = (item) => {
+            finish({ action: "select", id: item.value });
+        };
+        picker.onCancel = () => {
+            finish({ action: "cancel" });
+        };
+        const cleanup = () => {
+            unsubscribeInput();
+        };
+        const finish = (result) => {
+            cleanup();
+            resolve(result);
+        };
+        const onInput = (event) => {
+            const { key, sequence } = event;
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("c")) || (0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("d")) || (key.ctrl && (key.name === "c" || key.name === "d"))) {
+                finish({ action: "exit" });
+                return;
+            }
+            if ((0, pi_tui_1.matchesKey)(sequence, pi_tui_1.Key.ctrl("l")) || (key.ctrl && key.name === "l")) {
+                refresh();
+                return;
+            }
+            picker.handleInput(sequence);
+        };
+        const unsubscribeInput = inputSource.subscribe(onInput);
+        refresh();
+    });
 }
 function toSessionWithDialog(session) {
     const dialog = session.dialog ?? {
@@ -38,19 +1253,24 @@ function toSessionWithDialog(session) {
         rounds: [],
         history: []
     };
+    const history = dialog.history.filter((entry) => !isExitLifecycleNoise(entry));
+    const pendingBuildChoice = dialog.pending_build_choice
+        ? { ...dialog.pending_build_choice }
+        : undefined;
     return {
         ...session,
         dialog: {
             ...dialog,
             rounds: [...dialog.rounds],
-            history: [...dialog.history]
+            history: [...history],
+            pending_build_choice: pendingBuildChoice
         }
     };
 }
 async function requireSessionWithDialog(cwd) {
     const session = await (0, intent_1.readSessionStore)(cwd);
     if (!session) {
-        throw new Error("Missing .zaker/session.json. Run `zaker init` first.");
+        throw new Error("Missing .zaker/session.json. Run `/init` first.");
     }
     const normalized = toSessionWithDialog(session);
     await (0, intent_1.writeSessionStore)(normalized, cwd);
@@ -86,24 +1306,39 @@ async function appendDialogEntry(cwd, role, kind, content) {
         return normalized;
     });
 }
+async function setPendingBuildChoice(cwd, intentId) {
+    await mutateDialogSession(cwd, (session) => {
+        const normalized = toSessionWithDialog(session);
+        const dialog = normalized.dialog ?? {
+            debug: false,
+            turn: 0,
+            rounds: [],
+            history: []
+        };
+        normalized.dialog = {
+            debug: dialog.debug,
+            turn: dialog.turn,
+            rounds: [...dialog.rounds],
+            history: [...dialog.history],
+            pending_build_choice: intentId
+                ? {
+                    intent_id: intentId,
+                    created_at: now()
+                }
+                : undefined
+        };
+        normalized.updated_at = now();
+        return normalized;
+    });
+}
 async function buildSessionStatusLines(cwd) {
     const session = await requireSessionWithDialog(cwd);
     const draft = await (0, intent_1.readIntentCard)(cwd);
-    const rounds = session.dialog?.rounds ?? [];
-    const lines = [
-        `state: ${session.state}`,
-        `current_intent_id: ${session.current_intent_id ?? "-"}`,
-        `debug: ${session.dialog?.debug ? "on" : "off"}`,
-        `history_turns: ${session.dialog?.history.length ?? 0}`,
-        `intent.card: ${draft ? `${draft.intent_id} (${draft.status})` : "-"}`
-    ];
-    if (rounds.length > 0) {
-        lines.push("recent_rounds:");
-        for (const item of rounds.slice(-5)) {
-            lines.push(`- #${item.round} verdict=${item.verdict} reason=${item.reason_code} checkpoint=${item.checkpoint_id ?? "-"}`);
-        }
-    }
-    return lines;
+    const confirmed = await (0, intent_1.readConfirmedIntent)(cwd);
+    return (0, session_status_1.formatSessionStatusLines)(session, draft, confirmed, {
+        includeDialog: true,
+        recentRoundLimit: 5
+    });
 }
 async function upsertDraftIntent(cwd, content, replace = false) {
     const text = content.trim();
@@ -118,6 +1353,97 @@ async function upsertDraftIntent(cwd, content, replace = false) {
     const intent = await (0, intent_1.alignIntent)(nextDescription, config.scope, cwd);
     return `intent.card updated: ${intent.intent_id} (state=ALIGN)`;
 }
+async function generateAssistantReply(cwd, userMessage, intentUpdate, options = {}) {
+    if (options.abort_signal?.aborted) {
+        const error = new Error("ALIGN_ABORTED");
+        error.name = "AbortError";
+        throw error;
+    }
+    const config = await (0, config_1.readConfig)(cwd);
+    if (config.model.provider === "mock") {
+        throw new Error("ALIGN_MODEL_UNAVAILABLE: provider=mock. Please login a real model provider first.");
+    }
+    const provider = (0, config_1.createLLMProvider)(config);
+    if (typeof provider.align !== "function") {
+        throw new Error(`ALIGN_MODEL_UNAVAILABLE: provider "${config.model.provider}" does not support alignment replies.`);
+    }
+    try {
+        const reply = await provider.align(userMessage, {
+            intent_update: intentUpdate,
+            abort_signal: options.abort_signal
+        });
+        const normalized = reply.trim();
+        if (!normalized) {
+            throw new Error("ALIGN_MODEL_EMPTY_REPLY: provider returned empty reply.");
+        }
+        return normalized;
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === "AbortError" || /abort|cancel/i.test(error.message))) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`ALIGN_MODEL_ERROR: ${message}`);
+    }
+}
+async function detectBuildIntent(cwd, userMessage, intentUpdate, options = {}) {
+    if (options.abort_signal?.aborted) {
+        const error = new Error("ALIGN_ABORTED");
+        error.name = "AbortError";
+        throw error;
+    }
+    const config = await (0, config_1.readConfig)(cwd);
+    if (config.model.provider === "mock") {
+        return {
+            ready: false,
+            confidence: 0,
+            signal: "mock_provider"
+        };
+    }
+    const provider = (0, config_1.createLLMProvider)(config);
+    if (typeof provider.detectBuildIntent !== "function") {
+        return {
+            ready: false,
+            confidence: 0,
+            signal: "unsupported"
+        };
+    }
+    return await provider.detectBuildIntent(userMessage, {
+        intent_update: intentUpdate,
+        abort_signal: options.abort_signal
+    });
+}
+async function readDraftIntent(cwd) {
+    return await (0, intent_1.readIntentCard)(cwd);
+}
+async function buildIntent(cwd) {
+    return await (0, intent_1.confirmIntent)(cwd);
+}
+async function setPendingBuildChoiceForIntent(cwd, intentId) {
+    await setPendingBuildChoice(cwd, intentId);
+}
+async function detectBuildIntentSignal(cwd, userMessage, intentUpdate, options = {}) {
+    try {
+        const signal = await detectBuildIntent(cwd, userMessage, intentUpdate, options);
+        if (signal.ready && signal.confidence >= 0.65) {
+            return signal;
+        }
+        return {
+            ...signal,
+            ready: false
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && (error.name === "AbortError" || /abort|cancel/i.test(error.message))) {
+            throw error;
+        }
+        return {
+            ready: false,
+            confidence: 0,
+            signal: "error"
+        };
+    }
+}
 function printVerdictLines(lines, verdict) {
     const first = lines[0] ?? verdict;
     if (verdict === "PASS") {
@@ -175,264 +1501,461 @@ function summarizeVerdict(output, debug) {
         `risk=${panel.risk_hit}`,
         `retry=${panel.retry_allowed ? "YES" : "NO"}`
     ].join(" | ");
-    return { lines, historyEntry };
+    return { lines, historyEntry, panel };
 }
-async function renderDialogueScreen(cwd, notice) {
-    const session = await requireSessionWithDialog(cwd);
-    const draft = await (0, intent_1.readIntentCard)(cwd);
+function updateBoardFromSession(board, session, lastRoundReasonCode) {
+    if (session.state === "RUNNING") {
+        board.run_status = "RUNNING";
+    }
+    if (session.state === "ALIGN" && board.run_status === "RUNNING") {
+        board.run_status = "IDLE";
+        board.run_stage = "IDLE";
+    }
+    if (session.last_run_verdict) {
+        board.audit_verdict = session.last_run_verdict;
+        board.audit_reason = lastRoundReasonCode ?? board.audit_reason;
+    }
+}
+function renderDialogueScreen(conversationId, session, _draft, board, notice, modelInfo, conversationScrollOffset, inputBuffer = "", completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex, frameRenderer = tui_view_1.renderTwoPaneFrame) {
     const history = session.dialog?.history ?? [];
     const rounds = session.dialog?.rounds ?? [];
     const lastRound = rounds.at(-1);
-    const lines = [];
-    lines.push(chalk_1.default.bold("ZAKER Agent TUI"));
-    lines.push(chalk_1.default.gray(`state=${session.state} | debug=${session.dialog?.debug ? "on" : "off"} | turns=${history.length} | rounds=${rounds.length}`));
-    lines.push(chalk_1.default.gray(helpText()));
-    lines.push(divider());
-    lines.push(chalk_1.default.bold("Conversation"));
+    const visibleHistory = Math.max(8, (process.stdout.rows || tui_view_1.MIN_TUI_ROWS) - 14);
+    const maxScrollOffset = Math.max(0, history.length - visibleHistory);
+    const normalizedScrollOffset = Math.max(0, Math.min(conversationScrollOffset, maxScrollOffset));
+    const windowEnd = Math.max(0, history.length - normalizedScrollOffset);
+    const windowStart = Math.max(0, windowEnd - visibleHistory);
+    const visibleEntries = history.slice(windowStart, windowEnd);
+    const leftTitle = normalizedScrollOffset > 0 && history.length > 0
+        ? `Conversation (${windowStart + 1}-${windowEnd}/${history.length})`
+        : "Conversation";
+    const leftContent = [];
+    const leftContentItems = [];
     if (history.length === 0) {
-        lines.push(chalk_1.default.gray("(empty) 输入需求文本以更新 intent.card，然后 /confirm -> /run"));
+        leftContent.push("(empty)");
     }
     else {
-        for (const entry of history.slice(-MAX_SCREEN_HISTORY)) {
-            const role = entry.role === "user" ? "YOU " : "ZAKER";
-            const kind = entry.kind.toUpperCase().padEnd(7, " ");
-            lines.push(`${chalk_1.default.cyan(role)} [${kind}] ${compactLine(entry.content, 180)}`);
-        }
-    }
-    lines.push(divider());
-    lines.push(chalk_1.default.bold("Intent"));
-    lines.push(`intent_id: ${draft?.intent_id ?? session.current_intent_id ?? "-"}`);
-    lines.push(`goal: ${compactLine(draft?.goal ?? "-", 180)}`);
-    if (lastRound) {
-        lines.push(`last_round: #${lastRound.round} ${lastRound.verdict} (${lastRound.reason_code}) checkpoint=${lastRound.checkpoint_id ?? "-"}`);
-    }
-    if (notice) {
-        lines.push(chalk_1.default.yellow(`notice: ${notice}`));
-    }
-    lines.push("");
-    process.stdout.write("\x1Bc");
-    process.stdout.write(`${lines.join("\n")}\n`);
-    return session;
-}
-function renderBootstrapScreen(notice) {
-    const lines = [];
-    lines.push(chalk_1.default.bold("ZAKER Agent TUI"));
-    lines.push(chalk_1.default.gray("state=UNINITIALIZED"));
-    lines.push(chalk_1.default.gray(helpText()));
-    lines.push(divider());
-    lines.push(chalk_1.default.bold("Bootstrap"));
-    lines.push("workspace is not initialized.");
-    lines.push("run /init to create .zaker/config.json, .zaker/risk_paths.yaml, .zaker/memory.json, and session files.");
-    if (notice) {
-        lines.push(chalk_1.default.yellow(`notice: ${notice}`));
-    }
-    lines.push("");
-    process.stdout.write("\x1Bc");
-    process.stdout.write(`${lines.join("\n")}\n`);
+        for (const entry of visibleEntries.slice(-Math.max(MAX_SCREEN_HISTORY, visibleHistory))) {
+            const isBuildChoiceCard = entry.role === "system" &&
+                entry.kind === "status" &&
+                entry.content.includes("intent.card ready:") &&
+                entry.content.includes("1) Build");
+            const tone = entry.role === "user"
+                ? "user"
+                : isBuildChoiceCard
+                    ? "action_card"
+                    : entry.kind === "status"
+                        ? "status"
+                        : "default";
+            leftContentItems.push({
+                text: tone === "action_card" ? entry.content : compactLine(entry.content, 300),
+                tone
+            });
+        }
+    }
+    updateBoardFromSession(board, session, lastRound?.reason_code);
+    frameRenderer({
+        conversationId,
+        stateLabel: session.state,
+        stageLabel: board.run_stage,
+        verdictLabel: board.audit_verdict,
+        debug: session.dialog?.debug ?? false,
+        turns: history.length,
+        rounds: rounds.length,
+        leftTitle,
+        leftContent,
+        leftContentItems: leftContentItems.length > 0 ? leftContentItems : undefined,
+        notice,
+        modelInfo,
+        inputBuffer,
+        inputCursorIndex,
+        completion,
+        commandMenu,
+        cursorVisible,
+        commandMenuLabel
+    });
+    return {
+        scrollOffset: normalizedScrollOffset,
+        totalHistory: history.length,
+        visibleHistory
+    };
 }
+function renderBootstrapScreen(conversationId, notice, modelInfo, inputBuffer = "", completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex, frameRenderer = tui_view_1.renderTwoPaneFrame) {
+    const leftContent = [
+        "workspace is not initialized.",
+        "",
+        "run /init to create required artifacts:",
+        "- .zaker/config.json",
+        "- .zaker/risk_paths.yaml",
+        "- .zaker/memory.json",
+        "- .zaker/intent.card.json",
+        "- .zaker/session.json",
+        "",
+        "AVAILABLE COMMANDS",
+        "/init",
+        "/help",
+        "/exit",
+        "",
+        "NEXT",
+        "1) run /init",
+        "2) write requirement text",
+        "3) 触发 build 卡片后输入 1",
+        "4) /run"
+    ];
+    frameRenderer({
+        conversationId,
+        stateLabel: "UNINITIALIZED",
+        stageLabel: "BOOTSTRAP",
+        verdictLabel: "PENDING",
+        debug: false,
+        turns: 0,
+        rounds: 0,
+        leftTitle: "Bootstrap",
+        leftContent,
+        notice,
+        modelInfo,
+        inputBuffer,
+        inputCursorIndex,
+        completion,
+        commandMenu,
+        cursorVisible,
+        commandMenuLabel
+    });
+}
+function createDialogLogger(options) {
+    const enabled = !options.interactive && !options.quiet;
+    return {
+        info(message) {
+            if (enabled) {
+                console.log(chalk_1.default.gray(message));
+            }
+        },
+        warn(message) {
+            if (enabled) {
+                console.log(chalk_1.default.yellow(message));
+            }
+        },
+        success(message) {
+            if (enabled) {
+                console.log(chalk_1.default.green(message));
+            }
+        },
+        error(message) {
+            if (enabled) {
+                console.log(chalk_1.default.red(message));
+            }
+        }
+    };
+}
+function createDialogHandlerServices() {
+    return {
+        now,
+        maxDialogRounds: MAX_DIALOG_ROUNDS,
+        defaultConversationId: dialog_session_1.DEFAULT_CONVERSATION_ID,
+        helpText,
+        createDefaultConversationIndex: dialog_session_1.createDefaultConversationIndex,
+        resetBoard,
+        readSessionStore: async (cwd) => await (0, intent_1.readSessionStore)(cwd),
+        requireSessionWithDialog,
+        mutateDialogSession,
+        appendDialogEntry,
+        readIntentCard: readDraftIntent,
+        upsertDraftIntent,
+        generateAssistantReply,
+        detectBuildIntent: detectBuildIntentSignal,
+        setPendingBuildChoice: setPendingBuildChoiceForIntent,
+        buildSessionStatusLines,
+        runInit: async (cwd) => {
+            await (0, init_1.runInit)(false, cwd, () => undefined);
+        },
+        persistActiveConversation: dialog_session_1.persistActiveConversation,
+        listConversationIds: dialog_session_1.listConversationIds,
+        switchConversation: dialog_session_1.switchConversation,
+        normalizeConversationId: dialog_session_1.normalizeConversationId,
+        buildIntent,
+        runConfirmedPipeline: async (sopOut, checkpointOut, cwd, onStage) => await (0, run_1.runConfirmedPipeline)(sopOut, checkpointOut, cwd, {
+            quiet: true,
+            hooks: { onStage }
+        }),
+        summarizeVerdict: (output, debug) => summarizeVerdict(output, debug),
+        printVerdictLines
+    };
+}
+const dialogHandlerServices = createDialogHandlerServices();
 async function handleDialogInput(line, cwd, options) {
-    const input = line.trim();
-    if (!input) {
-        return { action: "continue" };
-    }
     const initialized = (await (0, intent_1.readSessionStore)(cwd)) !== null;
-    if (!initialized) {
-        if (!input.startsWith("/")) {
-            const notice = "workspace not initialized. run /init first.";
-            if (!options.interactive && !options.quiet) {
-                console.log(chalk_1.default.yellow(notice));
-            }
-            return { action: "continue", notice };
-        }
-        const [bootstrapCommand] = input.split(" ");
-        if (bootstrapCommand === "/exit" || bootstrapCommand === "/quit") {
-            return { action: "exit", notice: "dialog ended" };
-        }
-        if (bootstrapCommand === "/help") {
-            const help = helpText();
-            if (!options.interactive && !options.quiet) {
-                console.log(chalk_1.default.gray(help));
-            }
-            return { action: "continue", notice: "help shown" };
-        }
-        if (bootstrapCommand === "/init") {
-            await (0, init_1.runInit)(false, cwd);
-            await requireSessionWithDialog(cwd);
-            const notice = "workspace initialized";
-            if (!options.interactive && !options.quiet) {
-                console.log(chalk_1.default.green(notice));
-            }
-            return { action: "continue", notice };
-        }
-        const notice = "workspace not initialized. only /init, /help, /exit are available.";
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.yellow(notice));
-        }
-        return { action: "continue", notice };
-    }
-    if (!input.startsWith("/")) {
-        await appendDialogEntry(cwd, "user", "message", input);
-        const updated = await upsertDraftIntent(cwd, input, false);
-        await appendDialogEntry(cwd, "system", "status", updated);
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.gray(updated));
-        }
-        return { action: "continue", notice: updated };
-    }
-    const [command, ...args] = input.split(" ");
-    const rest = args.join(" ").trim();
-    await appendDialogEntry(cwd, "user", "command", input);
-    if (command === "/exit" || command === "/quit") {
-        await appendDialogEntry(cwd, "system", "status", "dialog ended");
-        return { action: "exit", notice: "dialog ended" };
-    }
-    if (command === "/help") {
-        const help = helpText();
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.gray(help));
-        }
-        await appendDialogEntry(cwd, "system", "status", help);
-        return { action: "continue", notice: "help shown" };
-    }
-    if (command === "/init") {
-        await (0, init_1.runInit)(false, cwd);
-        const message = "workspace init checked";
-        await appendDialogEntry(cwd, "system", "status", message);
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.gray(message));
-        }
-        return { action: "continue", notice: message };
-    }
-    if (command === "/status") {
-        const lines = await buildSessionStatusLines(cwd);
-        if (!options.interactive && !options.quiet) {
-            for (const lineItem of lines) {
-                console.log(chalk_1.default.gray(lineItem));
-            }
-        }
-        await appendDialogEntry(cwd, "system", "status", `status snapshot: ${lines.join(" | ")}`);
-        return { action: "continue", notice: "status refreshed" };
-    }
-    if (command === "/debug") {
-        if (rest !== "on" && rest !== "off") {
-            throw new Error("Usage: /debug on|off");
-        }
-        await mutateDialogSession(cwd, (session) => {
-            const normalized = toSessionWithDialog(session);
-            normalized.dialog.debug = rest === "on";
-            normalized.updated_at = now();
-            return normalized;
-        });
-        await appendDialogEntry(cwd, "system", "status", `debug mode ${rest}`);
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.gray(`debug mode: ${rest}`));
-        }
-        return { action: "continue", notice: `debug mode ${rest}` };
-    }
-    if (command === "/edit") {
-        if (!rest) {
-            throw new Error("Usage: /edit <text>");
-        }
-        const updated = await upsertDraftIntent(cwd, rest, true);
-        await appendDialogEntry(cwd, "system", "status", "intent.card replaced");
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.gray(updated));
-        }
-        return { action: "continue", notice: "intent.card replaced" };
-    }
-    if (command === "/confirm") {
-        const confirmed = await (0, intent_1.confirmIntent)(cwd);
-        const message = `intent confirmed: ${confirmed.intent.intent_id} (state=READY, intent_sha256=${confirmed.binding.intent_sha256})`;
-        await appendDialogEntry(cwd, "system", "status", message);
-        if (!options.interactive && !options.quiet) {
-            console.log(chalk_1.default.green(message));
-        }
-        return { action: "continue", notice: `confirmed ${confirmed.intent.intent_id}` };
-    }
-    if (command === "/run") {
-        const roundStart = now();
-        const session = await requireSessionWithDialog(cwd);
-        const nextRound = (session.dialog?.rounds.at(-1)?.round ?? 0) + 1;
-        const output = await (0, run_1.runConfirmedPipeline)(options.sopOut, options.checkpointOut, cwd, {
-            quiet: true
-        });
-        const debug = (await requireSessionWithDialog(cwd)).dialog?.debug ?? false;
-        const summary = summarizeVerdict(output, debug);
-        if (!options.interactive && !options.quiet) {
-            printVerdictLines(summary.lines, output.interpretation.verdict);
-        }
-        const reasonCode = output.finalAuditResult.reason_code || "UNKNOWN";
-        await mutateDialogSession(cwd, (current) => {
-            const normalized = toSessionWithDialog(current);
-            normalized.dialog.rounds = [
-                ...normalized.dialog.rounds,
-                {
-                    round: nextRound,
-                    started_at: roundStart,
-                    completed_at: now(),
-                    verdict: output.interpretation.verdict,
-                    reason_code: reasonCode,
-                    checkpoint_id: output.checkpoint?.checkpoint_id
-                }
-            ].slice(-MAX_DIALOG_ROUNDS);
-            normalized.updated_at = now();
-            return normalized;
-        });
-        await appendDialogEntry(cwd, "system", "result", `round #${nextRound} ${summary.historyEntry}`);
-        return { action: "continue", notice: `round #${nextRound} ${summary.historyEntry}` };
-    }
-    throw new Error(`Unknown command: ${command}`);
+    return await (0, dialog_handlers_1.dispatchDialogInput)({
+        input: line,
+        initialized,
+        cwd,
+        options,
+        services: dialogHandlerServices,
+        logger: createDialogLogger(options)
+    });
 }
 async function runDialogueSession(cwd = process.cwd(), options = {}) {
     const sopOut = options.sopOut ?? "sop.json";
     const checkpointOut = options.checkpointOut ?? "checkpoint.json";
     const quiet = options.quiet ?? false;
     const scripted = options.script;
+    const launchDebugEnabled = options.debug === true;
+    let launchDebugPending = launchDebugEnabled;
+    const board = createTaskBoardState();
+    const conversations = {
+        index: await (0, dialog_session_1.readConversationIndex)(cwd)
+    };
+    const applyLaunchDebugMode = async () => {
+        if (!launchDebugPending) {
+            return;
+        }
+        const session = await (0, intent_1.readSessionStore)(cwd);
+        if (!session) {
+            return;
+        }
+        const currentDebug = session.dialog?.debug === true;
+        if (!currentDebug) {
+            await mutateDialogSession(cwd, (currentSession) => {
+                const dialog = currentSession.dialog ?? {
+                    debug: false,
+                    turn: 0,
+                    rounds: [],
+                    history: []
+                };
+                return {
+                    ...currentSession,
+                    dialog: {
+                        ...dialog,
+                        debug: true,
+                        rounds: [...dialog.rounds],
+                        history: [...dialog.history]
+                    },
+                    updated_at: now()
+                };
+            });
+        }
+        launchDebugPending = false;
+    };
     if (Array.isArray(scripted)) {
+        await applyLaunchDebugMode();
         for (const line of scripted) {
             const result = await handleDialogInput(line, cwd, {
                 sopOut,
                 checkpointOut,
                 interactive: false,
-                quiet
+                quiet,
+                board,
+                conversations
             });
             if (result.action === "exit") {
                 break;
             }
         }
+        if (await (0, intent_1.readSessionStore)(cwd)) {
+            await (0, dialog_session_1.persistActiveConversation)(conversations, cwd);
+        }
         return;
     }
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new Error("Dialogue TUI requires a TTY or scripted inputs.");
     }
-    const rl = node_readline_1.default.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    let notice = (await (0, intent_1.readSessionStore)(cwd))
-        ? "输入需求文本更新 intent.card；/confirm 冻结；/run 执行。"
+    const inputSource = new DialogInputBuffer();
+    const frameRenderer = await createPiFrameRenderer(inputSource);
+    await applyLaunchDebugMode();
+    const initialSession = await (0, intent_1.readSessionStore)(cwd);
+    let notice = initialSession
+        ? "输入需求文本更新 intent.card；当系统给出 Build 卡片时输入 1 执行，输入 2 继续调整。"
         : "workspace not initialized. run /init first.";
+    let conversationScrollOffset = 0;
+    let latestHistoryCount = 0;
+    let latestVisibleHistory = 8;
+    let activeTurnAbortController = null;
+    let lastEscapeAtMs = 0;
+    let renderFrameRef = null;
+    const applyConversationScrollDelta = (delta, granularity = "page") => {
+        if (!Number.isFinite(delta) || delta === 0) {
+            return false;
+        }
+        const maxScrollOffset = Math.max(0, latestHistoryCount - latestVisibleHistory);
+        const step = granularity === "line"
+            ? 1
+            : Math.max(3, Math.floor(latestVisibleHistory / 2));
+        const next = Math.max(0, Math.min(maxScrollOffset, conversationScrollOffset + (delta * step)));
+        if (next === conversationScrollOffset) {
+            return false;
+        }
+        conversationScrollOffset = next;
+        return true;
+    };
+    const detachGlobalInputListener = inputSource.subscribe((event) => {
+        const wheelDeltas = parseMouseWheelDeltas(event.sequence);
+        if (wheelDeltas.length > 0) {
+            let changed = false;
+            for (const delta of wheelDeltas) {
+                changed = applyConversationScrollDelta(delta) || changed;
+            }
+            if (changed && renderFrameRef) {
+                void renderFrameRef("", undefined);
+            }
+            return;
+        }
+        if (event.key.name === "escape" && activeTurnAbortController) {
+            const nowMs = Date.now();
+            if (nowMs - lastEscapeAtMs <= ESC_DOUBLE_PRESS_WINDOW_MS) {
+                lastEscapeAtMs = 0;
+                if (!activeTurnAbortController.signal.aborted) {
+                    activeTurnAbortController.abort();
+                }
+                notice = "assistant reply cancelling...";
+                if (renderFrameRef) {
+                    void renderFrameRef("", undefined);
+                }
+                return;
+            }
+            lastEscapeAtMs = nowMs;
+            notice = "press Esc again to cancel current reply";
+            if (renderFrameRef) {
+                void renderFrameRef("", undefined);
+            }
+            return;
+        }
+    });
     try {
         while (true) {
             const session = await (0, intent_1.readSessionStore)(cwd);
-            let promptState = "uninitialized";
             if (session) {
-                const rendered = await renderDialogueScreen(cwd, notice);
-                promptState = rendered.state.toLowerCase();
+                await applyLaunchDebugMode();
             }
-            else {
-                renderBootstrapScreen(notice);
+            if (session) {
+                await requireSessionWithDialog(cwd);
+            }
+            let activeModelInfo = "-";
+            let renderFrameGeneration = 0;
+            const renderFrame = async (buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex) => {
+                const generation = ++renderFrameGeneration;
+                const latestSession = await (0, intent_1.readSessionStore)(cwd);
+                if (latestSession) {
+                    const sessionWithDialog = await requireSessionWithDialog(cwd);
+                    const draftIntent = await (0, intent_1.readIntentCard)(cwd);
+                    if (generation !== renderFrameGeneration) {
+                        return;
+                    }
+                    const renderMeta = renderDialogueScreen(conversations.index.active_id || dialog_session_1.DEFAULT_CONVERSATION_ID, sessionWithDialog, draftIntent, board, notice, activeModelInfo, conversationScrollOffset, buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex, frameRenderer.render);
+                    conversationScrollOffset = renderMeta.scrollOffset;
+                    latestHistoryCount = renderMeta.totalHistory;
+                    latestVisibleHistory = renderMeta.visibleHistory;
+                    return;
+                }
+                if (generation !== renderFrameGeneration) {
+                    return;
+                }
+                latestHistoryCount = 0;
+                latestVisibleHistory = 8;
+                conversationScrollOffset = 0;
+                renderBootstrapScreen(conversations.index.active_id || dialog_session_1.DEFAULT_CONVERSATION_ID, notice, activeModelInfo, buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex, frameRenderer.render);
+            };
+            renderFrameRef = renderFrame;
+            const conversationIds = await (0, dialog_session_1.listConversationIds)(conversations.index, cwd);
+            let modelMenu = EMPTY_MODEL_MENU_SNAPSHOT;
+            try {
+                const config = await (0, config_1.readConfig)(cwd);
+                modelMenu = (0, model_accounts_1.buildModelMenuSnapshot)(config);
+                activeModelInfo = formatTuiModelInfo(config);
+            }
+            catch {
+                modelMenu = EMPTY_MODEL_MENU_SNAPSHOT;
+                activeModelInfo = "-";
             }
-            const prompt = `zaker:${promptState} > `;
-            const line = await new Promise((resolve) => {
-                rl.question(prompt, resolve);
+            let line = await readInteractiveInput(async (buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex) => {
+                await renderFrame(buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex);
+            }, (buffer) => resolveSlashMenuCandidates(buffer, conversationIds, modelMenu), inputSource, modelMenu, (key) => {
+                if (key.name === "pageup") {
+                    applyConversationScrollDelta(1);
+                    return;
+                }
+                if (key.name === "pagedown") {
+                    applyConversationScrollDelta(-1);
+                    return;
+                }
+                const maxScrollOffset = Math.max(0, latestHistoryCount - latestVisibleHistory);
+                if (key.name === "home") {
+                    conversationScrollOffset = maxScrollOffset;
+                    return;
+                }
+                if (key.name === "end") {
+                    conversationScrollOffset = 0;
+                }
             });
+            if (line.trim() === "/resume" && (await (0, intent_1.readSessionStore)(cwd))) {
+                const activeConversationId = conversations.index.active_id || dialog_session_1.DEFAULT_CONVERSATION_ID;
+                const ids = await (0, dialog_session_1.listConversationIds)(conversations.index, cwd);
+                const pickerItems = ids.map((id) => ({
+                    id,
+                    label: id === activeConversationId ? `${id} (active)` : id
+                }));
+                const initialSelectedIndex = Math.max(0, pickerItems.findIndex((item) => item.id === activeConversationId));
+                const pickerResult = await readInteractiveResumePicker(async (buffer, completion, commandMenu, cursorVisible, commandMenuLabel) => {
+                    await renderFrame(buffer, completion, commandMenu, cursorVisible, commandMenuLabel);
+                }, inputSource, pickerItems, initialSelectedIndex);
+                if (pickerResult.action === "exit") {
+                    break;
+                }
+                if (pickerResult.action === "cancel") {
+                    notice = "resume cancelled";
+                    await renderFrame("", undefined);
+                    continue;
+                }
+                line = `/resume ${pickerResult.id}`;
+            }
+            const loginResolution = await resolveInteractiveLoginCommand({
+                line,
+                cwd,
+                input_source: inputSource,
+                prompt: async (promptNotice) => {
+                    const previousNotice = notice;
+                    notice = promptNotice;
+                    const prompted = await readInteractiveInput(async (buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex) => {
+                        await renderFrame(buffer, completion, commandMenu, cursorVisible, commandMenuLabel, inputCursorIndex);
+                    }, () => [], inputSource, EMPTY_MODEL_MENU_SNAPSHOT);
+                    notice = previousNotice;
+                    await renderFrame("", undefined);
+                    return prompted;
+                },
+                oauth_browser: {
+                    enabled: true,
+                    notify: async (oauthNotice) => {
+                        notice = oauthNotice;
+                        await renderFrame("", undefined);
+                    }
+                }
+            });
+            if (loginResolution.action === "exit") {
+                break;
+            }
+            if (loginResolution.action === "cancel") {
+                notice = loginResolution.notice ?? "login cancelled";
+                await renderFrame("", undefined);
+                continue;
+            }
+            line = loginResolution.line ?? line;
+            const turnAbortController = new AbortController();
+            activeTurnAbortController = turnAbortController;
+            lastEscapeAtMs = 0;
+            conversationScrollOffset = 0;
             try {
                 const result = await handleDialogInput(line, cwd, {
                     sopOut,
                     checkpointOut,
                     interactive: true,
-                    quiet
+                    quiet,
+                    turnAbortSignal: turnAbortController.signal,
+                    board,
+                    conversations,
+                    redraw: async (nextNotice) => {
+                        if (typeof nextNotice === "string") {
+                            notice = nextNotice;
+                        }
+                        await renderFrame("", undefined);
+                    }
                 });
                 notice = result.notice ?? "";
                 if (result.action === "exit") {
@@ -446,10 +1969,33 @@ async function runDialogueSession(cwd = process.cwd(), options = {}) {
                     await appendDialogEntry(cwd, "system", "status", `error: ${message}`);
                 }
             }
+            finally {
+                activeTurnAbortController = null;
+                lastEscapeAtMs = 0;
+            }
         }
     }
     finally {
-        rl.close();
+        let persistWarning;
+        try {
+            await frameRenderer.dispose();
+        }
+        catch {
+            // ignore renderer teardown failures to prioritize terminal restore
+        }
+        try {
+            if (await (0, intent_1.readSessionStore)(cwd)) {
+                await (0, dialog_session_1.persistActiveConversation)(conversations, cwd);
+            }
+        }
+        catch (error) {
+            persistWarning = error instanceof Error ? error.message : String(error);
+        }
+        detachGlobalInputListener();
+        inputSource.clear();
+        if (persistWarning) {
+            process.stderr.write(`zaker: warning: failed to persist active conversation on exit: ${persistWarning}\n`);
+        }
     }
 }
 function registerDialogCommand(program) {
@@ -458,10 +2004,12 @@ function registerDialogCommand(program) {
         .description("interactive contract-gated dialogue TUI")
         .option("-o, --sop-out <path>", "sop output path", "sop.json")
         .option("-c, --checkpoint-out <path>", "checkpoint output path", "checkpoint.json")
+        .option("--debug", "start dialogue with debug mode on", false)
         .action(async (options) => {
         await runDialogueSession(process.cwd(), {
             sopOut: options.sopOut,
-            checkpointOut: options.checkpointOut
+            checkpointOut: options.checkpointOut,
+            debug: options.debug === true
         });
     });
 }