@autopilot-agent/cli 0.0.0-stage → 0.1.0

package/dist/tui/run.js

@@ -0,0 +1,237 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** TUI 入口编排：启动 Ink，统一处理信号、退出码和动态渲染生命周期。 */
+import { render } from "ink";
+import { createTuiInputRouter } from "../tui-input-router.js";
+import { CliTuiApp } from "./app.js";
+import { getTuiStatusLabel, isActiveTuiStatus, isTerminalStatus, readTuiTerminalSize } from "./format.js";
+import { createRoutedTuiStdin, createTuiMouseInputSink, createTuiRenderStdout, createTuiTerminalLifecycle } from "./lifecycle.js";
+import { getTuiRenderModeFallbackNotice, resolveNoColor, resolveReducedMotion, resolveScreenReader, resolveTuiRenderMode } from "./render-mode.js";
+import { createCliTuiStore } from "./store.js";
+/** 将已知的安全会话字段格式化为主屏 recap；输出保持纯文本，兼容 NO_COLOR。 */
+export function formatCliTuiRecap(recap) {
+    const canResume = recap.recoverable
+        && (recap.finalStatus === "waiting_approval" || recap.finalStatus === "interrupted_recoverable" || recap.finalStatus === "limit_reached");
+    const resumeHint = canResume ? ` · Resume: ap resume --session ${recap.sessionId}` : "";
+    return `Autopilot recap · Session: ${recap.sessionId} · Completed turns: ${recap.completedTurnCount} · Final status: ${getTuiStatusLabel(recap.finalStatus)}${resumeHint}\n`;
+}
+/** 启动 Ink，统一处理信号、退出码和动态渲染生命周期。 */
+export async function runCliTui(options) {
+    const env = options.env ?? process.env;
+    const store = createCliTuiStore();
+    const noColor = resolveNoColor(env);
+    const screenReader = resolveScreenReader(env);
+    const renderMode = resolveTuiRenderMode(env);
+    const terminalSizeSource = options.streams.stdout;
+    const renderStdout = createTuiRenderStdout(terminalSizeSource, readTuiTerminalSize(terminalSizeSource));
+    const fallbackNotice = getTuiRenderModeFallbackNotice({ env, platform: process.platform });
+    if (fallbackNotice)
+        options.streams.stderr.write(fallbackNotice);
+    const terminalLifecycle = createTuiTerminalLifecycle(options.streams.stdout, renderMode);
+    const mouseInput = createTuiMouseInputSink();
+    const routedStdin = createRoutedTuiStdin(options.streams.stdin);
+    const inputRouter = createTuiInputRouter();
+    const reducedMotion = resolveReducedMotion(env);
+    // Ink 的 auto 预检没有覆盖 Windows Terminal；WT 1.24 支持 Kitty keyboard protocol，必须主动启用才能区分 Shift+Enter。
+    const kittyKeyboardMode = env.WT_SESSION ? "enabled" : "auto";
+    let requestedExitCode;
+    let lastResult;
+    let instance;
+    let lastInterruptAt = 0;
+    let pendingWheelNotches = 0;
+    let pendingWheelEvent;
+    let mouseFlushTimer;
+    /** 把同一 16ms 窗口内的滚轮 notch 合并为一次视口状态更新。 */
+    function flushMouseWheel() {
+        mouseFlushTimer = undefined;
+        const event = pendingWheelEvent;
+        const wheelNotches = Math.abs(pendingWheelNotches);
+        pendingWheelEvent = undefined;
+        pendingWheelNotches = 0;
+        if (event && wheelNotches > 0)
+            mouseInput.dispatch(event, wheelNotches);
+    }
+    /** 记录无法解析的 SGR 鼠标输入，而不把控制字节泄漏给 Ink prompt。 */
+    function recordMouseDiagnostics(diagnostics) {
+        for (const diagnostic of diagnostics)
+            store.addNotice(`terminal mouse input ignored (${diagnostic})`);
+    }
+    /** 单点消费真实 stdin：鼠标交给视口，其余字节按原顺序交给 Ink。 */
+    function routeRawTuiInput(chunk) {
+        const routed = inputRouter.push(String(chunk));
+        recordMouseDiagnostics(routed.diagnostics);
+        if (routed.passthrough.includes("\u001b[I"))
+            terminalLifecycle.reassert();
+        if (routed.passthrough)
+            routedStdin.write(routed.passthrough);
+        for (const event of routed.mouseEvents) {
+            if (event.kind !== "wheel_up" && event.kind !== "wheel_down") {
+                mouseInput.dispatch(event);
+                continue;
+            }
+            const delta = event.kind === "wheel_up" ? 1 : -1;
+            if (pendingWheelNotches !== 0 && Math.sign(pendingWheelNotches) !== delta)
+                flushMouseWheel();
+            pendingWheelNotches += delta;
+            pendingWheelEvent = event;
+            if (!mouseFlushTimer)
+                mouseFlushTimer = setTimeout(flushMouseWheel, 16);
+        }
+    }
+    /** 输入结束时丢弃残缺 SGR 前缀并关闭 Ink 专用输入流。 */
+    function finishRawTuiInput() {
+        recordMouseDiagnostics(inputRouter.finish().diagnostics);
+        flushMouseWheel();
+        routedStdin.end();
+    }
+    options.streams.stdin.on("data", routeRawTuiInput);
+    options.streams.stdin.once("end", finishRawTuiInput);
+    function finish(code) {
+        requestedExitCode = requestedExitCode ?? code;
+        instance?.unmount();
+    }
+    /** 在 TUI 终端恢复后尽力输出统一安全摘要；输出失败不能掩盖原本的退出或异常。 */
+    function writeTuiRecap() {
+        if (!options.sessionId)
+            return;
+        const snapshot = store.getSnapshot();
+        const completedTurnCount = snapshot.transcript.filter(function countCompletedTurn(item) {
+            return item.kind === "turn" && item.status === "completed";
+        }).length;
+        try {
+            options.streams.stdout.write(`\n${formatCliTuiRecap({
+                sessionId: options.sessionId,
+                completedTurnCount,
+                finalStatus: snapshot.status,
+                recoverable: snapshot.recoverable,
+            })}`);
+        }
+        catch {
+            // 终端已断开时只保证先完成 restore，recap 为尽力输出。
+        }
+    }
+    function handleResult(result) {
+        lastResult = result;
+        store.syncProjection(result.projection);
+        // 专用视图结果由 app 层打开覆盖视图；禁止复用 notice 路径把报告行截成零散 info。
+        if (result.skillOptions || result.permissionOptions || result.modelOptions || result.effortOptions || result.jobView || result.contextView)
+            return;
+        const lines = result.lines.filter(function keepNotice(line) {
+            const trimmed = line.trim();
+            // queue 的投递/启动由 pending prompt 和新 Turn 时间线表达，不再重复显示为两行 info。
+            return trimmed.length > 0 && !trimmed.startsWith("input queued:") && !trimmed.startsWith("queued input started:");
+        });
+        for (const line of lines)
+            store.addNotice(line);
+        if (lines.length === 0 && result.message)
+            store.addNotice(result.message);
+    }
+    /** 向 Runtime 请求当前活动 Turn 取消，但保留 Ink TUI 等待终态并回到 prompt。 */
+    function requestCancellation() {
+        const current = store.getSnapshot();
+        if (!isActiveTuiStatus(current.status) || current.cancellationRequested)
+            return;
+        store.setCancellationRequested(true);
+        void options.controller.dispatch({ type: "cancel_turn" }).then(handleResult).catch(function handleCancelFailure() {
+            store.setCancellationRequested(false);
+            store.addNotice("turn cancellation failed");
+        });
+    }
+    /** 处理 TUI 内 Ctrl+C：首次取消当前 Turn，取消收口前第二次强制退出。 */
+    function requestInterrupt() {
+        const now = Date.now();
+        const current = store.getSnapshot();
+        if (isActiveTuiStatus(current.status)) {
+            if (current.cancellationRequested) {
+                if (now - lastInterruptAt < 100)
+                    return;
+                options.streams.stderr.write("forced exit before cancellation completed; recovery status unknown\n");
+                finish(130);
+                terminalLifecycle.restore();
+                options.forceExit?.(130);
+                return;
+            }
+            lastInterruptAt = now;
+            requestCancellation();
+            return;
+        }
+        finish(130);
+    }
+    /** 处理 Esc：只取消活动 Turn，不把 Esc 解释为退出进程。 */
+    function requestCancel() {
+        requestCancellation();
+    }
+    /** 处理宿主 SIGINT/SIGTERM：取消后以相应进程退出码收口。 */
+    function requestSignalStop(code) {
+        requestedExitCode = requestedExitCode ?? code;
+        store.requestExit(code);
+        if (isActiveTuiStatus(store.getSnapshot().status)) {
+            requestCancellation();
+            return;
+        }
+        finish(code);
+    }
+    function handleEof() {
+        requestedExitCode = requestedExitCode ?? 0;
+        store.requestExit(0);
+        const current = store.getSnapshot();
+        if (current.status === "running" || current.status === "waiting_approval") {
+            void options.controller.dispatch({ type: "cancel_turn" }).then(handleResult).catch(function ignoreEofCancelFailure() {
+                finish(0);
+            });
+            return;
+        }
+        finish(0);
+    }
+    function handleSigint() { requestInterrupt(); }
+    function handleSigterm() { requestSignalStop(143); }
+    options.signalSource.on("SIGINT", handleSigint);
+    options.signalSource.on("SIGTERM", handleSigterm);
+    const listener = function receiveEvent(event, projection) {
+        store.acceptEvent(event, projection);
+        if (event.type === "status" && isTerminalStatus(event.status) && requestedExitCode !== undefined)
+            finish(requestedExitCode);
+    };
+    options.controller.setEventListener?.(listener);
+    options.controller.setQueuedInputListener?.(function receiveQueuedInputStarted(input) {
+        store.markQueuedInputStarted(input);
+    });
+    const node = (_jsx(CliTuiApp, { store: store, controller: options.controller, initial: options.initial, closeWhenIdle: options.closeWhenIdle, workspaceRoot: options.workspaceRoot, useColor: !noColor && !screenReader, screenReader: screenReader, renderMode: renderMode, reducedMotion: reducedMotion, mouseInput: mouseInput, onResult: handleResult, onRequestInterrupt: requestInterrupt, onRequestCancel: requestCancel, onEof: handleEof, onAppExit: finish, terminalSizeSource: terminalSizeSource, onTerminalSizeChange: renderStdout.setSize }));
+    try {
+        terminalLifecycle.enter();
+        instance = render(node, {
+            stdout: renderStdout.stdout,
+            stderr: options.streams.stderr,
+            stdin: routedStdin,
+            exitOnCtrlC: false,
+            patchConsole: true,
+            // 输入框和动态时间线会改变行高；Windows Terminal 下增量渲染会残留旧帧，
+            // 表现为逐字符重复或内容重叠。使用完整帧保证当前交互区域正确。
+            incrementalRendering: false,
+            isScreenReaderEnabled: screenReader,
+            kittyKeyboard: { mode: kittyKeyboardMode },
+        });
+        // CC 在 AlternateScreen 挂载后再次声明鼠标模式；Ink 初始化完成后重申一次，避免真实终端只保留键盘模式。
+        terminalLifecycle.reassert();
+        await instance.waitUntilExit();
+    }
+    finally {
+        if (mouseFlushTimer)
+            clearTimeout(mouseFlushTimer);
+        options.streams.stdin.removeListener("data", routeRawTuiInput);
+        options.streams.stdin.removeListener("end", finishRawTuiInput);
+        mouseInput.setHandler(undefined);
+        routedStdin.end();
+        terminalLifecycle.restore();
+        writeTuiRecap();
+        options.signalSource.removeListener("SIGINT", handleSigint);
+        options.signalSource.removeListener("SIGTERM", handleSigterm);
+    }
+    const projection = options.controller.getProjection();
+    const result = lastResult ?? {
+        kind: "exit",
+        exitCode: requestedExitCode ?? 0,
+        lines: [],
+        projection,
+    };
+    return { result, exitCode: requestedExitCode ?? result.exitCode };
+}

package/dist/tui/status-line.d.ts

@@ -0,0 +1,16 @@
+/** 状态栏与信息行：消费安全状态视图，渲染状态、模型、权限、context 与 workspace。 */
+import type { CliStatusView } from "../types.js";
+import type { CliTuiSnapshot } from "./types.js";
+/** 渲染当前状态栏；配置行只消费安全状态视图，不读取 Runtime 或 checkpoint。 */
+export declare const TuiStatusLine: import("react").NamedExoticComponent<{
+    snapshot: CliTuiSnapshot;
+    statusView?: CliStatusView;
+    useColor: boolean;
+    screenReader: boolean;
+    selectionCharacters?: number;
+}>;
+/** 将最近的控制台信息固定在输入框上方，避免混入会话时间线或占用回答区域。 */
+export declare const TuiInfoLines: import("react").NamedExoticComponent<{
+    messages: string[];
+    useColor: boolean;
+}>;

package/dist/tui/status-line.js

@@ -0,0 +1,37 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/** 状态栏与信息行：消费安全状态视图，渲染状态、模型、权限、context 与 workspace。 */
+import { memo } from "react";
+import { Box, Text } from "ink";
+import { formatTuiContextStatus } from "../context-report.js";
+import { CLI_TUI_COLORS, TUI_ACCENT_COLOR } from "../design-tokens.js";
+import { getTuiPermissionModeLabel, getTuiStatusLabel } from "./format.js";
+/** 渲染当前状态栏；配置行只消费安全状态视图，不读取 Runtime 或 checkpoint。 */
+export const TuiStatusLine = memo(function TuiStatusLine(props) {
+    const suffix = `${props.screenReader ? " · screen reader" : ""}${props.selectionCharacters ? ` · ${props.selectionCharacters} chars selected` : ""}`;
+    const runningHint = props.snapshot.status === "running" ? " · Esc interrupt · Enter 引导 · /queue <prompt> 排队" : "";
+    let statusLabel = getTuiStatusLabel(props.snapshot.status);
+    if (props.snapshot.cancellationRequested)
+        statusLabel = "Stopping · press Ctrl+C again to exit";
+    const statusColor = props.snapshot.status === "idle" ? undefined : props.useColor ? TUI_ACCENT_COLOR : undefined;
+    const view = props.statusView;
+    const nextPermissionLabel = view?.nextPermissionMode;
+    const permissionLabel = view ? getTuiPermissionModeLabel(view.permissionMode) : undefined;
+    const nextPermissionModeLabel = nextPermissionLabel ? getTuiPermissionModeLabel(nextPermissionLabel) : undefined;
+    if (!view) {
+        const hint = props.snapshot.status === "idle" ? " · /exit to quit" : runningHint;
+        return _jsxs(Text, { bold: props.snapshot.status === "waiting_approval", color: statusColor, children: [statusLabel, suffix, hint] });
+    }
+    const permissionColor = props.useColor && view.permissionMode === "full_access" ? CLI_TUI_COLORS.permissionFullAccess : undefined;
+    const nextPermissionColor = props.useColor && nextPermissionLabel === "full_access" ? CLI_TUI_COLORS.permissionFullAccess : undefined;
+    // 无数据/无 Session 统一显示 unknown，不猜测窗口或输出伪 0%。
+    const contextLabel = formatTuiContextStatus(view.contextUsage ?? null);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: props.snapshot.status === "waiting_approval", color: statusColor, children: [statusLabel, suffix, runningHint] }), _jsxs(Text, { dimColor: props.useColor, children: ["model: ", view.model, " \u00B7 effort: ", view.effort, " \u00B7 ", _jsxs(Text, { color: permissionColor, bold: true, dimColor: false, children: ["permission: ", permissionLabel, " (", view.permissionMode, ")"] }), view.nextModel ? _jsxs(_Fragment, { children: [" \u00B7 next model: ", view.nextModel] }) : null, view.nextEffort ? _jsxs(_Fragment, { children: [" \u00B7 next effort: ", view.nextEffort] }) : null, nextPermissionLabel ? _jsxs(_Fragment, { children: [" \u00B7 next permission: ", _jsxs(Text, { color: nextPermissionColor, bold: true, dimColor: false, children: [nextPermissionModeLabel, " (", nextPermissionLabel, ")"] })] }) : null] }), _jsxs(Text, { dimColor: props.useColor, children: ["context: ", contextLabel] }), _jsxs(Text, { dimColor: props.useColor, children: ["workspace: ", view.workspaceRoot ?? "unavailable"] })] }));
+});
+/** 将最近的控制台信息固定在输入框上方，避免混入会话时间线或占用回答区域。 */
+export const TuiInfoLines = memo(function TuiInfoLines(props) {
+    if (props.messages.length === 0)
+        return null;
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: props.messages.map(function renderInfo(message, index) {
+            return _jsxs(Text, { color: props.useColor ? CLI_TUI_COLORS.copilotMuted : undefined, children: ["info: ", message] }, `${index}:${message}`);
+        }) }));
+});

package/dist/tui/store.d.ts

@@ -0,0 +1,4 @@
+/** TUI 外部 Store：把安全事件归约为 React 可订阅快照，不读取 Core Store 或 checkpoint。 */
+import type { CliTuiStore } from "./types.js";
+/** 创建 Ink TUI 的外部 Store。 */
+export declare function createCliTuiStore(): CliTuiStore;

package/dist/tui/store.js

@@ -0,0 +1,344 @@
+/** TUI 外部 Store：把安全事件归约为 React 可订阅快照，不读取 Core Store 或 checkpoint。 */
+import { createInitialCliActivityState, reduceCliActivityState, settleCliActivityState, } from "../activity-animation.js";
+import { TUI_EVENT_PUBLISH_INTERVAL_MS } from "./constants.js";
+import { isTerminalStatus } from "./format.js";
+import { recordTuiPerformanceDiagnostic } from "./performance-diagnostics.js";
+/** 创建 TUI 初始快照。 */
+function createInitialTuiSnapshot(now = Date.now()) {
+    return {
+        transcript: [],
+        pendingInputs: [],
+        liveEvents: [],
+        hasLiveApprovalEvent: false,
+        activity: createInitialCliActivityState(now),
+        status: "idle",
+        recoverable: false,
+        activeSkills: [],
+        contextUsage: undefined,
+        cancellationRequested: false,
+    };
+}
+/** 创建 Ink TUI 的外部 Store。 */
+export function createCliTuiStore() {
+    let snapshot = createInitialTuiSnapshot();
+    let noticeIndex = 0;
+    let promptIndex = 0;
+    let scheduledNotify;
+    const settledInputIds = new Set();
+    const submittedApprovalIds = new Set();
+    const listeners = new Set();
+    const eventsByTurn = new Map();
+    const presentationByTurn = new Map();
+    const metricsByTurn = new Map();
+    const finalizedTurns = new Set();
+    function publish(nextSnapshot) {
+        flushScheduledNotify();
+        snapshot = nextSnapshot;
+        notifyListeners();
+    }
+    function flushScheduledNotify() {
+        if (scheduledNotify === undefined)
+            return;
+        clearTimeout(scheduledNotify);
+        scheduledNotify = undefined;
+    }
+    function scheduleNotify() {
+        if (scheduledNotify !== undefined)
+            return;
+        scheduledNotify = setTimeout(function publishAnswerBatch() {
+            scheduledNotify = undefined;
+            notifyListeners();
+        }, TUI_EVENT_PUBLISH_INTERVAL_MS);
+    }
+    function notifyListeners() {
+        const startedAt = performance.now();
+        for (const listener of listeners)
+            listener();
+        recordTuiPerformanceDiagnostic("tui_store_published", "snapshot", performance.now() - startedAt);
+    }
+    /** 追加一条不会再被等待态原地修改的普通 prompt 历史。 */
+    function appendPrompt(content) {
+        const trimmed = content.trim();
+        if (!trimmed)
+            return;
+        publish({
+            ...snapshot,
+            transcript: [
+                ...snapshot.transcript,
+                { kind: "prompt", key: "prompt:" + String(promptIndex++), content: trimmed },
+            ],
+        });
+    }
+    function finalizeTurn(turnId, status) {
+        if (finalizedTurns.has(turnId))
+            return;
+        const events = eventsByTurn.get(turnId) ?? [];
+        if (events.length === 0)
+            return;
+        finalizedTurns.add(turnId);
+        const metrics = metricsByTurn.get(turnId);
+        const thoughtDurationMs = metrics?.firstAnswerAt === undefined
+            ? undefined
+            : Math.max(0, metrics.firstAnswerAt - metrics.startedAt);
+        const totalDurationMs = metrics?.completedAt === undefined
+            ? undefined
+            : Math.max(0, metrics.completedAt - metrics.startedAt);
+        // 终态先保留当前 live Turn，让这一帧同时接住最后的 answer/status block；
+        // 立即清空会让外层历史区过滤掉同一 Turn，导致最后一段回答不可见。
+        snapshot = {
+            ...snapshot,
+            transcript: [
+                ...snapshot.transcript,
+                {
+                    kind: "turn",
+                    key: "turn:" + turnId + ":" + String(events[events.length - 1]?.seq ?? 0),
+                    turnId,
+                    events: [...events],
+                    presentation: presentationByTurn.get(turnId),
+                    status,
+                    thoughtDurationMs,
+                    totalDurationMs,
+                },
+            ],
+        };
+    }
+    return {
+        getSnapshot() {
+            return snapshot;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return function unsubscribe() {
+                listeners.delete(listener);
+            };
+        },
+        recordPrompt(content, displayAsActive = true) {
+            const trimmed = content.trim();
+            if (!trimmed)
+                return undefined;
+            // 运行中的 steer/queue 先进入 pendingInputs；真正消费时由时间线事件放回新位置。
+            if (!displayAsActive)
+                return undefined;
+            const key = "prompt:" + String(promptIndex++);
+            publish({
+                ...snapshot,
+                // info 是下一次 Turn 之前的临时反馈；新 prompt 被接收后必须立即消费，不能留在新 Turn 的输入区上方。
+                transcript: [
+                    ...snapshot.transcript.filter(function omitConsumedNotice(item) { return item.kind !== "notice"; }),
+                    { kind: "prompt", key, content: trimmed },
+                ],
+                activePrompt: displayAsActive ? { key, content: trimmed } : snapshot.activePrompt,
+            });
+            return key;
+        },
+        /** 将已由 Controller 成功投递的输入放入动态等待区；若已消费则直接固化为普通历史。 */
+        addPendingPrompt(content, input) {
+            const trimmed = content.trim();
+            if (!trimmed)
+                return;
+            if (settledInputIds.has(input.inputId)) {
+                return;
+            }
+            publish({
+                ...snapshot,
+                pendingInputs: [
+                    ...snapshot.pendingInputs,
+                    {
+                        key: "pending:" + String(promptIndex++),
+                        content: trimmed,
+                        inputId: input.inputId,
+                        delivery: input.delivery,
+                    },
+                ],
+            });
+        },
+        /** 在自动 queue Turn 开始前，将 prompt 放进目标 Turn 的事件序列并清除等待态。 */
+        markQueuedInputStarted(input) {
+            if (settledInputIds.has(input.inputId))
+                return;
+            settledInputIds.add(input.inputId);
+            const currentEvents = eventsByTurn.get(input.turnId) ?? [];
+            if (currentEvents.some(function hasConsumedPrompt(event) {
+                return event.type === "tui_input_consumed" && event.inputId === input.inputId;
+            }))
+                return;
+            const nextEvents = [
+                ...currentEvents,
+                {
+                    type: "tui_input_consumed",
+                    seq: 0,
+                    turnId: input.turnId,
+                    inputId: input.inputId,
+                    content: input.content,
+                    delivery: input.delivery,
+                },
+            ];
+            eventsByTurn.set(input.turnId, nextEvents);
+            publish({
+                ...snapshot,
+                pendingInputs: snapshot.pendingInputs.filter(function keepUnstartedInput(item) { return item.inputId !== input.inputId; }),
+                liveTurnId: snapshot.liveTurnId === input.turnId ? input.turnId : snapshot.liveTurnId,
+                liveEvents: snapshot.liveTurnId === input.turnId ? nextEvents : snapshot.liveEvents,
+            });
+        },
+        /** 用户选择审批范围后立即将等待卡收束为已提交结果；Runtime 后续事件仍是最终执行依据。 */
+        recordApprovalSubmission(decision) {
+            const approval = snapshot.pendingApproval;
+            const turnId = snapshot.liveTurnId;
+            if (!approval || !turnId)
+                return;
+            submittedApprovalIds.add(approval.approvalId);
+            const currentEvents = eventsByTurn.get(turnId) ?? [];
+            if (currentEvents.some(function hasSubmission(event) {
+                return event.type === "tui_approval_submitted" && event.approvalId === approval.approvalId;
+            }))
+                return;
+            const nextEvents = [
+                ...currentEvents,
+                { type: "tui_approval_submitted", seq: Number.MAX_SAFE_INTEGER, turnId, approvalId: approval.approvalId, decision },
+            ];
+            eventsByTurn.set(turnId, nextEvents);
+            publish({ ...snapshot, liveEvents: snapshot.liveTurnId === turnId ? nextEvents : snapshot.liveEvents, pendingApproval: undefined });
+        },
+        addNotice(message) {
+            const trimmed = message.trim();
+            if (!trimmed)
+                return;
+            publish({
+                ...snapshot,
+                transcript: [
+                    ...snapshot.transcript,
+                    { kind: "notice", key: "notice:" + String(noticeIndex++), message: trimmed },
+                ],
+            });
+        },
+        acceptEvent(event, projection) {
+            // 用量变化只刷新动态状态栏事实，不进入 transcript 时间线或 scrollback。
+            if (event.type === "context_usage") {
+                if (snapshot.contextUsage === event.usage)
+                    return;
+                publish({ ...snapshot, contextUsage: event.usage });
+                return;
+            }
+            // Esc 后只等待 Runtime 的终态；取消请求之后已经在途的回答/工具尾部事件不再进入可见时间线。
+            if (snapshot.cancellationRequested && !(event.type === "status" && isTerminalStatus(event.status)))
+                return;
+            const currentEvents = eventsByTurn.get(event.turnId) ?? [];
+            if (currentEvents.some(function hasSequence(item) { return item.type === event.type && item.seq === event.seq; }))
+                return;
+            const nextEvents = [...currentEvents, event];
+            eventsByTurn.set(event.turnId, nextEvents);
+            presentationByTurn.set(event.turnId, projection.presentation);
+            const isNewTurn = snapshot.liveTurnId !== event.turnId;
+            const activePrompt = snapshot.activePrompt && snapshot.activePrompt.turnId === undefined
+                ? { ...snapshot.activePrompt, turnId: event.turnId }
+                : snapshot.activePrompt;
+            const eventTime = Date.now();
+            const previousMetrics = metricsByTurn.get(event.turnId);
+            const nextMetrics = {
+                startedAt: event.type === "turn_started" ? eventTime : previousMetrics?.startedAt ?? eventTime,
+                firstAnswerAt: previousMetrics?.firstAnswerAt,
+                completedAt: previousMetrics?.completedAt,
+            };
+            if (event.type === "answer_delta" && nextMetrics.firstAnswerAt === undefined)
+                nextMetrics.firstAnswerAt = eventTime;
+            // Core 的 reset/discard 表示当前采样的暂定文字不能展示；下一次真正回答重新计时。
+            if (event.type === "answer_reset")
+                nextMetrics.firstAnswerAt = undefined;
+            if (event.type === "status" && isTerminalStatus(event.status))
+                nextMetrics.completedAt = eventTime;
+            metricsByTurn.set(event.turnId, nextMetrics);
+            const nextActivity = settleCliActivityState(reduceCliActivityState(snapshot.activity, event, eventTime), projection.status, eventTime);
+            const nextSnapshot = {
+                ...snapshot,
+                activePrompt,
+                liveTurnId: event.turnId,
+                liveEvents: nextEvents,
+                livePresentation: projection.presentation,
+                liveMetrics: { ...nextMetrics },
+                hasLiveApprovalEvent: isNewTurn ? event.type === "approval_required" : snapshot.hasLiveApprovalEvent || event.type === "approval_required",
+                activity: nextActivity,
+                status: projection.status,
+                recoverable: projection.recoverable,
+                pendingApproval: projection.pendingApproval && !submittedApprovalIds.has(projection.pendingApproval.approvalId)
+                    ? { ...projection.pendingApproval }
+                    : undefined,
+                activeSkills: projection.activeSkills.map(function copySkill(skill) { return { ...skill }; }),
+                cancellationRequested: event.type === "status" && isTerminalStatus(event.status) ? false : snapshot.cancellationRequested,
+            };
+            if (event.type === "input_consumed") {
+                settledInputIds.add(event.inputId);
+                const pendingInput = nextSnapshot.pendingInputs.find(function findPendingInput(item) { return item.inputId === event.inputId; });
+                if (pendingInput) {
+                    nextSnapshot.pendingInputs = nextSnapshot.pendingInputs.filter(function keepPendingInput(item) { return item.inputId !== event.inputId; });
+                    nextEvents.push({
+                        type: "tui_input_consumed",
+                        seq: event.seq,
+                        turnId: event.turnId,
+                        inputId: pendingInput.inputId,
+                        content: pendingInput.content,
+                        delivery: pendingInput.delivery,
+                    });
+                    nextSnapshot.liveEvents = nextEvents;
+                }
+            }
+            snapshot = nextSnapshot;
+            if (event.type === "status" && isTerminalStatus(event.status)) {
+                finalizeTurn(event.turnId, event.status);
+            }
+            if (event.type === "answer_delta") {
+                scheduleNotify();
+            }
+            else {
+                flushScheduledNotify();
+                notifyListeners();
+            }
+        },
+        syncProjection(projection) {
+            const turnIsFinalized = projection.turnId ? finalizedTurns.has(projection.turnId) : false;
+            const isNewTurn = projection.turnId !== undefined && projection.turnId !== snapshot.liveTurnId;
+            const activePrompt = snapshot.activePrompt && snapshot.activePrompt.turnId === undefined && projection.turnId
+                ? { ...snapshot.activePrompt, turnId: projection.turnId }
+                : snapshot.activePrompt;
+            const keepFinalizedLiveTurn = Boolean(projection.turnId && turnIsFinalized && projection.turnId === snapshot.liveTurnId);
+            const keepLiveTurn = Boolean(projection.turnId && (!turnIsFinalized || keepFinalizedLiveTurn));
+            if (projection.turnId)
+                presentationByTurn.set(projection.turnId, projection.presentation);
+            let activity = isNewTurn ? createInitialCliActivityState(Date.now()) : snapshot.activity;
+            if (projection.pendingApproval || projection.status === "waiting_approval") {
+                activity = reduceCliActivityState(activity, { type: "approval_required" }, Date.now());
+            }
+            else {
+                activity = settleCliActivityState(activity, projection.status, Date.now());
+            }
+            snapshot = {
+                ...snapshot,
+                activePrompt,
+                liveTurnId: keepLiveTurn ? projection.turnId : undefined,
+                liveEvents: keepLiveTurn ? [...(eventsByTurn.get(projection.turnId) ?? [])] : [],
+                livePresentation: keepLiveTurn ? projection.presentation : undefined,
+                hasLiveApprovalEvent: Boolean(keepLiveTurn && !isNewTurn && snapshot.hasLiveApprovalEvent),
+                activity,
+                status: projection.status,
+                recoverable: projection.recoverable,
+                pendingApproval: projection.pendingApproval && !submittedApprovalIds.has(projection.pendingApproval.approvalId)
+                    ? { ...projection.pendingApproval }
+                    : undefined,
+                activeSkills: projection.activeSkills.map(function copySkill(skill) { return { ...skill }; }),
+                cancellationRequested: isTerminalStatus(projection.status) ? false : snapshot.cancellationRequested,
+            };
+            if (projection.turnId && isTerminalStatus(projection.status)) {
+                finalizeTurn(projection.turnId, projection.status);
+            }
+            notifyListeners();
+        },
+        setCancellationRequested(requested) {
+            if (snapshot.cancellationRequested === requested)
+                return;
+            publish({ ...snapshot, cancellationRequested: requested });
+        },
+        requestExit(code) {
+            publish({ ...snapshot, requestedExitCode: code });
+        },
+    };
+}

package/dist/tui/timeline/live.d.ts

@@ -0,0 +1,16 @@
+/** 动态时间线的增量缓存与渲染：只更新尾部事件或当前回答块，避免重扫全部事件。 */
+import type { CliTurnStatus } from "../../types.js";
+import type { CliTuiTimelineEvent, CliTuiTurnMetrics } from "../types.js";
+/**
+ * Ink 在动态区超过一屏后会清空终端并从顶部重绘；把已经确定的块交给
+ * 历史树后，动态区最多只保留当前回答或未决审批，避免活动期间
+ * 的每个事件都把 Windows Terminal 的原生滚动视口拉回顶部。
+ */
+export declare const TuiLiveTimeline: import("react").NamedExoticComponent<{
+    turnId: string;
+    events: CliTuiTimelineEvent[];
+    status: CliTurnStatus;
+    useColor: boolean;
+    maximumWidth: number;
+    metrics?: CliTuiTurnMetrics;
+}>;