praxis-agent 0.34.0 → 0.35.0

package/dist/application/subagent-service.js

@@ -8,7 +8,8 @@ import { createClaudeAsyncAgentToolUseResult, createClaudeAgentToolUseResult, cr
 import { projectClaudeModelMessages, projectClaudeSidechainContinuationMessages, } from '../compatibility/claude/projection.js';
 import { selectClaudeSchemaAdapter, } from '../compatibility/claude/schema.js';
 import { createClaudeHookAttachmentEntries, translateProviderEvents, } from '../compatibility/claude/translation.js';
-import { injectFirstUserMessageContext, } from '../core/context.js';
+import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/context.js';
+import { assembleContextSnapshot } from '../core/prompt-composer.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
@@ -1995,9 +1996,6 @@ export class ClaudeSubagentExecutor {
             const agentSystem = memoryPrompt
                 ? `${baseSystem}\n\n${memoryPrompt}`
                 : baseSystem;
-            const system = options.outputSchema
-                ? `${agentSystem}\n\nYou MUST call StructuredOutput exactly once at the end with a value matching its schema.`
-                : agentSystem;
             const preloadedSkills = agentSkillMessages(this.options.extensions, customAgent);
             let stopHookActive = false;
             const contextBudget = options.provider.capabilities.contextWindowTokens
@@ -2016,22 +2014,28 @@ export class ClaudeSubagentExecutor {
                 ? runtimeTools.definitions()
                 : [];
             let observedMessages;
+            let stableSystemMessageCount = 0;
             const assembleMessages = async () => {
-                const assembledContext = await this.options.contextAssembler?.assemble({
+                const assembledContext = await assembleContextSnapshot(this.options.contextAssembler, {
                     cwd,
                     lifecycleId: options.agentId,
                     mode: 'subagent',
-                    baseSystemPrompt: system,
+                    baseSystemPrompt: agentSystem,
+                    ...(options.outputSchema
+                        ? {
+                            turn: {
+                                structuredOutput: true,
+                            },
+                        }
+                        : {}),
                 });
-                const composedSubagentPolicy = assembledContext?.promptSections?.some((section) => section.id === 'subagent-policy');
+                const contextProjection = projectContextSnapshot(assembledContext);
+                stableSystemMessageCount = contextProjection.stableSystemSectionCount;
                 const messages = [
-                    ...(assembledContext?.systemMessages ?? []),
-                    ...(composedSubagentPolicy
-                        ? []
-                        : [{ role: 'system', content: system }]),
+                    ...contextProjection.systemMessages,
                     ...injectFirstUserMessageContext(options.continuationMessage === undefined
                         ? projectClaudeModelMessages(snapshot.entries)
-                        : projectClaudeSidechainContinuationMessages(snapshot.entries), assembledContext?.firstUserMessageContext),
+                        : projectClaudeSidechainContinuationMessages(snapshot.entries), contextProjection.firstUserMessageContext),
                     ...preloadedSkills,
                 ];
                 observedMessages = messages;
@@ -2042,11 +2046,17 @@ export class ClaudeSubagentExecutor {
             };
             const configuredEffort = typeof customAgent?.effort === 'string' ? customAgent.effort : undefined;
             const effectiveEffort = options.effort ?? configuredEffort;
-            const result = await runtime.run({
+            const initialMessages = await assembleMessages();
+            const runtimeRequest = {
                 sessionId: String(options.root.sessionId),
-                messages: await assembleMessages(),
+                messages: initialMessages,
                 collectMetrics: true,
-                reloadMessages: assembleMessages,
+                stableSystemMessageCount,
+                reloadMessages: async () => {
+                    const messages = await assembleMessages();
+                    runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                    return messages;
+                },
                 cwd,
                 ...(effectiveEffort ? { effort: effectiveEffort } : {}),
                 toolResultDirectory: options.toolResultDirectory,
@@ -2119,7 +2129,8 @@ export class ClaudeSubagentExecutor {
                     }
                     : {}),
                 ...(options.signal ? { signal: options.signal } : {}),
-            });
+            };
+            const result = await runtime.run(runtimeRequest);
             contextBudget?.observeUsage(result.usage, observedMessages ?? [], definitions);
             this.options.eventSink?.({
                 type: 'task-progress',

package/dist/application/turn-lifecycle.d.ts

@@ -0,0 +1,38 @@
+import { type ModelDocument, type ModelImage, type RuntimeEventSink } from '../core/runtime.js';
+export type TurnActivation = {
+    kind: 'start';
+    sessionId: string;
+    name?: string;
+} | {
+    kind: 'resume';
+    sessionId: string;
+    name?: string;
+    atMessageId?: string;
+};
+export type TurnSubmission = {
+    kind: 'prompt';
+    text: string;
+    images?: readonly ModelImage[];
+    documents?: readonly ModelDocument[];
+} | {
+    kind: 'shell';
+    command: string;
+} | {
+    kind: 'retry';
+    prompt: string;
+};
+export interface TurnRequest {
+    activation: TurnActivation;
+    submission: TurnSubmission;
+    signal?: AbortSignal;
+}
+export declare class TurnTerminalController {
+    private readonly sink;
+    private terminal;
+    constructor(sink: RuntimeEventSink);
+    emit: RuntimeEventSink;
+    complete(): void;
+    fail(error: unknown, signal?: AbortSignal): void;
+    private transition;
+}
+//# sourceMappingURL=turn-lifecycle.d.ts.map

package/dist/application/turn-lifecycle.js

@@ -0,0 +1,36 @@
+import { AgentRunCancelledError, ModelProviderError, } from '../core/runtime.js';
+export class TurnTerminalController {
+    sink;
+    terminal = false;
+    constructor(sink) {
+        this.sink = sink;
+    }
+    emit = (event) => {
+        if (event.type === 'state' &&
+            (event.state === 'completed' ||
+                event.state === 'cancelled' ||
+                event.state === 'failed')) {
+            return;
+        }
+        this.sink(event);
+    };
+    complete() {
+        this.transition('completed');
+    }
+    fail(error, signal) {
+        if (this.terminal)
+            return;
+        const cancelled = signal?.aborted === true ||
+            error instanceof AgentRunCancelledError ||
+            (error instanceof ModelProviderError && error.kind === 'cancelled');
+        this.transition(cancelled ? 'cancelled' : 'failed');
+    }
+    transition(state) {
+        if (this.terminal) {
+            throw new Error('Turn terminal transition already emitted');
+        }
+        this.terminal = true;
+        this.sink({ type: 'state', state });
+    }
+}
+//# sourceMappingURL=turn-lifecycle.js.map

package/dist/cli/interactive.js

@@ -18,7 +18,6 @@ import { loadClaudeReleaseNotes } from './tui/release-notes.js';
 import { fullscreenInkRenderOptions } from './tui/fullscreen-renderer.js';
 import { StreamingFrameBuffer } from './tui/streaming-frame-buffer.js';
 import { createClaudeStatusLineInput, StatusLine } from './tui/status-line.js';
-import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, transcriptLineCount, } from './tui/transcript-viewport.js';
 import { projectTuiView, resolveTuiRenderer } from './tui/tui-view-model.js';
 import { loadGitDiff, visiblePatchLines, } from './tui/git-diff.js';
 import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
@@ -466,7 +465,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     // composer/status chrome intact and keeping the active stream visible.
     // Classic and screen-reader modes always render the full history exactly as
     // before.
-    const { projectedHistory, resumed, freshSession, hasConversationHistory } = projectTuiView({
+    const { transcriptEntries, transcriptPageRows, maxTranscriptScrollOffset, resumed, freshSession, hasConversationHistory, } = useMemo(() => projectTuiView({
         initialHistory,
         history,
         resume: resume !== undefined,
@@ -475,7 +474,19 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         rows,
         width,
         scrollOffset: transcriptScrollOffset,
-    });
+        detailedTranscript: thinkingExpanded || runtimeSettings.verbose,
+    }), [
+        initialHistory,
+        history,
+        resume,
+        fixedViewport,
+        axScreenReader,
+        rows,
+        width,
+        transcriptScrollOffset,
+        thinkingExpanded,
+        runtimeSettings.verbose,
+    ]);
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -2979,7 +2990,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             !question &&
             !elicitation &&
             !selectingSession) {
-            const page = Math.max(1, (rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS);
+            const page = transcriptPageRows;
             const scrollDelta = key.pageUp
                 ? page
                 : key.pageDown
@@ -2994,8 +3005,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                                     ? -1
                                     : 0;
             if (scrollDelta !== 0) {
-                setTranscriptScrollOffset((current) => Math.min(Math.max(0, transcriptLineCount(history, width) -
-                    Math.max(1, (rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS)), Math.max(0, current + Math.trunc(scrollDelta))));
+                setTranscriptScrollOffset((current) => Math.min(Math.max(0, maxTranscriptScrollOffset), Math.max(0, current + Math.trunc(scrollDelta))));
                 return;
             }
         }
@@ -5857,7 +5867,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                                 minHeight: 0,
                                 overflowY: 'hidden',
                             }
-                            : {}), children: _jsx(Transcript, { items: projectedHistory, activeText: activeText, activeThinking: activeThinking, activeStreamVisible: transcriptScrollOffset === 0, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }) }), externalEditorRequest !== null ||
+                            : {}), children: _jsx(Transcript, { entries: transcriptEntries, activeText: activeText, activeThinking: activeThinking, activeStreamVisible: transcriptScrollOffset === 0, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }) }), externalEditorRequest !== null ||
                         keybindingsEditing ||
                         memoryEditorRequest !== null ? (_jsx(ExternalEditorWait, { screenReader: axScreenReader })) : permission ? (permission.kind === 'tool' && toolPermissionModel ? (_jsx(ToolPermissionDialog, { model: toolPermissionModel, selection: permissionSelection, feedbackMode: permissionFeedbackMode, feedback: input, ruleEditor: permissionRuleEditor, screenReader: axScreenReader })) : (_jsxs(DialogFrame, { title: `Retry interrupted ${permission.call.name}?`, screenReader: axScreenReader, children: [_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: _jsx(Text, { bold: true, children: describeTool(permission.call, sensitiveValues) }) }), _jsx(Text, { children: "Do you want to proceed?" }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 0, children: [selectionPrefix(permissionSelection === 0, axScreenReader), "1. Yes"] }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 1, children: [selectionPrefix(permissionSelection === 1, axScreenReader), "2. No"] }), permissionFeedbackMode ? (_jsxs(Text, { children: ["\u203A", ' ', input ||
                                         (permissionSelection === 0

package/dist/cli/protocol.js

@@ -1788,11 +1788,14 @@ export class StreamJsonOutput {
                 event.state === 'executing-tools' ||
                 event.state === 'persisting-results' ||
                 event.state === 'completed' ||
-                event.state === 'cancelled') {
+                event.state === 'cancelled' ||
+                event.state === 'failed') {
                 this.flushAssistant();
                 if (event.state === 'awaiting-permission')
                     this.writeSessionState('requires_action');
-                else if (event.state === 'completed' || event.state === 'cancelled') {
+                else if (event.state === 'completed' ||
+                    event.state === 'cancelled' ||
+                    event.state === 'failed') {
                     this.writeSessionState('idle');
                 }
             }

package/dist/cli/tui/claude-style.d.ts

@@ -1,5 +1,5 @@
 import { type ReactElement } from 'react';
-import type { ModelToolCall, ModelUsage } from '../../core/runtime.js';
+import type { ModelUsage } from '../../core/runtime.js';
 import type { AgentColorName } from '../../compatibility/claude/agent-color.js';
 import type { DataPlane } from '../../persistence/data-plane.js';
 import type { TuiFileEntry, TuiMentionEntry } from './file-picker.js';
@@ -10,6 +10,7 @@ import type { TuiPermissionRule } from './permission-settings.js';
 import type { RecentlyDeniedAction } from './recently-denied.js';
 import type { CustomThemeToken, TuiCustomTheme } from './custom-themes.js';
 import type { TuiSlashCommand } from './slash-commands.js';
+import type { TranscriptPresentationEntry } from './transcript-presentation.js';
 import { type TuiTheme } from './theme.js';
 export interface TuiDisplayMetadata {
     version: string;
@@ -19,51 +20,7 @@ export interface TuiDisplayMetadata {
     permissionMode?: string;
     contextWindowTokens?: number;
 }
-export type TranscriptItem = {
-    kind: 'user' | 'assistant' | 'notice' | 'warning';
-    text: string;
-} | {
-    kind: 'local-result';
-    text: string;
-} | {
-    kind: 'thinking';
-    text: string;
-} | {
-    kind: 'compact';
-    summary: string;
-} | {
-    kind: 'context';
-    usedTokens: number;
-    contextWindowTokens: number;
-    model?: string;
-    skills: readonly {
-        name: string;
-        tokens: number;
-    }[];
-    memoryFiles: readonly {
-        path: string;
-        tokens: number;
-    }[];
-} | {
-    kind: 'tool';
-    call: ModelToolCall;
-    detail: string;
-} | {
-    kind: 'tool-result';
-    callId: string;
-    text: string;
-    isError: boolean;
-} | {
-    kind: 'shell';
-    callId: string;
-    command: string;
-} | {
-    kind: 'shell-result';
-    callId: string;
-    stdout: string;
-    stderr: string;
-    isError: boolean;
-};
+export type { TranscriptItem } from './transcript-presentation.js';
 export interface TuiBtwEntry {
     id: number;
     question: string;
@@ -92,8 +49,8 @@ export declare function activeStreamWindow(text: string): {
     pendingText: string;
     truncated: boolean;
 };
-export declare function Transcript({ items, activeText, activeThinking, activeStreamVisible, thinkingExpanded, detailedTranscript, screenReader, }: {
-    items: readonly TranscriptItem[];
+export declare function Transcript({ entries, activeText, activeThinking, activeStreamVisible, thinkingExpanded, detailedTranscript, screenReader, }: {
+    entries: readonly TranscriptPresentationEntry[];
     activeText: string;
     activeThinking?: string;
     activeStreamVisible?: boolean;

package/dist/cli/tui/claude-style.js

@@ -516,94 +516,42 @@ function ActiveStreamText({ text }) {
     const { stableText, pendingText, truncated } = activeStreamWindow(text);
     return (_jsxs(Box, { flexDirection: "column", children: [truncated ? _jsx(Text, { dimColor: true, children: "\u2026 earlier streaming content \u2026" }) : null, stableText ? _jsx(MarkdownText, { text: stableText }) : null, pendingText ? _jsx(Text, { children: pendingText }) : null] }));
 }
-export function Transcript({ items, activeText, activeThinking = '', activeStreamVisible = true, thinkingExpanded = false, detailedTranscript = false, screenReader, }) {
+export function Transcript({ entries, activeText, activeThinking = '', activeStreamVisible = true, thinkingExpanded = false, detailedTranscript = false, screenReader, }) {
     const palette = useTuiPalette();
     const detailed = thinkingExpanded || detailedTranscript;
-    const results = new Map(items
-        .filter((item) => item.kind === 'tool-result')
-        .map((item) => [item.callId, item]));
-    const pairedResults = new Set(items
-        .filter((item) => item.kind === 'tool' && results.has(item.call.id))
-        .map((item) => item.call.id));
-    const shellResults = new Map(items
-        .filter((item) => item.kind === 'shell-result')
-        .map((item) => [item.callId, item]));
-    const pairedShellResults = new Set(items
-        .filter((item) => item.kind === 'shell' && shellResults.has(item.callId))
-        .map((item) => item.callId));
-    const readGroupStarts = new Map();
-    const groupedReadTools = new Set();
-    if (!detailed && !screenReader) {
-        for (let index = 0; index < items.length; index += 1) {
-            const first = items[index];
-            if (first?.kind !== 'tool' || first.call.name !== 'Read')
-                continue;
-            let cursor = index;
-            const memberIndexes = [];
-            const memberCallIds = new Set();
-            while (cursor < items.length) {
-                const candidate = items[cursor];
-                if (candidate?.kind === 'tool' && candidate.call.name === 'Read') {
-                    const result = results.get(candidate.call.id);
-                    if (!result || result.isError)
-                        break;
-                    memberIndexes.push(cursor);
-                    memberCallIds.add(candidate.call.id);
-                    cursor += 1;
-                    continue;
+    return (_jsxs(Box, { flexDirection: "column", children: [entries.map((entry, index) => {
+                if (entry.kind === 'read-summary') {
+                    return (_jsxs(Text, { children: ['  ', "Read ", entry.count, " file", entry.count === 1 ? '' : 's', ' ', _jsx(Text, { dimColor: true, children: "(ctrl+o to expand)" })] }, entry.key));
                 }
-                if (candidate?.kind === 'tool-result' &&
-                    memberCallIds.has(candidate.callId)) {
-                    cursor += 1;
-                    continue;
-                }
-                break;
-            }
-            if (memberIndexes.length === 0)
-                continue;
-            readGroupStarts.set(index, memberIndexes.length);
-            for (const memberIndex of memberIndexes.slice(1)) {
-                groupedReadTools.add(memberIndex);
-            }
-            index = cursor - 1;
-        }
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [items.map((item, index) => {
-                const readCount = readGroupStarts.get(index);
-                if (readCount !== undefined) {
-                    return (_jsxs(Text, { children: ['  ', "Read ", readCount, " file", readCount === 1 ? '' : 's', ' ', _jsx(Text, { dimColor: true, children: "(ctrl+o to expand)" })] }, index));
-                }
-                if (groupedReadTools.has(index))
-                    return null;
+                const item = entry.item;
                 if (item.kind === 'user') {
-                    return (_jsxs(Box, { marginTop: index === 0 ? 0 : 1, children: [_jsx(Text, { color: palette.brand, bold: true, children: screenReader ? 'You: ' : '❯ ' }), _jsx(Text, { bold: true, children: item.text })] }, index));
+                    return (_jsxs(Box, { marginTop: index === 0 ? 0 : 1, children: [_jsx(Text, { color: palette.brand, bold: true, children: screenReader ? 'You: ' : '❯ ' }), _jsx(Text, { bold: true, children: item.text })] }, entry.key));
                 }
                 if (item.kind === 'assistant') {
-                    return (_jsxs(Box, { marginTop: 1, children: [screenReader ? _jsx(Text, { children: "Praxis:" }) : null, !screenReader ? _jsx(Text, { color: palette.accent, children: "\u23FA " }) : null, _jsx(MarkdownText, { text: item.text })] }, index));
+                    return (_jsxs(Box, { marginTop: 1, children: [screenReader ? _jsx(Text, { children: "Praxis:" }) : null, !screenReader ? _jsx(Text, { color: palette.accent, children: "\u23FA " }) : null, _jsx(MarkdownText, { text: item.text })] }, entry.key));
                 }
                 if (item.kind === 'thinking') {
-                    return (_jsx(ThinkingBlock, { text: item.text, active: false, expanded: detailed, screenReader: screenReader }, index));
+                    return (_jsx(ThinkingBlock, { text: item.text, active: false, expanded: detailed, screenReader: screenReader }, entry.key));
                 }
                 if (item.kind === 'compact') {
                     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: palette.accent, italic: true, children: screenReader
                                     ? 'Conversation compacted'
-                                    : '✻ Conversation compacted (ctrl+o for history)' }), detailed ? (_jsx(Box, { marginLeft: screenReader ? 0 : 2, children: _jsx(MarkdownText, { text: item.summary }) })) : null] }, index));
+                                    : '✻ Conversation compacted (ctrl+o for history)' }), detailed ? (_jsx(Box, { marginLeft: screenReader ? 0 : 2, children: _jsx(MarkdownText, { text: item.summary }) })) : null] }, entry.key));
                 }
                 if (item.kind === 'context') {
-                    return (_jsx(ContextUsageBlock, { ...item, screenReader: screenReader }, index));
+                    return (_jsx(ContextUsageBlock, { ...item, screenReader: screenReader }, entry.key));
                 }
                 if (item.kind === 'tool') {
-                    const result = results.get(item.call.id);
-                    return (_jsx(ToolTranscriptEntry, { call: item.call, detail: item.detail, ...(result ? { result } : {}), detailed: detailed || screenReader }, index));
+                    return (_jsx(ToolTranscriptEntry, { call: item.call, detail: item.detail, ...(entry.kind === 'tool' && entry.result
+                            ? { result: entry.result }
+                            : {}), detailed: detailed || screenReader }, entry.key));
                 }
                 if (item.kind === 'tool-result') {
-                    if (pairedResults.has(item.callId))
-                        return null;
                     const text = item.text.length > 500 ? `${item.text.slice(0, 497)}...` : item.text;
-                    return (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsx(Text, { color: item.isError ? palette.error : palette.muted, children: item.isError ? '└ Error' : '└ Result' }), item.isError ? (_jsx(Text, { color: palette.error, children: text })) : (_jsx(ToolResultText, { text: text }))] }, index));
+                    return (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsx(Text, { color: item.isError ? palette.error : palette.muted, children: item.isError ? '└ Error' : '└ Result' }), item.isError ? (_jsx(Text, { color: palette.error, children: text })) : (_jsx(ToolResultText, { text: text }))] }, entry.key));
                 }
                 if (item.kind === 'shell') {
-                    const result = shellResults.get(item.callId);
+                    const result = entry.kind === 'shell' ? entry.result : undefined;
                     const output = result
                         ? [result.stdout, result.stderr]
                             .filter(Boolean)
@@ -616,18 +564,16 @@ export function Transcript({ items, activeText, activeThinking = '', activeStrea
                     const lines = contentLines(output);
                     const visible = detailed || screenReader ? lines : lines.slice(0, 3);
                     const hidden = lines.length - visible.length;
-                    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { children: _jsxs(Text, { bold: true, children: [screenReader ? 'Shell command: ' : '! ', item.command] }) }), result ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [lines.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u23BF " })) : (visible.map((line, lineIndex) => (_jsxs(Text, { ...(result.isError ? { color: palette.error } : {}), dimColor: !result.isError, children: [lineIndex === 0 ? '⎿ ' : '   ', line || ' '] }, lineIndex)))), hidden > 0 ? (_jsxs(Text, { dimColor: true, children: ['   ', "\u2026 +", hidden, " lines (ctrl+o to expand)"] })) : null] })) : null] }, index));
+                    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { children: _jsxs(Text, { bold: true, children: [screenReader ? 'Shell command: ' : '! ', item.command] }) }), result ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [lines.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u23BF " })) : (visible.map((line, lineIndex) => (_jsxs(Text, { ...(result.isError ? { color: palette.error } : {}), dimColor: !result.isError, children: [lineIndex === 0 ? '⎿ ' : '   ', line || ' '] }, lineIndex)))), hidden > 0 ? (_jsxs(Text, { dimColor: true, children: ['   ', "\u2026 +", hidden, " lines (ctrl+o to expand)"] })) : null] })) : null] }, entry.key));
                 }
                 if (item.kind === 'shell-result') {
-                    if (pairedShellResults.has(item.callId))
-                        return null;
                     const output = [item.stdout, item.stderr].filter(Boolean).join('\n');
-                    return (_jsxs(Text, { ...(item.isError ? { color: palette.error } : {}), children: ["\u23BF ", output] }, index));
+                    return (_jsxs(Text, { ...(item.isError ? { color: palette.error } : {}), children: ["\u23BF ", output] }, entry.key));
                 }
                 if (item.kind === 'local-result') {
-                    return (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u23BF ", item.text] }) }, index));
+                    return (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u23BF ", item.text] }) }, entry.key));
                 }
-                return (_jsxs(Text, { ...(item.kind === 'warning' ? { color: palette.error } : {}), dimColor: item.kind === 'notice', children: [item.kind === 'warning' ? '⚠ ' : '· ', item.text] }, index));
+                return (_jsxs(Text, { ...(item.kind === 'warning' ? { color: palette.error } : {}), dimColor: item.kind === 'notice', children: [item.kind === 'warning' ? '⚠ ' : '· ', item.text] }, entry.key));
             }), activeStreamVisible && activeThinking ? (_jsx(ThinkingBlock, { text: activeThinking, active: true, expanded: detailed, screenReader: screenReader })) : activeStreamVisible && activeText ? (_jsxs(Box, { marginTop: 1, children: [screenReader ? (_jsx(Text, { children: "Praxis: " })) : (_jsx(Text, { color: palette.accent, children: "\u2733 " })), screenReader ? (_jsx(MarkdownText, { text: activeText })) : (_jsx(ActiveStreamText, { text: activeText }))] })) : null] }));
 }
 export function DiffDashboard({ snapshots, sourceIndex, selectedIndex, viewingFile, scrollOffset, width, screenReader, }) {

package/dist/cli/tui/transcript-presentation.d.ts

@@ -0,0 +1,89 @@
+import type { ModelToolCall } from '../../core/runtime.js';
+export type TranscriptItem = {
+    kind: 'user' | 'assistant' | 'notice' | 'warning';
+    text: string;
+} | {
+    kind: 'local-result';
+    text: string;
+} | {
+    kind: 'thinking';
+    text: string;
+} | {
+    kind: 'compact';
+    summary: string;
+} | {
+    kind: 'context';
+    usedTokens: number;
+    contextWindowTokens: number;
+    model?: string;
+    skills: readonly {
+        name: string;
+        tokens: number;
+    }[];
+    memoryFiles: readonly {
+        path: string;
+        tokens: number;
+    }[];
+} | {
+    kind: 'tool';
+    call: ModelToolCall;
+    detail: string;
+} | {
+    kind: 'tool-result';
+    callId: string;
+    text: string;
+    isError: boolean;
+} | {
+    kind: 'shell';
+    callId: string;
+    command: string;
+} | {
+    kind: 'shell-result';
+    callId: string;
+    stdout: string;
+    stderr: string;
+    isError: boolean;
+};
+export type TranscriptPresentationMode = 'normal' | 'audit' | 'screen-reader';
+type ToolItem = Extract<TranscriptItem, {
+    kind: 'tool';
+}>;
+type ToolResultItem = Extract<TranscriptItem, {
+    kind: 'tool-result';
+}>;
+type ShellItem = Extract<TranscriptItem, {
+    kind: 'shell';
+}>;
+type ShellResultItem = Extract<TranscriptItem, {
+    kind: 'shell-result';
+}>;
+export type TranscriptPresentationEntry = {
+    kind: 'item';
+    key: string;
+    item: Exclude<TranscriptItem, ToolItem | ToolResultItem | ShellItem | ShellResultItem>;
+} | {
+    kind: 'tool';
+    key: string;
+    item: ToolItem;
+    result?: ToolResultItem;
+} | {
+    kind: 'orphan-tool-result';
+    key: string;
+    item: ToolResultItem;
+} | {
+    kind: 'shell';
+    key: string;
+    item: ShellItem;
+    result?: ShellResultItem;
+} | {
+    kind: 'orphan-shell-result';
+    key: string;
+    item: ShellResultItem;
+} | {
+    kind: 'read-summary';
+    key: string;
+    count: number;
+};
+export declare function projectTranscriptPresentation(items: readonly TranscriptItem[], mode: TranscriptPresentationMode): readonly TranscriptPresentationEntry[];
+export {};
+//# sourceMappingURL=transcript-presentation.d.ts.map