@evandu/super-pi 0.1.27 → 0.1.29

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-BNxHYUah.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B5pyabQ_.css">
+    <script type="module" crossorigin src="/assets/index-_xNokuGH.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DoUhMucG.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/application/conversation-service.d.ts

@@ -36,6 +36,13 @@ export declare class ConversationService {
      * Creates a new conversation in a workspace.
      */
     createConversation(workspaceId: string): Promise<string>;
+    /**
+     * Name a conversation from what was said in it. Returns the title; the CALLER applies it, because the
+     * rename is a second command with its own optimistic path and its own failure toast, and a service that
+     * renamed as a side effect of being asked for a name would make those two outcomes indistinguishable in
+     * a log and in a retry.
+     */
+    autoRenameConversation(conversationId: string): Promise<string>;
     /**
      * Selects a conversation and broadcasts the catalog for that conversation's model.
      */

package/dist/server/application/conversation-service.js

@@ -42,6 +42,24 @@ export class ConversationService {
         this.broadcaster.broadcastState();
         return created.id;
     }
+    /**
+     * Name a conversation from what was said in it. Returns the title; the CALLER applies it, because the
+     * rename is a second command with its own optimistic path and its own failure toast, and a service that
+     * renamed as a side effect of being asked for a name would make those two outcomes indistinguishable in
+     * a log and in a retry.
+     */
+    async autoRenameConversation(conversationId) {
+        const state = this.store.snapshot();
+        const conversation = state.conversations.find(item => item.id === conversationId);
+        if (!conversation)
+            throw new Error("会话不存在");
+        const workspace = state.workspaces.find(item => item.id === conversation.workspaceId);
+        if (!workspace)
+            throw new Error("会话所属的工作区不存在");
+        if (!this.runtime.summarizeConversation)
+            throw new Error("当前没有可用的 Pi 进程，无法生成标题");
+        return this.runtime.summarizeConversation(conversation, workspace.path);
+    }
     /**
      * Selects a conversation and broadcasts the catalog for that conversation's model.
      */

package/dist/server/application/run-service.js

@@ -172,11 +172,17 @@ export class RunService {
             const at = spoken;
             enqueueTools("a tool call", () => this.store.appendToolCall(conversation.id, assistant.id, { label: call.name, detail: call.detail, args: call.args, at }));
         };
+        const onToolUpdate = (call) => {
+            const index = call.id ? rowByToolCallId.get(call.id) : undefined;
+            if (index === undefined)
+                return;
+            enqueueTools("a tool call update", () => this.store.updateToolCall(conversation.id, assistant.id, index, { ...(call.args ? { args: call.args } : {}), ...(call.live !== undefined ? { live: call.live } : {}) }));
+        };
         const onToolEnd = (call) => {
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
             if (index === undefined)
                 return;
-            enqueueTools("a tool call outcome", () => this.store.settleToolCall(conversation.id, assistant.id, index, { status: call.status, durationMs: call.durationMs }));
+            enqueueTools("a tool call outcome", () => this.store.settleToolCall(conversation.id, assistant.id, index, { status: call.status, durationMs: call.durationMs, ...(call.result ? { result: call.result } : {}) }));
         };
         for await (const delta of this.runtime.answer({
             conversation,
@@ -187,6 +193,7 @@ export class RunService {
             onPiQueue: (snapshot) => this.onPiQueue(conversation.id, snapshot),
             onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
             onToolCall,
+            onToolUpdate,
             onToolEnd,
             images,
         })) {

package/dist/server/command-handler.js

@@ -66,6 +66,20 @@ export class CommandHandler {
         if (command.type === "conversation.create") {
             return await this.conversationService.createConversation(command.workspaceId);
         }
+        if (command.type === "conversation.autoRename") {
+            // Answered on a pushed event rather than through the return value: this spends real model time, and
+            // `handleCommand`'s return only carries an id for the optimistic-ack path. Swallowing the failure
+            // here would turn a model timeout into a menu that closed and never spoke again, so the error goes
+            // back on the same channel the success would have used.
+            try {
+                const title = await this.conversationService.autoRenameConversation(command.conversationId);
+                sendToSocket?.({ type: "conversation.autoRename.result", conversationId: command.conversationId, ok: true, title });
+            }
+            catch (error) {
+                sendToSocket?.({ type: "conversation.autoRename.result", conversationId: command.conversationId, ok: false, error: error instanceof Error ? error.message : String(error) });
+            }
+            return;
+        }
         if (command.type === "conversation.select") {
             if (sendToSocket) {
                 try {

package/dist/server/runtime.d.ts

@@ -83,6 +83,13 @@ export interface AnswerInput {
      * place a reader would reach for it.
      */
     onToolEnd?(call: ToolCallNotice): void;
+    /**
+     * Called on every tool_execution_update - which is DURING execution, and repeatedly. The companion to
+     * onToolCall and onToolEnd rather than a third thing: without it the entire span between a call being
+     * announced and a call being reported is silent, and a long-running call is on screen indistinguishable
+     * from a frozen agent.
+     */
+    onToolUpdate?(call: ToolCallNotice): void;
 }
 /**
  * What Pi answered when a `steer` was written to it, from the `disposition` of that command's response
@@ -170,6 +177,23 @@ export interface AgentRuntime {
      * Absent on a runtime with no Pi behind it (the welcome runtime), which has nothing to steer.
      */
     steer?(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
+    /**
+     * ONE-SHOT TITLE GENERATION. Spawns its own short-lived Pi child rather than borrowing a running one.
+     *
+     * WHY ITS OWN CHILD. `this.runs` only holds a child while a turn is executing, and that child is the
+     * one reading the user's stream - writing a prompt at it would land in the conversation it is streaming,
+     * and killing it to make room would abort a run the user is watching. So this gets a separate process
+     * with its own throwaway session id, which is the only way to ask the model something without touching
+     * the run in flight.
+     *
+     * WHY IT THROWS RATHER THAN FALLS BACK. An earlier version returned `transcript.slice(0, 60)`, which
+     * renamed a conversation to a fragment of its own first message while reporting success. A title the
+     * user did not write, produced by string slicing, must never reach `conversation.rename`. Every failure
+     * here is an exception the caller reports as one.
+     *
+     * Absent on the welcome runtime, which has no Pi behind it.
+     */
+    summarizeConversation?(conversation: Conversation, cwd: string, signal?: AbortSignal): Promise<string>;
     /**
      * The agent a conversation runs as, read fresh from the agent directory. Absent on a runtime with
      * no agents (the welcome runtime), where every conversation runs as Pi itself. Callers that need an
@@ -234,6 +258,14 @@ export type RpcRecord = {
     error?: string;
     /** Every `response` record's payload. Kept opaque: only the catalog reader knows these shapes. */
     data?: unknown;
+    /**
+     * `tool_execution_end` carries the tool's OUTPUT. Declared so it can be REDUCED by
+     * extractToolResultText and then dropped: the raw object must never travel past this record, and that
+     * reduction is the whole reason the result is safe to persist. Kept opaque for the same reason `data` is.
+     */
+    result?: unknown;
+    /** The tool_execution_update record's running output. Reduced by the same function as `result`, never carried raw. */
+    partialResult?: unknown;
     /**
      * The inner event of a `message_update`. `message` rides on `done` - the authoritative final
      * assistant message, with its text content, its stop reason and its model (pi-ai AssistantMessageEvent).
@@ -664,7 +696,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * own address, so it is the same string on every turn and is read once from the constructor's options.
      */
     private taskExtensionEnv;
-    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolEnd, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
+    answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolEnd, images, memoryReview, memorySourceConversationId }: AnswerInput): AsyncIterable<string>;
     /**
      * Reads back the id of the user message this turn just created, and hands it to the caller.
      *
@@ -790,6 +822,7 @@ export declare class PiRpcRuntime implements AgentRuntime {
      * time. The caller keeps the message cancellable in the first case because it provably reached no
      * model; in the second the outcome is genuinely unknown and a `sending` state says so.
      */
+    summarizeConversation(conversation: Conversation, cwd: string, signal?: AbortSignal): Promise<string>;
     steer(conversationId: string, message: string, images?: MessageImage[]): Promise<SteerDisposition>;
     /**
      * The model/thinking catalog, from Pi, cached.

package/dist/server/runtime.js

@@ -8,7 +8,7 @@ import { resolvePiCommand, shellQuote } from "./pi-command.js";
 import { TASK_CONVERSATION_ENV, TASK_DEPTH_ENV, TASK_ENDPOINT_ENV, TASK_ROSTER_ENV, TASK_TOOL_NAME, TODO_ENDPOINT_ENV, TODO_TOOL_NAME, WORKFLOW_ENDPOINT_ENV, WORKFLOW_TOOL_NAME, rosterPayload, } from "./task-tool.js";
 import { BLOCKING_UI_METHODS, EXTENSION_UI_METHODS, } from "./types.js";
 import { loadConversationImages } from "./upload.js";
-import { describeToolCall, describeToolCallArgs } from "./tool-calls.js";
+import { describeToolCall, describeToolCallArgs, extractToolResultText } from "./tool-calls.js";
 /** Deterministic offline runtime used by tests and local UI development. */
 export class WelcomeRuntime {
     async *answer({ prompt, signal }) {
@@ -700,7 +700,7 @@ export class PiRpcRuntime {
             [TASK_CAPABILITY_ENV]: mintCapability(conversationId),
         };
     }
-    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolEnd, images, memoryReview, memorySourceConversationId }) {
+    async *answer({ conversation, prompt, signal, cwd, host, onPiQueue, onUserEntry, onToolCall, onToolUpdate, onToolEnd, images, memoryReview, memorySourceConversationId }) {
         await mkdir(this.sessionDir, { recursive: true });
         // Normalize first: the picker can hand over forward slashes or a trailing separator, and `resolve`
         // turns both into one absolute native path. The directory must exist on disk before spawn - a
@@ -886,6 +886,33 @@ export class PiRpcRuntime {
                     // `message_update` events below: a `thinking_delta` still announces itself, because that is a
                     // documented decision about an event shape rather than an oversight this branch is here to
                     // repair. Only the two tool records move.
+                    if (record.type === "tool_execution_update") {
+                        // THE THIRD TOOL RECORD, AND THE ONE THAT WAS MISSING.
+                        //
+                        // `tool_execution_start` announces a call and `tool_execution_end` reports how it went, which
+                        // left the whole span between them silent. For a `bash` that runs a minute or an `edit` whose
+                        // replacement text is large, that span is the entire execution, and the block sat there with
+                        // no status, no output and nothing changing - which on screen is indistinguishable from a
+                        // frozen agent. Pi has been sending this record the whole time, with the arguments as they
+                        // stand and whatever output has arrived so far.
+                        //
+                        // It updates the EXISTING row rather than announcing a new one, so `args` is re-derived on
+                        // every update (it grows as a tool is prepared) and `live` carries the running output. The
+                        // reduction is the same one the final result goes through, so a preview can never be bigger
+                        // than the answer it precedes.
+                        const id = record.toolCallId ?? "";
+                        if (id) {
+                            const name = record.toolName ?? "unknown";
+                            const live = extractToolResultText(record.partialResult)?.text;
+                            try {
+                                onToolUpdate?.({ id, name, detail: describeToolCall(name, record.args), args: describeToolCallArgs(record.args), ...(live ? { live } : {}) });
+                            }
+                            catch (error) {
+                                console.warn(`PiRpcRuntime: the tool update handler threw: ${error instanceof Error ? error.message : "unknown error"}`);
+                            }
+                        }
+                        continue;
+                    }
                     if (record.type === "tool_execution_start") {
                         // The `args` are READ and summarised, never carried: `describeToolCallArgs` turns an
                         // arbitrary object into at most six capped strings and a non-string becomes a bare type
@@ -913,6 +940,9 @@ export class PiRpcRuntime {
                                 id: record.toolCallId ?? "",
                                 name: record.toolName ?? "unknown",
                                 status: record.isError === true ? "error" : "ok",
+                                // Reduced ONCE, here, and the raw record.result is dropped here. Anything that reaches a
+                                // store from this point is the bounded summary, never what Pi sent.
+                                ...(() => { const summary = extractToolResultText(record.result); return summary ? { result: summary } : {}; })(),
                                 ...(typeof record.durationMs === "number" && Number.isFinite(record.durationMs) ? { durationMs: Math.max(0, Math.round(record.durationMs)) } : {}),
                             });
                         }
@@ -1322,6 +1352,76 @@ export class PiRpcRuntime {
      * time. The caller keeps the message cancellable in the first case because it provably reached no
      * model; in the second the outcome is genuinely unknown and a `sending` state says so.
      */
+    async summarizeConversation(conversation, cwd, signal) {
+        if (!this.pi.found)
+            throw new Error(this.pi.reason);
+        const TIMEOUT_MS = 30_000;
+        const MAX_TITLE_CHARS = 40;
+        // A throwaway session id, not the conversation's: this child reads nothing else and its history must
+        // not be filed under the conversation whose title it is producing.
+        const child = spawn(shellQuote(this.pi.command), ["--mode", "rpc", "--session-dir", this.sessionDir, "--session-id", `autotitle-${Date.now()}`], {
+            cwd: resolve(cwd),
+            stdio: ["pipe", "pipe", "pipe"],
+            shell: process.platform === "win32",
+        });
+        const channel = new RpcChannel(child);
+        const deadline = Date.now() + TIMEOUT_MS;
+        try {
+            const transcript = conversation.messages
+                .filter((message) => (message.role === "user" || message.role === "assistant") && message.content.trim())
+                .map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.content.trim()}`)
+                .join("\n");
+            if (!transcript)
+                throw new Error("这个会话还没有内容，无法据此生成标题");
+            channel.write({
+                id: "autotitle_prompt",
+                type: "prompt",
+                message: [
+                    "为下面这段对话起一个简短的标题,用作会话列表里的一行字。",
+                    "只输出标题本身:不要引号,不要句末标点,不要「标题:」之类的前缀,不要解释,不要换行。",
+                    `长度不超过 ${MAX_TITLE_CHARS} 个字符,用与对话内容相同的语言。`,
+                    "",
+                    transcript,
+                ].join("\n"),
+            });
+            let settled = false, text = "";
+            while (!settled && Date.now() < deadline) {
+                if (signal?.aborted)
+                    throw new Error("已取消");
+                const record = await channel.next(100);
+                if (!record)
+                    continue;
+                if (record.type === "message_update" && record.assistantMessageEvent?.type === "text_delta")
+                    text += record.assistantMessageEvent.delta ?? "";
+                if (record.type === "agent_settled")
+                    settled = true;
+                if (record.type === "response" && record.id === "autotitle_prompt" && record.success === false)
+                    throw new Error(record.error ?? "Pi 拒绝了这次请求");
+                if (child.exitCode !== null)
+                    throw new Error("生成标题的进程意外退出");
+            }
+            if (!settled)
+                throw new Error(`模型在 ${TIMEOUT_MS / 1000} 秒内没有返回标题`);
+            // A model asked for "only the title" still wraps it now and then. Stripping the wrappers is not
+            // cosmetic: without it a leading quote or a `Title:` prefix becomes the first characters of every
+            // title in the sidebar.
+            const title = text
+                .replace(/^\s*(?:title|标题)\s*[:：]\s*/iu, "")
+                .replace(/^[`"'“”‘’「『]+/u, "")
+                .replace(/[`"'“”‘’」』]+$/u, "")
+                .replace(/[。.！!，,、;；\s]+$/u, "")
+                .trim()
+                .slice(0, MAX_TITLE_CHARS);
+            if (!title)
+                throw new Error("模型没有返回可用的标题");
+            return title;
+        }
+        finally {
+            // The child is this method's alone, so leaving it running would leak one Pi process per rename.
+            if (child.exitCode === null && child.pid !== undefined)
+                await killTree(child.pid);
+        }
+    }
     async steer(conversationId, message, images) {
         const run = this.runs.get(conversationId);
         if (!run)

package/dist/server/store.d.ts

@@ -1,7 +1,7 @@
 import type { AppStateRepository } from "./persistence/app-state-repository.js";
 import { defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import type { WorkflowRun } from "./workflow.js";
-import type { AppState, Conversation, Message, MessageImage, ModelSelection, QueuedMessage, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallBlock, Workspace } from "./types.js";
+import type { AppState, Conversation, Message, MessageImage, ModelSelection, QueuedMessage, SubagentRun, SubagentRunUpdate, TodoItem, ToolCallArg, ToolCallBlock, ToolResultSummary, Workspace } from "./types.js";
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
  *
  *  Exported because the ordering demands it and no other arrangement provides it. Pi's copied file's header
@@ -252,6 +252,20 @@ export declare class Store {
     settleToolCall(conversationId: string, messageId: string, index: number, outcome: {
         status?: "ok" | "error";
         durationMs?: number;
+        result?: ToolResultSummary;
+    }): Promise<ToolCallBlock[]>;
+    /**
+     * REWRITE A CALL THAT IS STILL RUNNING - its arguments as they have grown, and whatever output has
+     * arrived so far. Separate from `settleToolCall` because "settle" is the wrong word for a turn that is
+     * still going: nothing here decides an outcome, and a method that could be mistaken for it is one a
+     * future caller reaches for by mistake.
+     *
+     * Every field is `undefined`-tested for the same reason `settleToolCall` does it: `""` and `[]` are
+     * values a tool can genuinely produce, and treating them as "not reported" would erase a real answer.
+     */
+    updateToolCall(conversationId: string, messageId: string, index: number, patch: {
+        args?: ToolCallArg[];
+        live?: string;
     }): Promise<ToolCallBlock[]>;
     setStatus(conversationId: string, status: Conversation["status"]): Promise<void>;
     /** The plan a revert would carry out, without carrying it out. The server reads this to stop children first. */

package/dist/server/store.js

@@ -1,5 +1,6 @@
 import { JsonStateRepository, defaultJsonStatePath } from "./persistence/json-state-repository.js";
 import { normalizeTodos } from "./task-tool.js";
+import { TOOL_ARG_CAP } from "./tool-calls.js";
 function id(prefix) { return `${prefix}_${crypto.randomUUID()}`; }
 /** Mints the id a forked conversation will have, BEFORE its Pi transcript exists.
  *
@@ -910,6 +911,50 @@ export class Store {
             call.status = outcome.status;
         if (outcome.durationMs !== undefined)
             call.durationMs = outcome.durationMs;
+        // `!== undefined`, never a truthiness test: an absent result means "this call's output was never
+        // recorded", which is a different fact from "recorded, and it was empty", and `""` would state the
+        // second while meaning the first.
+        if (outcome.result !== undefined)
+            call.result = outcome.result;
+        // The finished answer REPLACES the running preview, and does not sit beside it. A block showing both
+        // would be asking the reader to work out which of two texts is the real one.
+        if (outcome.result !== undefined)
+            delete call.live;
+        conversation.updatedAt = now();
+        await this.persist();
+        return structuredClone(calls);
+    }
+    /**
+     * REWRITE A CALL THAT IS STILL RUNNING - its arguments as they have grown, and whatever output has
+     * arrived so far. Separate from `settleToolCall` because "settle" is the wrong word for a turn that is
+     * still going: nothing here decides an outcome, and a method that could be mistaken for it is one a
+     * future caller reaches for by mistake.
+     *
+     * Every field is `undefined`-tested for the same reason `settleToolCall` does it: `""` and `[]` are
+     * values a tool can genuinely produce, and treating them as "not reported" would erase a real answer.
+     */
+    async updateToolCall(conversationId, messageId, index, patch) {
+        const conversation = this.requireConversation(conversationId);
+        const message = conversation.messages.find((item) => item.id === messageId);
+        if (!message)
+            throw new Error("Assistant message not found");
+        const calls = message.toolCalls;
+        const call = calls?.[index];
+        if (!calls || !call)
+            return structuredClone(calls ?? []);
+        // MERGED BY KEY, NOT REPLACED. An update carries the arguments as they stand at that moment, and while a
+        // call is being prepared that list GROWS - one key, then two, then six. Replacing the row's list with
+        // whatever the latest update happened to carry loses every key the update left out, which on the very
+        // first update is all of them. Merging can only ever add, so a sparse update can no longer erase what
+        // an earlier one already reported - and the cap is re-applied here rather than trusted from outside.
+        if (patch.args !== undefined) {
+            const merged = new Map((call.args ?? []).map((arg) => [arg.key, arg]));
+            for (const arg of patch.args)
+                merged.set(arg.key, arg);
+            call.args = [...merged.values()].slice(0, TOOL_ARG_CAP);
+        }
+        if (patch.live !== undefined)
+            call.live = patch.live;
         conversation.updatedAt = now();
         await this.persist();
         return structuredClone(calls);

package/dist/server/tool-calls.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCallArg } from "./types.js";
+import type { ToolCallArg, ToolResultSummary } from "./types.js";
 /**
  * Turning one Pi tool call into something a human reads, and nothing more.
  *
@@ -28,6 +28,29 @@ export declare const TOOL_DETAIL_CAP = 120;
  * past it is announced by the caller through the row count rather than silently.
  */
 export declare const TOOL_ARG_CAP = 6;
+/**
+ * The longest tool OUTPUT this module lets through, in characters. Eight kilobytes is a screenful of
+ * scroll for one call; a `bash` that prints more is still legible because what it found is usually at the
+ * end, which is why the cut keeps the tail.
+ */
+export declare const TOOL_RESULT_CAP: number;
+/**
+ * REDUCE PI'S `tool_execution_end.result` TO WHAT A PERSON READS, or `undefined`.
+ *
+ * This is the ONLY path from a raw Pi result to anything downstream, and that is the whole reason it is
+ * safe for the result to be persisted at all: the untrusted object stops here. Four rules, each for a
+ * concrete failure it prevents:
+ *
+ * 1. TEXT BLOCKS ONLY, IMAGES DROPPED. A `read` of a PNG returns base64 megabytes, and the state file it
+ *    would land in is rewritten on every text delta of the message it belongs to.
+ * 2. THE TAIL, CUT ON A LINE BOUNDARY. Cutting mid-line leaves a final row that is half a sentence and
+ *    reads as corruption. The tail also beats the head: what a tool just found is at the end.
+ * 3. `details.truncation` / `details.fullOutputPath` ARE READ, never inferred. "This was cut" is a fact
+ *    only Pi knows; deriving it from length would claim Pi truncated something it returned in full.
+ * 4. IT RETURNS `undefined` AND NEVER THROWS. These records arrive on an open event family, so a shape
+ *    this function does not recognise is a fact to decline, not a crash to propagate.
+ */
+export declare function extractToolResultText(result: unknown): ToolResultSummary | undefined;
 /**
  * The one line that tells a reader what a tool call was FOR: the file it opened, the pattern it searched
  * for, the command it ran.

package/dist/server/tool-calls.js

@@ -27,6 +27,79 @@ export const TOOL_DETAIL_CAP = 120;
  * past it is announced by the caller through the row count rather than silently.
  */
 export const TOOL_ARG_CAP = 6;
+/**
+ * The longest tool OUTPUT this module lets through, in characters. Eight kilobytes is a screenful of
+ * scroll for one call; a `bash` that prints more is still legible because what it found is usually at the
+ * end, which is why the cut keeps the tail.
+ */
+export const TOOL_RESULT_CAP = 8 * 1024;
+/**
+ * REDUCE PI'S `tool_execution_end.result` TO WHAT A PERSON READS, or `undefined`.
+ *
+ * This is the ONLY path from a raw Pi result to anything downstream, and that is the whole reason it is
+ * safe for the result to be persisted at all: the untrusted object stops here. Four rules, each for a
+ * concrete failure it prevents:
+ *
+ * 1. TEXT BLOCKS ONLY, IMAGES DROPPED. A `read` of a PNG returns base64 megabytes, and the state file it
+ *    would land in is rewritten on every text delta of the message it belongs to.
+ * 2. THE TAIL, CUT ON A LINE BOUNDARY. Cutting mid-line leaves a final row that is half a sentence and
+ *    reads as corruption. The tail also beats the head: what a tool just found is at the end.
+ * 3. `details.truncation` / `details.fullOutputPath` ARE READ, never inferred. "This was cut" is a fact
+ *    only Pi knows; deriving it from length would claim Pi truncated something it returned in full.
+ * 4. IT RETURNS `undefined` AND NEVER THROWS. These records arrive on an open event family, so a shape
+ *    this function does not recognise is a fact to decline, not a crash to propagate.
+ */
+export function extractToolResultText(result) {
+    try {
+        if (result === undefined || result === null)
+            return undefined;
+        const content = result.content;
+        const chunks = Array.isArray(content)
+            ? content
+            : [{ type: "text", text: typeof result === "string" ? result : undefined }];
+        let text = "";
+        for (const raw of chunks) {
+            // An image chunk is dropped WITHOUT being read: its `data` can be megabytes and nothing here wants it.
+            const chunk = raw;
+            if (!chunk || chunk.type !== "text" || typeof chunk.text !== "string")
+                continue;
+            text += (text ? "\n" : "") + chunk.text;
+        }
+        if (!text)
+            return undefined;
+        const details = result.details;
+        const bag = details && typeof details === "object" ? details : {};
+        const truncation = bag.truncation;
+        const fullOutputPath = typeof bag.fullOutputPath === "string" ? bag.fullOutputPath : undefined;
+        let truncated = typeof truncation === "string" && truncation.length > 0;
+        let droppedLines;
+        if (text.length > TOOL_RESULT_CAP) {
+            const lines = text.split("\n");
+            const kept = [];
+            let used = 0;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                if (used + lines[i].length > TOOL_RESULT_CAP)
+                    break;
+                used += lines[i].length + 1;
+                kept.unshift(lines[i]);
+            }
+            if (!kept.length)
+                kept.push(lines[lines.length - 1].slice(-TOOL_RESULT_CAP));
+            droppedLines = lines.length - kept.length;
+            text = kept.join("\n");
+            truncated = true;
+        }
+        return {
+            text,
+            ...(truncated ? { truncated: true } : {}),
+            ...(droppedLines ? { droppedLines } : {}),
+            ...(fullOutputPath ? { fullOutputPath } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Argument fields that name a FILE, in the order the tools that read files tend to spell them. */
 const PATH_KEYS = ["path", "file_path", "filePath", "target_file", "filename", "file"];
 /** Argument fields that name a SEARCH, which is the thing a human wants to see on a `grep` row. */

package/dist/server/types.d.ts

@@ -91,15 +91,28 @@ export type ToolCallArg = {
  * that showed MORE than a sub-agent card row would answer a question the brief does not ask and would make
  * the two surfaces disagree about what a tool call is.
  *
- * `args` is the ONE addition, and it is what makes a block worth expanding: a card row answers "what was
- * this aimed at", while a block also answers "what else was it given" - a `bash` call's timeout, a
- * `read`'s offset. Bounded to six entries of capped text by `TOOL_ARG_CAP`, so this stays a summary
- * rather than becoming the transcript.
- *
- * TWO THINGS ARE NOT HERE AND NEVER WILL BE. `result` on `tool_execution_end` is, for a `read`, the file's
- * contents; and Pi's `toolCallId` is an identity only Pi can resolve, which is why the record is addressed
- * by position (the caller holds a `toolCallId` → row map for the length of a turn, exactly as
- * `SubagentRunRecorder` does) rather than by a field persisted forever.
+ * `args` and `result` are the two additions, and they are what makes a block worth expanding: a card row
+ * answers "what was this aimed at", while a block also answers "what else was it given" AND "what came
+ * back". `args` is bounded to six entries by `TOOL_ARG_CAP`; `result` is bounded by `TOOL_RESULT_CAP` and
+ * keeps the TAIL of the output, because a tool's answer ends in what it just found.
+ *
+ * `result` IS HERE NOW, AND ITS ARRIVAL OVERRULED A STANDING DECISION. It used to be written off in this
+ * very comment — "`result` on `tool_execution_end` is, for a `read`, the file's contents" — and
+ * `scripts/agent-vis-records.test.mjs` asserted the boundary from the outside, failing on the raw bytes of
+ * `state.json` if a result ever survived into it. Both said the same thing: a call block describes a call,
+ * it does not carry its output. That was right until it wasn't: expanding a `bash` block showed the command
+ * a second time and nothing of what the command found, which is the one thing the reader opened it for.
+ *
+ * What made it safe to reverse is that the bound was always the hard part and it is still enforced:
+ * `extractToolResultText` drops images rather than carrying base64, truncates on a line boundary, and is
+ * the ONLY path from Pi's result to anything downstream — the raw object never travels. And `result` is
+ * OPTIONAL for the same reason `status` is: absent means this call's output was never recorded, which is a
+ * different fact from "recorded, and it was empty", and a default of `""` would state the second while
+ * meaning the first.
+ *
+ * Pi's `toolCallId` is still not here, and is still right not to be: it is an identity only Pi can resolve,
+ * which is why the record is addressed by position (the caller holds a `toolCallId` → row map for the
+ * length of a turn, exactly as `SubagentRunRecorder` does) rather than by a field persisted forever.
  *
  * `status` is OPTIONAL, not defaulted to `"ok"`, for the same reason it is on `SubagentToolCall`: a default
  * would claim an outcome nobody observed. Absent means the call is still in flight, which is the state a
@@ -111,8 +124,29 @@ export type ToolCallBlock = {
     status?: "ok" | "error";
     durationMs?: number;
     args?: ToolCallArg[];
+    result?: ToolResultSummary;
+    /**
+     * OUTPUT AS IT IS ARRIVING, while the call is still running. Replaced by `result` the moment the call
+     * ends, and absent before the first update - so it is never mistaken for the final answer, which is the
+     * distinction that matters when a reader copies it.
+     */
+    live?: string;
     at?: number;
 };
+/**
+ * ONE TOOL CALL'S OUTPUT, reduced to the part a person reads and bounded so it cannot become the
+ * transcript. The shape is closed on purpose: `text` is what to show, and the three optional fields are
+ * what it would be dishonest to omit once the text is known to be short.
+ */
+export type ToolResultSummary = {
+    text: string;
+    /** The output was cut. Never inferred from length alone — only set when Pi said so. */
+    truncated?: boolean;
+    /** Lines Pi dropped, when it said how many. */
+    droppedLines?: number;
+    /** Where Pi put the full output, when it was large enough to warrant a file. */
+    fullOutputPath?: string;
+};
 /**
  * WHAT THE RUNTIME HANDS A CALLER WHEN PI ANNOUNCES OR FINISHES A TOOL CALL.
  *
@@ -128,6 +162,8 @@ export type ToolCallNotice = {
     args?: ToolCallArg[];
     status?: "ok" | "error";
     durationMs?: number;
+    result?: ToolResultSummary;
+    live?: string;
 };
 /**
  * `archivedAt` is the whole archive mechanism: a state MARKER, not a move. The conversation object never
@@ -703,6 +739,16 @@ export type ClientCommandBody =
     conversationId: string;
     name: string;
 }
+/**
+ * ASK THE MODEL TO NAME THIS CONVERSATION. Separate from conversation.rename on purpose: rename moves a
+ * name a person chose, this one is a request whose ANSWER comes back later and may fail - so it cannot
+ * ride the optimistic command path, which resolves the moment the socket accepts the write and has no
+ * room for an answer that arrives ten seconds later. The result arrives as conversation.autoRename.result.
+ */
+ | {
+    type: "conversation.autoRename";
+    conversationId: string;
+}
 /**
  * FORKS A WHOLE SESSION: a second conversation that starts from this one's complete history, in Pi's own
  * transcript as well as in `state.json`.
@@ -982,6 +1028,21 @@ export type ServerEvent = {
     type: "model.catalog";
     catalog: ModelCatalog;
     conversationId?: string;
+}
+/**
+ * The answer to conversation.autoRename. Carries a title OR an error and never both, because the client
+ * has exactly two things to say about it: here is the new name, or here is why there isnt one.
+ */
+ | {
+    type: "conversation.autoRename.result";
+    conversationId: string;
+    ok: true;
+    title: string;
+} | {
+    type: "conversation.autoRename.result";
+    conversationId: string;
+    ok: false;
+    error: string;
 } | {
     type: "agent.catalog";
     catalog: AgentCatalog;