@autopilot-agent/cli 0.0.0-stage → 0.2.0

package/dist/tui/store.js

@@ -0,0 +1,380 @@
+/** 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";
+import { captureTuiInputPosition } from "./timeline/turn-items.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 consumedPositions = new Map();
+    const cancelledTurns = new Set();
+    let submissionOrder = 0;
+    const submittedInputIds = 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);
+    }
+    /** 更新所属轮的宿主输入事实；晚到回调同时刷新历史快照，不挪到当前另一轮。 */
+    function putInput(content, input, position, consumed) {
+        const turnId = position.turnId;
+        if (!turnId)
+            return;
+        const events = [...(eventsByTurn.get(turnId) ?? [])];
+        const priorIndex = events.findIndex(function same(event) { return event.type === "tui_input_consumed" && event.inputId === input.inputId; });
+        const prior = priorIndex >= 0 ? events[priorIndex] : undefined;
+        const event = { type: "tui_input_consumed", seq: 0, turnId, ...input, content, consumed, cancelled: !consumed && cancelledTurns.has(turnId), position: prior?.type === "tui_input_consumed" ? prior.position : position };
+        if (priorIndex >= 0)
+            events[priorIndex] = event;
+        else {
+            let publicCount = 0;
+            let insertAt = events.length;
+            for (let index = 0; index < events.length; index += 1) {
+                const current = events[index];
+                if (current.type === "tui_input_consumed") {
+                    if (publicCount >= position.eventCount && (current.position?.order ?? 0) > (position.order ?? 0)) {
+                        insertAt = index;
+                        break;
+                    }
+                }
+                else {
+                    if (publicCount >= position.eventCount) {
+                        insertAt = index;
+                        break;
+                    }
+                    publicCount += 1;
+                }
+            }
+            events.splice(insertAt, 0, event);
+        }
+        eventsByTurn.set(turnId, events);
+        snapshot = { ...snapshot, liveEvents: snapshot.liveTurnId === turnId ? events : snapshot.liveEvents, transcript: snapshot.transcript.map(function update(item) { return item.kind === "turn" && item.turnId === turnId ? { ...item, events } : item; }) };
+    }
+    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 由已确认的 inputId 单独记录，避免发送前伪造成功展示。
+            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;
+        },
+        /** 在异步投递之前捕获真实提交位置。 */
+        captureInputPosition() { return { ...captureTuiInputPosition(snapshot.liveTurnId, snapshot.liveEvents, snapshot.livePresentation), order: submissionOrder++ }; },
+        /** 成功投递后才外显原文，消费与回调的先后次序不改变所属轮。 */
+        addPendingPrompt(content, input, position = captureTuiInputPosition(snapshot.liveTurnId, snapshot.liveEvents, snapshot.livePresentation)) {
+            if (!content.trim() || submittedInputIds.has(input.inputId))
+                return;
+            submittedInputIds.add(input.inputId);
+            const consumed = settledInputIds.has(input.inputId);
+            const settledPosition = consumedPositions.get(input.inputId);
+            const target = input.delivery === "steer" && position.turnId && (!settledPosition || settledPosition.turnId === position.turnId) ? position : settledPosition;
+            if (target)
+                putInput(content, input, target, consumed);
+            if (consumed || (position.turnId && cancelledTurns.has(position.turnId))) {
+                publish(snapshot);
+                return;
+            }
+            publish({
+                ...snapshot,
+                pendingInputs: [
+                    ...snapshot.pendingInputs,
+                    {
+                        key: "pending:" + String(promptIndex++),
+                        content,
+                        inputId: input.inputId,
+                        delivery: input.delivery,
+                    },
+                ],
+            });
+        },
+        /** 在自动 queue Turn 开始前，将 prompt 放进目标 Turn 的事件序列并清除等待态。 */
+        markQueuedInputStarted(input) {
+            if (settledInputIds.has(input.inputId))
+                return;
+            settledInputIds.add(input.inputId);
+            const position = { turnId: input.turnId, eventCount: 0, items: [] };
+            consumedPositions.set(input.inputId, position);
+            const pending = snapshot.pendingInputs.find(function same(item) { return item.inputId === input.inputId; });
+            // 领取回调的 content 可能带附件展开，只在原文已经确认时输出正文。
+            if (pending)
+                putInput(pending.content, input, position, true);
+            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.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);
+                if (!consumedPositions.has(event.inputId))
+                    consumedPositions.set(event.inputId, captureTuiInputPosition(event.turnId, currentEvents, snapshot.livePresentation));
+                const pending = nextSnapshot.pendingInputs.find(function same(item) { return item.inputId === event.inputId; });
+                nextSnapshot.pendingInputs = nextSnapshot.pendingInputs.filter(function keepPendingInput(item) { return item.inputId !== event.inputId; });
+                const host = nextEvents.find(function same(item) { return item.type === "tui_input_consumed" && item.inputId === event.inputId; });
+                if (host?.type === "tui_input_consumed")
+                    nextSnapshot.liveEvents = nextEvents.map(function consume(item) { return item === host ? { ...host, consumed: true } : item; });
+                eventsByTurn.set(event.turnId, nextSnapshot.liveEvents);
+                if (!host && pending) {
+                    snapshot = nextSnapshot;
+                    const position = pending.delivery === "queue" ? { turnId: event.turnId, eventCount: 0, items: [] } : consumedPositions.get(event.inputId);
+                    consumedPositions.set(event.inputId, position);
+                    putInput(pending.content, pending, position, true);
+                    nextSnapshot.liveEvents = snapshot.liveEvents;
+                    nextSnapshot.transcript = snapshot.transcript;
+                }
+            }
+            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) {
+            if (projection.turnId && !eventsByTurn.has(projection.turnId) && projection.events.length > 0)
+                eventsByTurn.set(projection.turnId, projection.events.filter(function belongs(event) { return event.turnId === projection.turnId; }));
+            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,
+                liveMetrics: keepLiveTurn && projection.turnId ? metricsByTurn.get(projection.turnId) : 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;
+            if (requested && snapshot.liveTurnId) {
+                cancelledTurns.add(snapshot.liveTurnId);
+                const events = snapshot.liveEvents.map(function cancel(event) { return event.type === "tui_input_consumed" && event.consumed === false ? { ...event, cancelled: true } : event; });
+                eventsByTurn.set(snapshot.liveTurnId, events);
+                snapshot = { ...snapshot, liveEvents: events, pendingInputs: [] };
+            }
+            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;
+}>;

package/dist/tui/timeline/live.js

@@ -0,0 +1,153 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/** 动态时间线的增量缓存与渲染：只更新尾部事件或当前回答块，避免重扫全部事件。 */
+import { memo, useRef } from "react";
+import { Box, Text } from "ink";
+import { TUI_ACCENT_COLOR } from "../../design-tokens.js";
+import { TUI_AGENT_LABEL } from "../constants.js";
+import { formatTuiDuration, formatTuiInputConsumed, getTuiApprovalDecisionLabel, isTerminalStatus } from "../format.js";
+import { TuiMarkdown } from "../markdown/markdown.js";
+import { TuiPromptLine } from "../transcript.js";
+import { renderTuiToolTreeEvent } from "./tool-tree.js";
+/** 为增量时间线生成稳定键，避免 answer delta 到达时重建历史节点。 */
+function getCliTuiTimelineEventKey(event) {
+    const inputId = "inputId" in event ? event.inputId : "";
+    const approvalId = "approvalId" in event ? event.approvalId : "";
+    return `${event.type}:${event.seq}:${event.turnId}:${inputId}:${approvalId}`;
+}
+/** 判断新事件列表是否只是同一 Turn 的尾部追加。 */
+function isCliTuiTimelineAppendOnly(cache, events) {
+    if (cache.eventCount === 0)
+        return true;
+    const hostInputs = events.filter(function host(event) { return event.type === "tui_input_consumed"; });
+    if (hostInputs.length !== cache.hostInputs.length || hostInputs.some(function changed(event, index) { return event !== cache.hostInputs[index]; }))
+        return false;
+    return events.length >= cache.eventCount && events[cache.eventCount - 1] === cache.lastEvent;
+}
+/** 应用一条时间线事件，只修改新增尾部或当前回答块。 */
+function appendCliTuiTimelineEvent(cache, event) {
+    if (event.type === "answer_delta") {
+        if (!event.delta)
+            return;
+        const lastBlock = cache.blocks[cache.blocks.length - 1];
+        if (lastBlock?.kind === "answer") {
+            lastBlock.answer += event.delta;
+            return;
+        }
+        cache.blocks.push({ kind: "answer", key: "answer:" + String(event.seq), answer: event.delta });
+        return;
+    }
+    if (event.type === "answer_reset") {
+        for (let index = cache.blocks.length - 1; index >= 0; index -= 1) {
+            if (cache.blocks[index]?.kind === "answer") {
+                cache.blocks.splice(index, 1);
+                break;
+            }
+        }
+    }
+    if (event.type === "tui_approval_submitted") {
+        for (const block of cache.blocks) {
+            if (block.kind === "event" && block.event.type === "approval_required" && block.event.approvalId === event.approvalId)
+                block.hidden = true;
+        }
+    }
+    cache.blocks.push({ kind: "event", key: getCliTuiTimelineEventKey(event), event });
+}
+/** 首次或 Turn 切换时完整归约时间线；后续更新走尾部增量路径。 */
+function createCliTuiTimelineCache(events) {
+    const cache = { eventCount: 0, blocks: [], hostInputs: events.filter(function host(event) { return event.type === "tui_input_consumed"; }) };
+    for (const event of events)
+        appendCliTuiTimelineEvent(cache, event);
+    cache.eventCount = events.length;
+    cache.lastEvent = events[events.length - 1];
+    return cache;
+}
+/** 为当前 live Turn 复用已归约的时间线块，避免每个输入字符重扫全部事件。 */
+function useCliTuiTimelineBlocks(events) {
+    const cacheRef = useRef(undefined);
+    let cache = cacheRef.current;
+    if (!cache || !isCliTuiTimelineAppendOnly(cache, events)) {
+        cache = createCliTuiTimelineCache(events);
+    }
+    else {
+        for (let index = cache.eventCount; index < events.length; index += 1) {
+            const event = events[index];
+            if (event)
+                appendCliTuiTimelineEvent(cache, event);
+        }
+        cache.eventCount = events.length;
+        cache.lastEvent = events[events.length - 1];
+    }
+    cacheRef.current = cache;
+    return cache.blocks;
+}
+/** 渲染一个不再随连续 answer delta 改变的安全事件节点。 */
+function TuiLiveEventBlock(props) {
+    const event = props.event;
+    if (event.type === "tui_input_consumed") {
+        return _jsxs(Box, { flexDirection: "column", children: [_jsx(TuiPromptLine, { content: event.content, useColor: props.useColor, columns: props.maximumWidth + 2 }), _jsx(Text, { dimColor: props.useColor, children: event.cancelled ? "[引导] 已取消" : event.consumed === false ? "[引导] 等待当前步骤结束" : formatTuiInputConsumed(event) })] });
+    }
+    if (event.type === "tui_approval_submitted") {
+        return _jsxs(Text, { dimColor: props.useColor, children: ["Approval submitted \u00B7 ", getTuiApprovalDecisionLabel(event.decision)] });
+    }
+    if (event.type === "turn_started" || event.type === "reasoning_summary" || event.type === "reasoning_hidden" || event.type === "answer_reset" || event.type === "input_joined" || event.type === "input_consumed" || event.type === "active_skills")
+        return null;
+    if (event.type === "tool_started" || event.type === "tool_result")
+        return renderTuiToolTreeEvent(event, props.useColor);
+    if (event.type === "approval_required")
+        return null;
+    if (event.type === "input_queued")
+        return _jsx(Text, { dimColor: props.useColor, children: "Additional instruction queued; waiting for the current step" });
+    if (event.type === "todo_updated")
+        return null;
+    if (event.type === "model_recovery")
+        return _jsxs(Text, { dimColor: props.useColor, children: ["Recovering \u00B7 ", event.reason] });
+    if (event.type === "context_overflow")
+        return _jsx(Text, { children: "Context limit reached; organizing before continuing" });
+    if (event.type === "context_compact_started")
+        return _jsx(Text, { dimColor: props.useColor, children: "Organizing context" });
+    if (event.type === "context_compacted")
+        return _jsx(Text, { children: "Context organized" });
+    if (event.type === "context_compact_failed")
+        return _jsx(Text, { children: "Context organization failed" });
+    if (event.type === "context_compact_circuit_open")
+        return _jsx(Text, { children: "Context organization temporarily unavailable" });
+    if (event.type === "status")
+        return null;
+    return null;
+}
+/** 对历史事件节点启用 memo，使新增 answer delta 不重新执行工具/diff/审批渲染。 */
+const MemoizedTuiLiveEventBlock = memo(TuiLiveEventBlock);
+/** 渲染当前累计回答块；只有最后一个连续回答块会随 delta 更新。 */
+function TuiLiveAnswerBlock(props) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: props.useColor ? TUI_ACCENT_COLOR : undefined, children: ["\u2022 ", TUI_AGENT_LABEL] }), props.renderMarkdown
+                ? _jsx(TuiMarkdown, { content: props.answer, keyPrefix: props.keyPrefix, useColor: props.useColor, maximumWidth: props.maximumWidth })
+                : _jsx(Text, { wrap: "wrap", children: props.answer })] }));
+}
+/** 对回答块启用 memo，保持长时间线中已经完成的 Markdown 节点不变。 */
+const MemoizedTuiLiveAnswerBlock = memo(TuiLiveAnswerBlock);
+/** 增量渲染当前 Turn 的时间线块；完整 transcript 由历史树使用 renderTimeline。 */
+function renderTuiLiveTimelineBlock(block, useColor, renderMarkdown, maximumWidth) {
+    if (block.kind === "answer") {
+        return _jsx(MemoizedTuiLiveAnswerBlock, { answer: block.answer, keyPrefix: block.key, useColor: useColor, renderMarkdown: renderMarkdown, maximumWidth: maximumWidth });
+    }
+    if (block.hidden)
+        return null;
+    if (block.event.type === "answer_delta")
+        return null;
+    return _jsx(MemoizedTuiLiveEventBlock, { event: block.event, useColor: useColor, maximumWidth: maximumWidth });
+}
+/**
+ * Ink 在动态区超过一屏后会清空终端并从顶部重绘；把已经确定的块交给
+ * 历史树后，动态区最多只保留当前回答或未决审批，避免活动期间
+ * 的每个事件都把 Windows Terminal 的原生滚动视口拉回顶部。
+ */
+export const TuiLiveTimeline = memo(function TuiLiveTimeline(props) {
+    const blocks = useCliTuiTimelineBlocks(props.events);
+    const firstAnswerKey = blocks.find(function findFirstAnswer(block) { return block.kind === "answer"; })?.key;
+    function renderBlock(block) {
+        return (_jsxs(Box, { flexDirection: "column", children: [block.key === firstAnswerKey && props.metrics?.firstAnswerAt !== undefined ? _jsxs(Text, { dimColor: props.useColor, children: ["Thought for ", formatTuiDuration(Math.max(0, props.metrics.firstAnswerAt - props.metrics.startedAt))] }) : null, renderTuiLiveTimelineBlock(block, props.useColor, isTerminalStatus(props.status), props.maximumWidth)] }, block.key));
+    }
+    return (_jsx(_Fragment, { children: blocks.map(function renderDynamicTimelineBlock(block) {
+            return renderBlock(block);
+        }) }));
+});

package/dist/tui/timeline/presentation-timeline.d.ts

@@ -0,0 +1,15 @@
+/** 基于共享 Presentation selector 的 CLI 时间线；不读取旧工具 summary、detail 或审批 preview。 */
+import { type AgentPresentationState } from "@autopilot-agent/presentation";
+import { type ReactNode } from "react";
+import type { CliTuiTimelineEvent } from "../types.js";
+/** 详情视图参数：expanded 驱动 Todo 卡展开，toolGroupsExpanded 驱动工具分组展开；screen reader 恒展开全部明细。 */
+type TuiDetailView = {
+    expanded: boolean;
+    screenReader: boolean;
+    rowLimit?: number;
+    showToggleHint?: boolean;
+    toolGroupsExpanded?: boolean;
+};
+/** 渲染指定 Turn 的共享 Presentation 时间线；无匹配节点时由调用方回退兼容旧事件。 */
+export declare function renderTuiPresentationTimeline(presentation: AgentPresentationState, turnId: string, useColor: boolean, maximumWidth: number, detailView: TuiDetailView, events?: CliTuiTimelineEvent[]): ReactNode[];
+export {};