@timurproko/a1 0.1.8-dev.332 → 0.1.8-dev.368

package/dist/integrations/pi/components/upstream/components/session-footer.js

@@ -1,7 +1,8 @@
 /**
  * Adapted from @earendil-works/pi-coding-agent 0.84.2
  * packages/coding-agent/src/modes/interactive/components/footer.ts (MIT).
- * Modifications: consumes neutral owned-UI view data rather than a concrete AgentSession.
+ * Modifications: consumes neutral owned-UI view data rather than a concrete AgentSession;
+ * bare A1 colors the effective level-name span while the comparison profile retains pinned styling.
  */
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { truncateToWidth, visibleWidth } from "#pi-tui";
@@ -9,9 +10,11 @@ import { piTheme } from "../../theme.js";
 export class SessionFooter {
     getView;
     cwd;
-    constructor(getView, cwd) {
+    profile;
+    constructor(getView, cwd, profile = "pi") {
         this.getView = getView;
         this.cwd = cwd;
+        this.profile = profile;
     }
     invalidate() { }
     dispose() { }
@@ -60,12 +63,14 @@ export class SessionFooter {
             leftWidth = visibleWidth(left);
         }
         const modelName = view.activeModel?.modelId ?? "no-model";
-        const rightWithoutProvider = view.activeModel === null || view.thinkingLevel === "off"
-            ? modelName
-            : `${modelName} • ${view.thinkingLevel}`;
+        const rightWithoutProvider = this.profile === "a1"
+            ? view.activeModel === null ? theme.fg("dim", modelName)
+                : theme.fg("dim", `${modelName} • `) + theme.getThinkingBorderColor(view.thinkingLevel)(view.thinkingLevel)
+            : view.activeModel === null || view.thinkingLevel === "off" ? modelName : `${modelName} • ${view.thinkingLevel}`;
         let right = rightWithoutProvider;
         if ((view.status.footer?.availableProviderCount ?? 1) > 1 && view.activeModel) {
-            right = `(${view.activeModel.providerId}) ${rightWithoutProvider}`;
+            const provider = `(${view.activeModel.providerId}) `;
+            right = (this.profile === "a1" ? theme.fg("dim", provider) : provider) + rightWithoutProvider;
             if (leftWidth + 2 + visibleWidth(right) > width)
                 right = rightWithoutProvider;
         }
@@ -85,7 +90,7 @@ export class SessionFooter {
         }
         const lines = [
             truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")),
-            theme.fg("dim", left) + theme.fg("dim", line.slice(left.length)),
+            theme.fg("dim", left) + (this.profile === "a1" ? line.slice(left.length) : theme.fg("dim", line.slice(left.length))),
         ];
         const statuses = view.status.footer?.extensionStatuses ?? [];
         if (statuses.length > 0) {

package/dist/integrations/pi/components/upstream/history/editor-core.js

@@ -500,7 +500,7 @@ export class HistoryEditorCore {
         // Render top border (with scroll indicator if scrolled down)
         if (this.persistentHistory && this.historyIndex >= 0) {
             const overflow = this.scrollOffset > 0 ? ` · ↑ ${this.scrollOffset} more` : "";
-            const label = `─── History ${this.history.length - this.historyIndex}/${this.history.length}${overflow} `;
+            const label = `─── ${this.history.length - this.historyIndex}/${this.history.length}${overflow} `;
             const shown = truncateToWidth(label, width);
             const remaining = Math.max(0, width - visibleWidth(shown));
             result.push(this.borderColor(shown.slice(0, 4))

package/dist/integrations/pi/engine/adapter.d.ts

@@ -1,6 +1,6 @@
 import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
 import { type AgentSession, type AgentSessionRuntime, type AgentSessionServices, type SessionInfo } from "@earendil-works/pi-coding-agent";
-import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiImageAttachment, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../../../contracts/owned-ui/index.js";
+import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiImageAttachment, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionReasoning, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../../../contracts/owned-ui/index.js";
 import { type PiAuthenticationProviderOption, type PiBashWorkflowResult, type PiPinnedSettingsCallback, type PiPinnedSettingsSnapshot, type PiWorkflowAutocompleteCommand, type PiWorkflowHost, type PiWorkflowInteractionHost, type PiWorkflowOption, type PiWorkflowRequest, type PiWorkflowResult } from "./workflows.js";
 import { PiSettingsIntegration } from "./settings-integration.js";
 import type { PiSettingOwnerHandlers } from "./settings-effects.js";
@@ -145,6 +145,7 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
     currentSessionFile(): string | null;
     currentSessionResumeMetadata(): PiSessionResumeMetadata | null;
     get disposed(): boolean;
+    suggestionReasoningPolicy(): OwnedUiPromptSuggestionReasoning;
     generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
     start(): Promise<OwnedUiSessionViewModel>;
     onEvent(listener: (event: OwnedUiEvent) => void): () => void;

package/dist/integrations/pi/engine/adapter.js

@@ -8,8 +8,9 @@ import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../../product-identity.js";
 import { configureOwnedHttpDispatcher } from "./http-dispatcher.js";
 import { readPinnedCommandChangelog } from "./changelog.js";
+import { toolRenderingInput } from "./tool-rendering.js";
 import { copyToClipboard, CredentialSynchronizationError, DefaultPackageManager, getAgentDir, ProjectTrustStore, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
-import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiPromptSuggestionRequest, assertOwnedUiPromptSuggestionResult, assertOwnedUiSnapshot, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
+import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, acceptsTranscriptUpdate, transcriptToolState, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiPromptSuggestionRequest, assertOwnedUiPromptSuggestionResult, assertOwnedUiSnapshot, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
 import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
@@ -216,6 +217,17 @@ export class PiEngineAdapter {
     get disposed() {
         return this.#disposed;
     }
+    suggestionReasoningPolicy() {
+        const session = this.#session;
+        if (!session?.model)
+            return "unavailable";
+        if (!session.model.reasoning)
+            return "ordinary";
+        const levels = session.getAvailableThinkingLevels?.() ?? [];
+        // Compatibility: capability order, not the user's current setting or a provider-name heuristic.
+        return ["off", "minimal", "low", "medium", "high", "xhigh", "max"]
+            .find(level => levels.includes(level)) ?? "unavailable";
+    }
     async generate(request) {
         assertOwnedUiPromptSuggestionRequest(request);
         const identity = request.identity;
@@ -230,52 +242,50 @@ export class PiEngineAdapter {
             || activeModel === null
             || identity.model.providerId !== activeModel.providerId
             || identity.model.modelId !== activeModel.modelId) {
-            return { identity, text: null };
+            return { identity, outcome: request.signal.aborted ? "cancelled" : "unavailable", text: null };
         }
         const model = session.model;
         const agentState = session.agent.state;
-        if (model === undefined || typeof runtime.services.modelRuntime.completeSimple !== "function") {
-            return { identity, text: null };
+        const policy = this.suggestionReasoningPolicy();
+        if (model === undefined || policy === "unavailable" || typeof runtime.services.modelRuntime.completeSimple !== "function") {
+            return { identity, outcome: "unavailable", text: null };
         }
         const messages = agentState.messages.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
-        const reasoning = session.thinkingLevel === "minimal"
-            || session.thinkingLevel === "low"
-            || session.thinkingLevel === "medium"
-            || session.thinkingLevel === "high"
-            || session.thinkingLevel === "xhigh"
-            || session.thinkingLevel === "max"
-            ? session.thinkingLevel
-            : undefined;
-        const response = await runtime.services.modelRuntime.completeSimple(model, {
-            systemPrompt: agentState.systemPrompt,
-            messages: [
-                ...messages,
-                { role: "user", content: CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, timestamp: Date.now() },
-            ],
-            tools: agentState.tools,
-        }, {
-            signal: request.signal,
-            ...(reasoning === undefined ? {} : { reasoning }),
-        });
-        if (isRecord(response)
-            && (stringValue(response.errorMessage) !== undefined
-                || stringValue(response.stopReason) === "error"
-                || stringValue(response.stopReason) === "aborted")) {
-            const result = { identity, text: null };
-            assertOwnedUiPromptSuggestionResult(result);
-            return result;
+        const reasoning = policy === "ordinary" || policy === "off" ? undefined : policy;
+        let response;
+        try {
+            response = await runtime.services.modelRuntime.completeSimple(model, {
+                systemPrompt: agentState.systemPrompt,
+                messages: [
+                    ...messages,
+                    { role: "user", content: CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, timestamp: Date.now() },
+                ],
+                tools: agentState.tools,
+            }, {
+                signal: request.signal,
+                ...(reasoning === undefined ? {} : { reasoning }),
+            });
+        }
+        catch {
+            return { identity, outcome: request.signal.aborted ? "cancelled" : "provider-failure", text: null };
+        }
+        if (request.signal.aborted || (isRecord(response) && response.stopReason === "aborted")) {
+            return { identity, outcome: "cancelled", text: null };
+        }
+        if (!isRecord(response) || stringValue(response.errorMessage) !== undefined || response.stopReason === "error") {
+            return { identity, outcome: "provider-failure", text: null };
         }
         const content = Array.isArray(response.content) ? response.content : [];
-        if (content.some(block => isRecord(block) && block.type === "toolCall")) {
-            const result = { identity, text: null };
-            assertOwnedUiPromptSuggestionResult(result);
-            return result;
-        }
-        const textBlock = content.find(block => isRecord(block) && block.type === "text" && typeof block.text === "string");
-        const result = {
-            identity,
-            text: normalizePromptSuggestionCandidate(isRecord(textBlock) && typeof textBlock.text === "string" ? textBlock.text : null),
-        };
+        if (response.stopReason === "length" || content.some(block => isRecord(block) && block.type === "toolCall")) {
+            return { identity, outcome: "rejected", text: null };
+        }
+        // Security: validate all text, not just the first block of a multi-part response.
+        const rawText = content.filter(block => isRecord(block) && block.type === "text")
+            .map(block => stringValue(block.text) ?? "").join("\n");
+        const text = normalizePromptSuggestionCandidate(rawText);
+        const result = text === null
+            ? { identity, outcome: rawText.trim() ? "rejected" : "empty", text: null }
+            : { identity, outcome: "candidate", text };
         assertOwnedUiPromptSuggestionResult(result);
         return result;
     }
@@ -1989,6 +1999,8 @@ export class PiEngineAdapter {
         this.#reconcileActiveModelAvailability();
         this.#thinkingLevel = readThinkingLevel(session.thinkingLevel);
         this.#transcriptImageAssets.clear();
+        // Invariant: a new binding cannot inherit arguments/results from a reused invocation id.
+        this.#setTranscript([]);
         this.#rebuildTranscript(session.messages, "finalized");
         const generation = this.#sessionGeneration;
         this.#unsubscribe = session.subscribe(event => {
@@ -2119,6 +2131,7 @@ export class PiEngineAdapter {
             }
             case "message_end":
                 this.#upsertMessageBlock(event.message, "finalized");
+                this.#settleFailedDeclarations(event.message);
                 // Compatibility: preserve the same semantic boundary v2 counted. Transcript block
                 // finalization is intentionally not a substitute: rebuilds, retries,
                 // thinking parts, and tool rows can all finalize independently.
@@ -2164,13 +2177,18 @@ export class PiEngineAdapter {
             case "agent_end": {
                 if (event.type === "agent_end" && event.willRetry === true)
                     return;
-                const finalMessages = Array.isArray(event.messages) && event.messages.length > 0
-                    ? event.messages
-                    : this.#session?.messages ?? [];
-                if (finalMessages.length > 0)
+                // Protocol: agent_end is run-local; only settlement reads the complete session scope.
+                const finalMessages = event.type === "agent_settled"
+                    ? this.#session?.messages ?? []
+                    : Array.isArray(event.messages) ? event.messages : [];
+                if (event.type === "agent_end")
+                    this.#mergeRunTranscript(finalMessages);
+                else if (finalMessages.length > 0)
                     this.#rebuildTranscript(finalMessages, "finalized");
-                else
-                    this.#setTranscript(this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
+                // Invariant: missing final messages must not erase accumulated content or invent tool outcomes.
+                if (finalMessages.length === 0)
+                    this.#setTranscript(this.#transcript.map(block => block.status === "live" && transcriptToolState(block) === undefined
+                        ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
                 // Compatibility: ending a turn leaves the working state, as the recorded pinned baseline does, but
                 // it leaves only that state: a compaction or retry being shown outlives the turn
                 // that ended under it. Settlement ends the run, and with it every state — the
@@ -2286,6 +2304,29 @@ export class PiEngineAdapter {
             autoCompactEnabled: this.#runtime?.services.settingsManager?.getCompactionEnabled?.() ?? true,
         };
     }
+    // Invariant: run-local completion may restate messages, but never owns transcript membership.
+    #mergeRunTranscript(messages) {
+        const positions = new Map();
+        const sessionOccurrences = new Map();
+        for (const [index, message] of (this.#session?.messages ?? []).entries()) {
+            const key = messageFallbackKey(message, index);
+            const occurrence = sessionOccurrences.get(key) ?? 0;
+            sessionOccurrences.set(key, occurrence + 1);
+            positions.set(message, { index, occurrence });
+        }
+        const runOccurrences = new Map();
+        for (const [index, message] of messages.entries()) {
+            const key = messageFallbackKey(message, index);
+            const occurrence = runOccurrences.get(key) ?? 0;
+            runOccurrences.set(key, occurrence + 1);
+            const position = positions.get(message) ?? { index, occurrence };
+            for (const block of this.#messageBlocks(message, "finalized", position.index, position.occurrence)) {
+                this.#upsertTranscriptBlock(block);
+            }
+            this.#settleFailedDeclarations(message);
+        }
+    }
+    // Invariant: full replacement is reserved for session-authoritative scope (bind/settlement).
     #rebuildTranscript(messages, status) {
         const blocks = [];
         const blockIndexes = new Map();
@@ -2294,7 +2335,7 @@ export class PiEngineAdapter {
             const key = messageFallbackKey(message, index);
             const occurrence = occurrences.get(key) ?? 0;
             occurrences.set(key, occurrence + 1);
-            for (const block of this.#messageBlocks(message, status, index, occurrence)) {
+            for (const block of this.#messageBlocks(message, status, index, occurrence, id => blocks[blockIndexes.get(id) ?? -1] ?? this.#transcriptBlock(id))) {
                 const existingIndex = blockIndexes.get(block.id);
                 if (existingIndex === undefined) {
                     blockIndexes.set(block.id, blocks.length);
@@ -2318,7 +2359,8 @@ export class PiEngineAdapter {
         // it — otherwise every turn that ends re-renders the whole session.
         this.#setTranscript(blocks.map(block => {
             const existing = this.#transcriptBlock(block.id);
-            return existing !== undefined && sameBlockContent(existing, block) ? existing : block;
+            const next = existing === undefined ? block : retainCompletedArguments(existing, block);
+            return existing !== undefined && sameBlockContent(existing, next) ? existing : next;
         }));
     }
     #upsertMessageBlock(message, status) {
@@ -2328,7 +2370,7 @@ export class PiEngineAdapter {
             this.#upsertTranscriptBlock(block);
         return first;
     }
-    #messageBlocks(message, status, fallbackIndex, occurrence) {
+    #messageBlocks(message, status, fallbackIndex, occurrence, currentBlock = id => this.#transcriptBlock(id)) {
         if (!isRecord(message) || typeof message.role !== "string")
             return [];
         const baseId = this.#messageBlockId(message, fallbackIndex, status, occurrence);
@@ -2409,25 +2451,24 @@ export class PiEngineAdapter {
                 : this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
             if (toolCallId !== undefined)
                 this.#toolBlockIds.set(toolCallId, blockId);
-            const existing = this.#transcriptBlock(blockId);
+            const existing = currentBlock(blockId);
             const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
+            const payload = {
+                role: "toolResult", toolCallId: toolCallId ?? null,
+                toolName: stringValue(message.toolName) ?? stringValue(existingPayload?.toolName) ?? "unknown",
+                argsComplete: true, partialResult: status === "live", isError: message.isError === true,
+            };
+            const rendering = toolRenderingInput({ args: undefined, previousArgs: existing?.toolRendering,
+                result: message, payload, image: part => this.#imageReferences([part], "tool-result")[0] });
             return [{
                     id: blockId,
                     kind: "tool-result",
                     status,
+                    toolState: { argsComplete: true, execution: status === "live" ? "running" : message.isError === true ? "failed" : "succeeded" },
                     revision: this.#nextBlockRevision(blockId),
                     title: stringValue(message.toolName) ?? existing?.title ?? "Tool result",
-                    text: textFromContent(message.content),
-                    imageReferences: this.#imageReferences(message.content, "tool-result"),
-                    payload: {
-                        ...(existingPayload ?? {}),
-                        role: "toolResult",
-                        toolCallId: toolCallId ?? null,
-                        toolName: stringValue(message.toolName) ?? stringValue(existingPayload?.toolName) ?? "unknown",
-                        argsComplete: true,
-                        isError: message.isError === true,
-                        details: jsonSummary(message.details),
-                    },
+                    ...rendering,
+                    payload,
                 }];
         }
         if (message.role !== "assistant" || !Array.isArray(message.content))
@@ -2457,23 +2498,61 @@ export class PiEngineAdapter {
             const toolCallId = stringValue(item.id) ?? `${baseId}:${blocks.length}`;
             const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
             this.#toolBlockIds.set(toolCallId, blockId);
+            const failure = status === "finalized" ? this.#declarationFailure(message) : undefined;
+            const payload = { toolCallId, toolName: stringValue(item.name) ?? "unknown",
+                argsComplete: failure === undefined && status === "finalized",
+                ...(failure === undefined ? {} : { isError: true }) };
+            const rendering = toolRenderingInput({ args: item.arguments, payload,
+                ...(failure === undefined ? {} : { result: { content: [{ type: "text", text: failure.text }] } }),
+                image: () => undefined });
             blocks.push({
                 id: blockId,
-                kind: "tool-call",
-                status,
+                kind: failure === undefined ? "tool-call" : "tool-result",
+                status: failure === undefined ? "live" : "finalized",
+                toolState: {
+                    argsComplete: failure === undefined && status === "finalized",
+                    execution: failure?.execution ?? "pending",
+                },
                 revision: this.#nextBlockRevision(blockId),
                 title: stringValue(item.name) ?? "Tool",
-                text: jsonSummary(item.arguments).summary,
-                payload: {
-                    toolCallId,
-                    toolName: stringValue(item.name) ?? "unknown",
-                    arguments: jsonSummary(item.arguments),
-                    argsComplete: status === "finalized",
-                },
+                ...rendering,
+                text: failure?.text ?? jsonSummary(item.arguments).summary,
+                payload,
             });
         }
         return blocks;
     }
+    #declarationFailure(message) {
+        // Provenance: pinned interactive-mode message_end and history reconstruction settle pending tools.
+        if (message.role !== "assistant")
+            return undefined;
+        if (message.stopReason === "aborted") {
+            const attempts = this.#session?.retryAttempt ?? 0;
+            return { execution: "aborted", text: attempts > 0
+                    ? `Aborted after ${attempts} retry attempt${attempts > 1 ? "s" : ""}` : "Operation aborted" };
+        }
+        return message.stopReason === "error"
+            ? { execution: "failed", text: stringValue(message.errorMessage) || "Error" } : undefined;
+    }
+    #settleFailedDeclarations(message) {
+        if (!isRecord(message))
+            return;
+        const failure = this.#declarationFailure(message);
+        if (failure === undefined)
+            return;
+        for (const block of this.#transcript) {
+            const state = transcriptToolState(block);
+            if (state === undefined || state.execution !== "pending" && state.execution !== "running")
+                continue;
+            const payload = { ...(isRecord(block.payload) ? block.payload : {}), partialResult: false, isError: true };
+            this.#upsertTranscriptBlock({
+                ...block, kind: "tool-result", status: "finalized", revision: block.revision + 1,
+                ...toolRenderingInput({ args: undefined, previousArgs: block.toolRendering, payload,
+                    result: { content: [{ type: "text", text: failure.text }] }, image: () => undefined }),
+                toolState: { ...state, execution: failure.execution }, payload,
+            });
+        }
+    }
     #imageReferences(content, source) {
         if (!Array.isArray(content))
             return [];
@@ -2499,34 +2578,37 @@ export class PiEngineAdapter {
         const blockId = this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
         this.#toolBlockIds.set(toolCallId, blockId);
         const ended = event.type === "tool_execution_end";
+        const existing = this.#transcriptBlock(blockId);
+        const state = existing === undefined ? undefined : transcriptToolState(existing);
+        // Invariant: duplicate starts cannot blank accumulated output; late events cannot reopen a settled invocation.
+        if (state !== undefined && (state.execution !== "pending" && state.execution !== "running"
+            || event.type === "tool_execution_start" && state.execution === "running"))
+            return;
         const source = ended ? event.result : event.partialResult;
+        const payload = { toolCallId, toolName: stringValue(event.toolName) ?? "unknown",
+            partialResult: event.type === "tool_execution_update", argsComplete: true, isError: event.isError === true };
+        const rendering = toolRenderingInput({ args: event.args, previousArgs: existing?.toolRendering, result: source,
+            payload, image: part => this.#imageReferences([part], "tool-result")[0] });
         this.#upsertTranscriptBlock({
             id: blockId,
             kind: ended ? "tool-result" : "tool-call",
             status: ended ? "finalized" : "live",
+            toolState: { argsComplete: true, execution: ended ? event.isError === true ? "failed" : "succeeded" : "running" },
             revision: this.#nextBlockRevision(blockId),
             title: stringValue(event.toolName) ?? "Tool",
-            text: textFromContent(isRecord(source) ? source.content : source),
-            payload: {
-                toolCallId,
-                toolName: stringValue(event.toolName) ?? "unknown",
-                arguments: jsonSummary(event.args),
-                // Performance: a partial result repeats the whole accumulated output on every chunk;
-                // summarizing it each time would cost quadratic work over the stream.
-                result: ended ? jsonSummary(source) : { summary: "", json: null },
-                partialResult: event.type === "tool_execution_update",
-                argsComplete: ended,
-                isError: event.isError === true,
-            },
+            ...rendering,
+            payload,
         });
     }
     #upsertTranscriptBlock(block) {
         const index = this.#transcriptIndex.get(block.id);
         if (index !== undefined) {
             const existing = this.#transcript[index];
-            // Invariant: an obsolete partial cannot revive finalized content after a completion barrier.
-            if (existing?.status === "finalized" && block.status === "live")
+            // Invariant: argument completion is not execution finality; stale phases still stay rejected.
+            if (existing !== undefined && !acceptsTranscriptUpdate(existing, block))
                 return;
+            if (existing !== undefined)
+                block = retainCompletedArguments(existing, block);
             // Performance: nothing is emitted for a block that repeats itself, and keeping the
             // revision keeps the rows it already rendered.
             if (existing !== undefined && sameBlockContent(existing, block))
@@ -2676,6 +2758,9 @@ export class PiEngineAdapter {
         this.#lifecycle = this.#disposed ? "stopped" : canResume ? "ready" : "failed";
         this.#editor = { ...this.#editor, submitEnabled: canResume && !this.#disposed };
         this.#viewRevision += 1;
+        // Invariant: overload publishes one authoritative view; settle tool phases before finalizing other live blocks.
+        this.#settleFailedDeclarations({ role: "assistant", stopReason: cancelled ? "aborted" : "error",
+            errorMessage: "Tool result unavailable after UI delivery overload" });
         this.#setTranscript(this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized", revision: block.revision + 1 } : block));
         for (const [correlationId, result] of this.#reservedOutcomes) {
             this.#deliver(this.#event({ type: "command-outcome", correlationId, ...result }));
@@ -3224,6 +3309,16 @@ function compactResourceLabel(path) {
     const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
     return segments.at(-1) ?? path;
 }
+/** A later error may restate a declaration, but cannot make completed arguments incomplete. */
+function retainCompletedArguments(current, next) {
+    if (current.toolState?.argsComplete !== true || next.toolState === undefined || next.toolState.argsComplete)
+        return next;
+    return { ...next, toolState: { ...next.toolState, argsComplete: true },
+        ...(next.toolRendering === undefined || current.toolRendering === undefined ? {} : {
+            toolRendering: { ...next.toolRendering, arguments: current.toolRendering.arguments },
+        }),
+        payload: { ...(isRecord(next.payload) ? next.payload : {}), argsComplete: true } };
+}
 /**
  * Whether two blocks say the same thing. A block that says what it already said is not a
  * new revision: the shell renders a block once per revision, so bumping one it did not
@@ -3234,6 +3329,8 @@ function sameBlockContent(left, right) {
         && left.status === right.status
         && left.title === right.title
         && left.text === right.text
+        && sameValue(left.toolState, right.toolState)
+        && sameValue(left.toolRendering, right.toolRendering)
         && sameValue(left.payload, right.payload)
         && sameValue(left.imageReferences ?? [], right.imageReferences ?? []);
 }

package/dist/integrations/pi/engine/tool-rendering.d.ts

@@ -0,0 +1,13 @@
+import type { OwnedUiToolRendering, OwnedUiTranscriptImageReference } from "../../../contracts/owned-ui/index.js";
+/** Text lives once on the block; content parts refer to UTF-16 slices or opaque image references. */
+export declare function toolRenderingInput(options: {
+    readonly args: unknown;
+    readonly previousArgs?: OwnedUiToolRendering | undefined;
+    readonly result?: unknown;
+    readonly payload: Record<string, unknown>;
+    readonly image: (value: unknown) => OwnedUiTranscriptImageReference | undefined;
+}): {
+    text: string;
+    toolRendering: OwnedUiToolRendering;
+    imageReferences: readonly OwnedUiTranscriptImageReference[];
+};

package/dist/integrations/pi/engine/tool-rendering.js

@@ -0,0 +1,122 @@
+const MAX_METADATA_BYTES = 64 * 1024;
+/** Copy JSON metadata without diagnostic depth/array truncation or traversing result text/images. */
+function renderingJson(value) {
+    let remaining = MAX_METADATA_BYTES;
+    const encoded = JSON.stringify(value, function (key, item) {
+        if (key && !Array.isArray(this))
+            remaining -= jsonStringBytes(key) + 1;
+        if (typeof item === "string")
+            remaining -= jsonStringBytes(item);
+        else if (item === null || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) {
+            remaining -= String(item).length;
+        }
+        else if (typeof item === "object")
+            remaining -= 2;
+        else if (item === undefined)
+            return item;
+        else
+            throw new TypeError("unsupported JSON metadata");
+        if (--remaining < 0)
+            throw new RangeError("metadata exceeds the supported payload limit");
+        return item;
+    });
+    if (encoded === undefined)
+        throw new TypeError("unsupported JSON metadata");
+    if (Buffer.byteLength(encoded) > MAX_METADATA_BYTES)
+        throw new RangeError("metadata exceeds the supported payload limit");
+    return JSON.parse(encoded);
+}
+function jsonStringBytes(value) {
+    // Performance: reject very large strings before allocating their escaped representation.
+    if (value.length > MAX_METADATA_BYTES)
+        throw new RangeError("metadata exceeds the supported payload limit");
+    return Buffer.byteLength(JSON.stringify(value));
+}
+/** Text lives once on the block; content parts refer to UTF-16 slices or opaque image references. */
+export function toolRenderingInput(options) {
+    const warnings = new Set();
+    let args = {};
+    try {
+        args = options.args === undefined && options.previousArgs !== undefined
+            ? options.previousArgs.arguments : renderingJson(options.args ?? {});
+        if (options.args === undefined && options.previousArgs?.unavailable?.includes("Tool arguments unavailable")) {
+            warnings.add("Tool arguments unavailable: unsupported or oversized rendering data.");
+        }
+    }
+    catch {
+        warnings.add("Tool arguments unavailable: unsupported or oversized rendering data.");
+    }
+    const imageReferences = [];
+    const content = [];
+    const texts = [];
+    let length = 0;
+    const source = isRecord(options.result) ? options.result : undefined;
+    const rawContent = source === undefined ? options.result : source.content;
+    const parts = typeof rawContent === "string" ? [{ type: "text", text: rawContent }] : rawContent;
+    if (Array.isArray(parts)) {
+        for (const part of parts) {
+            if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+                if (texts.length > 0)
+                    length++;
+                const start = length;
+                texts.push(part.text);
+                length += part.text.length;
+                content.push({ type: "text", start, end: length });
+            }
+            else if (isRecord(part) && part.type === "image") {
+                const reference = imageReferences.length < 16 ? options.image(part) : undefined;
+                if (reference === undefined)
+                    warnings.add("Image unavailable: unsupported data or attachment limit exceeded.");
+                else {
+                    content.push({ type: "image", imageIndex: imageReferences.length });
+                    imageReferences.push(reference);
+                }
+            }
+            else
+                warnings.add("Tool content unavailable: unsupported content part.");
+        }
+    }
+    else if (options.result !== undefined)
+        warnings.add("Tool content unavailable: malformed result.");
+    let details;
+    if (source?.details !== undefined) {
+        try {
+            details = renderingJson(source.details);
+        }
+        catch {
+            warnings.add("Tool details unavailable: unsupported or oversized rendering data.");
+        }
+    }
+    const text = texts.join("\n");
+    let toolRendering = {
+        arguments: args,
+        ...(options.result === undefined ? {} : { result: { content, ...(details === undefined ? {} : { details }) } }),
+    };
+    const warning = () => [...warnings].join(" ");
+    const fits = () => Buffer.byteLength(JSON.stringify({ payload: options.payload, toolRendering: {
+            ...toolRendering, ...(warnings.size === 0 ? {} : { unavailable: warning() }),
+        } })) <= MAX_METADATA_BYTES;
+    if (!fits()) {
+        warnings.add("Tool details unavailable: rendering metadata exceeds the supported payload limit.");
+        if (toolRendering.result)
+            toolRendering = { ...toolRendering, result: { content } };
+    }
+    if (!fits()) {
+        warnings.add("Tool arguments unavailable: rendering metadata exceeds the supported payload limit.");
+        toolRendering = { ...toolRendering, arguments: {} };
+    }
+    if (!fits()) {
+        // Rationale: too many content boundaries exceed the metadata budget; retain text/images with an explicit fallback.
+        warnings.add("Tool content boundaries unavailable: rendering metadata exceeds the supported payload limit.");
+        toolRendering = { ...toolRendering, result: { content: [
+                    { type: "text", start: 0, end: text.length },
+                    ...imageReferences.map((_, imageIndex) => ({ type: "image", imageIndex })),
+                ] } };
+    }
+    if (warnings.size > 0)
+        toolRendering = { ...toolRendering, unavailable: warning() };
+    return { text, toolRendering, imageReferences };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}