feat(ui): group reasoning and tool calls into collapsible Processing blocks by Astro-Han · Pull Request #1320 · apache/maka

Astro-Han · 2026-07-22T01:28:40Z

Summary

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han · 2026-07-22T01:28:40Z

Summary

Closes#1307.

During longer tasks, every reasoning step and tool call rendered as its own timeline item, pushing the actual answer far down the conversation. Now each maximal run of thinking + tool activity between two answer texts folds into one collapsed "Processing" block; answer text always renders in place, and the expanded panel replays the full original timeline (the same 深度思考 disclosures and tool trows, nothing is lost).

Behavior decisions, where they differ from the issue's suggested behavior:

Answer text is the grouping boundary, so a turn can hold several Processing blocks (e.g. reasoning above a short interim answer, tools below it) instead of one section per turn. This keeps every user-facing text visible in chronological place.
Failures do not force the block open, deviating from the issue's "keep failures visible": recovered tool errors are not actionable, and the collapsed summary line already carries the failure signal (red icon + 「N 个失败」count), consistent with the existing tool-trow design locked by tool-trow-summary.test.ts. Only waiting_permission forces the block open; permission prompts themselves live outside the timeline and are unaffected.
While running, the block stays collapsed and its summary line shows the current activity live (「正在读取 foo.ts…」, plus the failed count as soon as a tool errors), then settles into the tool-activity roll-up (「读取 15 个文件，搜索 8 次」). Folded reasoning is not counted in the summary — thinking is not tool activity — and a pure-thinking run (no tools) stays a bare 深度思考 disclosure instead of folding into a Processing block. Manual expand/collapse sticks, per the existing disclosure-collapsible-contract (no defaultOpen).

The timeline model stays flat: the fold is a render-layer derivation (packages/ui/src/timeline-fold.ts, applied via useMemo in TurnView), so timeline-rewriting passes (overlayLiveTurn, projectTurnTools, shell-run folding) never maintain a nesting invariant — an invalid "tools-less Processing block" is unrepresentable by construction. Each block's React key derives from its preceding answer-text boundary, so projection removing a block's first tool cannot remount the disclosure or drop a manual toggle. Rendering reuses the existing Collapsible primitive, useToolDisclosure state machine, and SETTLE_FADE; no new CSS.

Verification

@maka/ui tests 223/223, @maka/desktop tests 2761/2761 (both re-run independently of the implementation pass), npm run lint, npm run format:check, workspace typecheck + build — all green.
An external adversarial review round (Codex + Kimi K3, independent) drove the final shape: their confirmed findings (a projection edge that could leave an empty Processing block, content-derived key instability, live-summary gaps) were resolved by moving the fold out of the timeline model rather than patching each site; regression tests for all three now lock the behavior.
Unit coverage: fold rules and block-id stability in timeline-fold.test.ts (pure thinking stays bare, interleaved runs, text-boundary multi-block, id survives first-tool projection); shell-run-fold regression in materialize.test.ts (a turn whose only tool is projected away yields a flat ['thinking'] timeline); render-level waiting_permission force-open in processing-block.test.tsx; live-summary cases in tool-trow-summary.test.ts (failed-count while running, last-live-activity pick, connector-tool localization).
New Processing story in chat-surface.stories.tsx (storybook contract updated) covers the collapsed block with a failed tool ahead of the answer text.
Before/after evidence below: both states captured from the live app (Playwright e2e fixture mode, fake backend, identical injected session on main vs this branch), composed with ImageMagick only.

Before / after (live app)

Expanded state — the same block manually opened, replaying the full timeline:

Review focus

packages/ui/src/timeline-fold.ts — the single place the fold rule lives; materialize.ts differs from main only by a doc comment stating the model stays flat.
trow-summary.ts now owns resolveToolDisplayName/isConnectorTool (moved from presentation.ts, which re-exports them) so the live Processing summary shares the localized name fallback without an import cycle.
streaming-handoff.test.ts asserts the folded render; materialize-turns.test.ts and live-turn-projection.test.ts are restored byte-identical to main.

…ing blocks Group each maximal run of thinking + tool-call timeline entries between two assistant answer texts into one collapsed "Processing" block (#1307). Answer text stays a grouping boundary and always renders in place, so a turn can hold several Processing blocks; the expanded block replays the full timeline (the same 深度思考 disclosures and tool trows, nested one indent in). - materialize: add a `processing` TurnTimelineItem kind and group in a shared finalize pass used by both the settled (buildTurnTimeline) and live-overlay paths, so streaming and replayed history fold identically; projectTurnTools descends into blocks while preserving turn identity. - trow-summary/copy: summarizeProcessing / isProcessingRunning / processingNeedsAttention — reasoning count + tool buckets + red failed count, live current-activity line, waiting_permission force-open (errors stay collapsed), reusing the existing trow summary + disclosure state machine. - chat-turn: ProcessingBlock renders via the shared disclosure/SETTLE_FADE seams, collapsed by default with sticky manual toggle.

Show a collapsed "Processing" block (#1307): two think-then-call steps with a failing tool fold into one summary (思考 2 次 + tool counts + a red failed count) ahead of the assistant answer. Enumerate it in the chat-surface Storybook contract.

…inking runs bare Review feedback on #1307: - The collapsed summary line now rolls up tool activity only (「读取 1 个文件，搜索 1 次，1 个失败」) — folded reasoning stays inside the block but is no longer counted; the settled `summary.thinking` copy is removed (zh/en). The live `thinkingActivity` fallback (「正在深度思考」 when the block's tools are done and thinking still streams) stays. - A run between two answer texts folds into a Processing block only when it contains at least one tools group; a pure-thinking run renders as the bare 深度思考 disclosure (including the live streaming path). groupProcessing applies the rule identically on the settled and live-overlay paths.

… render layer External review (Codex + Kimi) adjudication on #1307: baking the 'processing' kind into the shared TurnTimelineItem model forced every timeline-rewriting pass (overlayLiveTurn's flatten/refold, projectTurnTools' descent) to maintain the nesting invariant, and projectTurnTools missed it — shell-run folding could strip a block's every tool and strand an illegal thinking-only Processing block with an empty summary (P1). - materialize.ts reverts to main's flat TurnTimelineItem model; the processing kind, its child types, groupProcessing/flattenProcessing/ finalizeTimeline, overlayLiveTurn's flatten→refold, and projectTurnTools' processing branch are all removed. - New pure module timeline-fold.ts derives the folded view at render time: foldTimeline keeps answer text in place as the boundary, folds a maximal thinking+tools run into one block only when it contains a tools group, and gives each block a stable id from the preceding text's messageId ('start' at turn head) — so a block's React key survives its first tool being projected away without remounting or dropping a manual toggle (P2). - TurnView folds via useMemo(foldTimeline); ProcessingBlock consumes fold children and loses its dead onStreamingSettled prop; TurnTimelineEntry, timelineEntryKey, and the live-content check return to their flat forms. - Tests: materialize-turns.test.ts and live-turn-projection.test.ts restore their original stronger assertions (flatten helpers removed); the grouping cases move to timeline-fold.test.ts with a block-id stability case; new P1 regression (shell-run fold leaves a flat thinking-only timeline) and a render-level waiting_permission force-open test.

…y pick, and localization External review (Codex + Kimi) adjudication on #1307, live-summary findings: - The live line now appends the failed clause whenever the block already holds an errored tool (「正在运行测试，1 个失败」) — errored tools stay collapsed, so the summary must carry the failure signal before settle, matching the trow (P2). - The current activity is the LAST live entry in timeline order: children are walked in reverse and a still-streaming thinking block or a group's active tool wins, instead of flattening all tools and letting an earlier running tool outrank a later streaming reasoning block (P3). - The no-intent/no-displayName fallback routes through resolveToolDisplayName, so a bare load_tools call reads as the localized 「加载工具组」 (P3). The resolver and isConnectorTool move down into trow-summary.ts (the leaf module) to avoid an import cycle; presentation.ts re-exports them for its existing consumers.

…p is projected away

…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Astro-Han added 2 commits July 22, 2026 09:17

Astro-Han mentioned this pull request Jul 22, 2026
feat(ui): group reasoning and tool calls into a collapsible section #1307
Closed

Astro-Han added 5 commits July 22, 2026 10:29

docs(ui): note the Processing fold dissolves when its last tools grou…
5d1bfbb
…p is projected away

Merge remote-tracking branch 'origin/main' into feat/1307-processing-…
387bc00
…collapse # Conflicts: # packages/ui/src/chat-turn.tsx

Astro-Han merged commit 17cc81d into mainJul 22, 2026
3 checks passed

Astro-Han deleted the feat/1307-processing-collapse branch July 22, 2026 11:36

Astro-Han mentioned this pull request Aug 14, 2026
perf(ui): virtualize long chat transcripts #2975
Merged
8 tasks

Uh oh!

Conversation

Astro-Han commented Jul 22, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Verification

Before / after (live app)

Review focus

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

Astro-Han commented Jul 22, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Verification

Before / after (live app)

Review focus

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

Astro-Han commented Jul 22, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Verification

Before / after (live app)

Review focus

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

Astro-Han commented Jul 22, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Verification

Before / after (live app)

Review focus

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

Astro-Han commented Jul 22, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Verification

Before / after (live app)

Review focus

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading

Astro-Han commented Jul 22, 2026•
edited
Loading