@workerdeck/react 0.16.0 → 0.17.0

package/README.md

@@ -137,6 +137,23 @@ input by construction: fine for the user's own data, never a source of server-au
 
 ## Rules you cannot infer from the types
 
+- **A truncated tool result is hydrated into transcript state, not into a row.** The hook attaches
+  with `truncateResults`, so a huge result arrives as a head carrying
+  `result.truncated`/`totalChars`/`sourceSeq`; `loadFullResult(toolUseId)` fetches the rest and
+  folds it in through `hydrateToolResult`, which clears the markers. Keeping it in row-local state
+  instead would mean the copy button copies the head, the transcript cache drops it on a session
+  switch, and the next event re-truncates the row.
+
+- **`result.images` is the same idea for pictures, and it is set only when there are any.** The
+  hook also attaches with `imageRefs`, so a `tool_result`'s base64 images arrive as addresses and
+  the reducer records `{ partIndex, mediaType, bytes, sourceSeq }` per picture — absent, never
+  empty, because an item that gained a field is an item every renderer re-measures (on iOS
+  `ToolCallItem` is `Equatable` and half the row-plan cache key). Each entry carries its **own**
+  `sourceSeq`: the result-level one is cleared by text hydration, and a reader who pressed "show
+  everything" must still be able to load the screenshot. Raw base64 parts are still dropped on
+  arrival, as they always were — folding them into state would pin megabytes inside the transcript
+  cache.
+
 - **Companions must ride the hook's own `handle`.** The server's tool bridge asks the *first
   attached client*, so a second `useClaudeSession` for the same session is a second attach that
   will never be asked anything. `useAttachments`, `useHostFileSearch` and `useToolCallHost` all

package/build/index.d.mts

@@ -1,4 +1,4 @@
-import { AttachedFrame, ContextUsage, EngineCapabilities, FilePatch, HostDirEntry, HostFileMatch, MessageAttachment, ModelOption, PermissionMode, PermissionRequest, ProfileEngine, ProfileUsage, RateLimitInfo, SessionEvent, SessionInfo, SessionStatus, SkillInfo, SlashCommandInfo, ToolExecutionBackend, UsageWindowRow } from "@workerdeck/protocol";
+import { AttachedFrame, ContextUsage, EngineCapabilities, FilePatch, HostDirEntry, HostFileMatch, MessageAttachment, ModelOption, PermissionMode, PermissionRequest, ProfileEngine, ProfileUsage, RateLimitInfo, SessionEvent, SessionInfo, SessionRow, SessionStatus, SkillInfo, SlashCommandInfo, ToolExecutionBackend, UsageWindowRow } from "@workerdeck/protocol";
 import { SessionHandle, WorkerDeckClient } from "@workerdeck/client";
 import { RunScriptResult, SandboxEngine, SandboxVfs } from "@workerdeck/sandbox";
 
@@ -12,6 +12,18 @@ type TranscriptItem = {
   id: string;
   text: string;
   attachments?: MessageAttachment[];
+  /**
+   * The `Task` call this prompt was addressed to, when it is a subagent's
+   * brief rather than something a person typed.
+   *
+   * Optional where the other kinds carry it as `string | null`, and the
+   * asymmetry is the point: on those it is a fact about every instance, so
+   * forgetting to stamp it should not typecheck. Here the overwhelming case
+   * is a human prompt, which has no parent at all — `undefined` says that,
+   * where `null` on 24 construction sites would only say "somebody
+   * remembered".
+   */
+  parentToolUseId?: string;
 } | {
   kind: 'assistant_text';
   id: string;
@@ -39,9 +51,45 @@ type TranscriptItem = {
    * deferred call has no result yet and is not the same as a running one.
    */
   status: 'running' | 'pending' | 'deferred' | 'settled' | 'failed';
+  /**
+   * `truncated`/`totalChars`/`sourceSeq` are set **only** when the replay
+   * delivered a head (protocol's {@link ToolResultBlock.truncated}), so
+   * every other result stays byte-identical to what it was before this
+   * feature existed. That matters beyond tidiness: on iOS `ToolCallItem` is
+   * `Equatable` and is half the row-plan cache key.
+   *
+   * `sourceSeq` is what makes the press possible at all — the item is what a
+   * renderer holds, and it must be able to name the event to fetch. It goes
+   * away again on hydration, along with the other two, so a hydrated result
+   * is indistinguishable from one that was never cut.
+   */
   result?: {
     text: string;
     isError: boolean;
+    truncated?: boolean;
+    totalChars?: number;
+    sourceSeq?: number;
+    /**
+     * The pictures this result carried, as addresses rather than bytes —
+     * set **only** when the replay delivered `image_ref` parts, so every
+     * other result stays byte-identical (the `Equatable` argument above,
+     * again).
+     *
+     * Each entry carries its **own** `sourceSeq`, which is not redundant
+     * with the one beside it: that one is cleared by text hydration, and a
+     * reader who pressed "show everything" must still be able to load the
+     * screenshot afterwards.
+     *
+     * Raw base64 `image` parts are still dropped on arrival, as they always
+     * were. Folding them in would pin megabytes inside `TranscriptState`,
+     * which the transcript LRU then retains across session switches.
+     */
+    images?: ReadonlyArray<{
+      partIndex: number;
+      mediaType: string;
+      bytes: number;
+      sourceSeq: number;
+    }>;
   };
   /**
    * What this call changed on disk, when it was a file edit — the engine's
@@ -172,6 +220,22 @@ declare function seedFromSessionInfo(state: TranscriptState, info: SessionInfo):
  * described two ways. This stays as the transcript-shaped door to it.
  */
 declare function rateLimitWindows(state: TranscriptState): UsageWindowRow[];
+/**
+ * Put a fetched tool result back where its head was — the other half of
+ * `truncateResults`.
+ *
+ * Into **transcript state**, not row-local state, and the three reasons are the
+ * design: the copy button then copies the whole thing rather than the head, the
+ * transcript cache retains it across a session switch, and no later event can
+ * re-truncate it. The markers are cleared, so a hydrated result is
+ * indistinguishable from one that was never cut and every renderer needs a
+ * branch for exactly one state, not two.
+ *
+ * Keyed on `toolUseId`, which is the id the row already holds; `seq` is what the
+ * *fetch* needed, not what the fold needs. Unknown id returns `state` unchanged
+ * — a press answered after the session was cleared must not resurrect a row.
+ */
+declare function hydrateToolResult(state: TranscriptState, toolUseId: string, text: string): TranscriptState;
 declare function applyEvent(state: TranscriptState, event: SessionEvent): TranscriptState;
 //#endregion
 //#region src/hooks/use-session.d.ts
@@ -313,6 +377,17 @@ type UseClaudeSessionResult = {
   setModel: (model?: string) => void;
   closeSession: () => void; /** Skip the reconnect backoff — what a tab returning to the foreground does. */
   reconnectNow: () => void;
+  /**
+   * Fetch the whole of a tool result the replay delivered as a head, and put it
+   * back on its row (`result.truncated` clears with it).
+   *
+   * Resolves `false` when there was nothing to do — an untruncated row, an
+   * unknown id, or a gateway that refused (a stale `sourceSeq` after a dormant
+   * rebuild 404s by design; re-attaching is what fixes that, not a retry). It
+   * never throws, because the caller is a press on a row and an exception there
+   * has nowhere sensible to go.
+   */
+  loadFullResult: (toolUseId: string) => Promise<boolean>;
 };
 /** Attach to a session and maintain live transcript state. Detaches on unmount. */
 declare function useClaudeSession(client: WorkerDeckClient, sessionId: string | undefined, options?: UseClaudeSessionOptions): UseClaudeSessionResult;
@@ -555,6 +630,10 @@ type UseHostFileTreeResult = {
  */
 declare function useHostFileTree(client: WorkerDeckClient, cwd: string | undefined): UseHostFileTreeResult;
 //#endregion
+//#region src/hooks/use-project-icons.d.ts
+type ClientForHost = (hostId: string) => WorkerDeckClient | undefined;
+declare function useProjectIcons(rows: readonly SessionRow[], clientFor: ClientForHost): Record<string, string>;
+//#endregion
 //#region src/hooks/use-profile-usage.d.ts
 type UseProfileUsageOptions = {
   /** How often to re-ask while enabled. Default 60s. */intervalMs?: number;
@@ -900,5 +979,5 @@ declare function summarizeSince(state: RecapInput, fromIndex: number): RecapSumm
  */
 declare function recapLine(summary: RecapSummary): string | undefined;
 //#endregion
-export { type AttachmentKind, type ConnectionState, type HostDirState, type HostTreeRow, type OpenFile, type OpenFilesAction, type OpenFilesState, type ProducedFileRef, type PromptToken, REPLAY_HOLD_MAX_MS, type RecapInput, type RecapSummary, type StagedAttachment, type ToolCallHostOptions, type ToolHostExecution, type ToolHostRunner, type TranscriptItem, type TranscriptState, type UseAttachmentsOptions, type UseAttachmentsResult, type UseClaudeSessionOptions, type UseClaudeSessionResult, type UseHostFileRootsResult, type UseHostFileSearchResult, type UseHostFileTreeResult, type UseOpenFilesResult, type UseProfileUsageOptions, type UseProfileUsageResult, type UseSessionInfoResult, type UseToolCallHostOptions, ancestorsWithin, applyEvent, attachmentKind, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useSessionInfo, useToolCallHost };
+export { type AttachmentKind, type ClientForHost, type ConnectionState, type HostDirState, type HostTreeRow, type OpenFile, type OpenFilesAction, type OpenFilesState, type ProducedFileRef, type PromptToken, REPLAY_HOLD_MAX_MS, type RecapInput, type RecapSummary, type StagedAttachment, type ToolCallHostOptions, type ToolHostExecution, type ToolHostRunner, type TranscriptItem, type TranscriptState, type UseAttachmentsOptions, type UseAttachmentsResult, type UseClaudeSessionOptions, type UseClaudeSessionResult, type UseHostFileRootsResult, type UseHostFileSearchResult, type UseHostFileTreeResult, type UseOpenFilesResult, type UseProfileUsageOptions, type UseProfileUsageResult, type UseSessionInfoResult, type UseToolCallHostOptions, ancestorsWithin, applyEvent, attachmentKind, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, hydrateToolResult, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useProjectIcons, useSessionInfo, useToolCallHost };
 //# sourceMappingURL=index.d.mts.map

package/build/index.mjs

@@ -10,13 +10,48 @@ const initialTranscriptState = {
 	totalCostUsd: 0,
 	lastSeq: 0
 };
+/**
+* The in-flight streamed text and thought — a singleton **per agent**, not per
+* session.
+*
+* It was one id for the whole stream, which was right while one thread streamed
+* at a time. It is not: with subagent text forwarded, a `Task` and the thread
+* that spawned it stream *concurrently*, and three parallel Tasks stream three
+* ways at once. Under one id every one of those deltas accumulates into the same
+* item — a row welding several agents' half-sentences together — and the first
+* `assistant_message` to land wipes all of them, including the ones still being
+* written.
+*
+* So the id carries the agent: `streaming` for the main thread (unchanged, so
+* nothing that keys off it moves) and `streaming:<parentToolUseId>` inside a
+* subagent.
+*/
 const STREAMING_ID = "streaming";
 const STREAMING_THINKING_ID = "streaming-thinking";
+const streamingTextId = (parentToolUseId) => parentToolUseId == null ? STREAMING_ID : `${STREAMING_ID}:${parentToolUseId}`;
+const streamingThinkingId = (parentToolUseId) => parentToolUseId == null ? STREAMING_THINKING_ID : `${STREAMING_THINKING_ID}:${parentToolUseId}`;
+/** Is this item an in-flight stream — anyone's? The turn's end finalizes every
+* one of them, since a subagent's last text is as unrecoverable as the main
+* thread's when a turn is interrupted. */
+const isStreamingItem = (item) => item.kind === "assistant_text" && item.id.startsWith(STREAMING_ID) || item.kind === "thinking" && item.id.startsWith(STREAMING_THINKING_ID);
 function blockText(content) {
 	if (content === void 0) return "";
 	if (typeof content === "string") return content;
 	return content.map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
 }
+/** The `image_ref` addresses in a result's content, or undefined when it holds
+* none — which is the common case, and is why this returns undefined rather than
+* an empty array: an absent field keeps the item byte-identical. */
+function imageRefsOf(content, seq) {
+	if (!Array.isArray(content)) return void 0;
+	const refs = content.flatMap((part) => part.type === "image_ref" ? [{
+		partIndex: Number(part.part_index),
+		mediaType: String(part.media_type ?? "application/octet-stream"),
+		bytes: Number(part.bytes ?? 0),
+		sourceSeq: seq
+	}] : []);
+	return refs.length > 0 ? refs : void 0;
+}
 function contentToBlocks(content) {
 	return typeof content === "string" ? [{
 		type: "text",
@@ -97,6 +132,40 @@ function rateLimitWindows(state) {
 		updatedAt: state.rateLimitsUpdatedAt
 	}, void 0));
 }
+/**
+* Put a fetched tool result back where its head was — the other half of
+* `truncateResults`.
+*
+* Into **transcript state**, not row-local state, and the three reasons are the
+* design: the copy button then copies the whole thing rather than the head, the
+* transcript cache retains it across a session switch, and no later event can
+* re-truncate it. The markers are cleared, so a hydrated result is
+* indistinguishable from one that was never cut and every renderer needs a
+* branch for exactly one state, not two.
+*
+* Keyed on `toolUseId`, which is the id the row already holds; `seq` is what the
+* *fetch* needed, not what the fold needs. Unknown id returns `state` unchanged
+* — a press answered after the session was cleared must not resurrect a row.
+*/
+function hydrateToolResult(state, toolUseId, text) {
+	let changed = false;
+	const items = state.items.map((item) => {
+		if (item.kind !== "tool_call" || item.id !== toolUseId || !item.result?.truncated) return item;
+		changed = true;
+		return {
+			...item,
+			result: {
+				text,
+				isError: item.result.isError,
+				...item.result.images && { images: item.result.images }
+			}
+		};
+	});
+	return changed ? {
+		...state,
+		items
+	} : state;
+}
 function applyEvent(state, event) {
 	if (event.seq <= state.lastSeq) return state;
 	const base = {
@@ -181,7 +250,13 @@ function applyEvent(state, event) {
 					status: isError ? "failed" : "settled",
 					result: {
 						text: blockText(toolResult.content),
-						isError
+						isError,
+						...toolResult.truncated && {
+							truncated: true,
+							totalChars: toolResult.total_chars,
+							sourceSeq: event.seq
+						},
+						...imageRefsOf(toolResult.content, event.seq) && { images: imageRefsOf(toolResult.content, event.seq) }
 					},
 					...event.patch && { patch: event.patch }
 				} : item);
@@ -198,7 +273,8 @@ function applyEvent(state, event) {
 					kind: "user",
 					id: event.uuid ?? `user-${event.seq}`,
 					text: slashCommandText(text) ?? text,
-					attachments: event.attachments
+					attachments: event.attachments,
+					...event.parentToolUseId != null && { parentToolUseId: event.parentToolUseId }
 				});
 			}
 			return {
@@ -207,8 +283,10 @@ function applyEvent(state, event) {
 			};
 		}
 		case "assistant_message": {
-			let streamedThinking = base.items.find((item) => item.kind === "thinking" && item.id === STREAMING_THINKING_ID)?.text ?? "";
-			let items = base.items.filter((item) => !(item.kind === "assistant_text" && item.id === STREAMING_ID) && !(item.kind === "thinking" && item.id === STREAMING_THINKING_ID));
+			const streamingText = streamingTextId(event.parentToolUseId);
+			const streamingThought = streamingThinkingId(event.parentToolUseId);
+			let streamedThinking = base.items.find((item) => item.kind === "thinking" && item.id === streamingThought)?.text ?? "";
+			let items = base.items.filter((item) => !(item.kind === "assistant_text" && item.id === streamingText) && !(item.kind === "thinking" && item.id === streamingThought));
 			contentToBlocks(event.message.content).forEach((block, index) => {
 				const id = `${event.uuid}-${index}`;
 				if (block.type === "text") items = upsert(items, {
@@ -249,10 +327,11 @@ function applyEvent(state, event) {
 			const delta = event.event;
 			if (delta.type !== "content_block_delta") return base;
 			if (delta.delta?.type === "text_delta") {
+				const id = streamingTextId(event.parentToolUseId);
 				const item = {
 					kind: "assistant_text",
-					id: STREAMING_ID,
-					text: (base.items.find((item) => item.kind === "assistant_text" && item.id === STREAMING_ID)?.text ?? "") + (delta.delta.text ?? ""),
+					id,
+					text: (base.items.find((item) => item.kind === "assistant_text" && item.id === id)?.text ?? "") + (delta.delta.text ?? ""),
 					streaming: true,
 					parentToolUseId: event.parentToolUseId
 				};
@@ -262,11 +341,12 @@ function applyEvent(state, event) {
 				};
 			}
 			if (delta.delta?.type === "thinking_delta") {
-				const text = (base.items.find((item) => item.kind === "thinking" && item.id === STREAMING_THINKING_ID)?.text ?? "") + (delta.delta.thinking ?? "");
+				const id = streamingThinkingId(event.parentToolUseId);
+				const text = (base.items.find((item) => item.kind === "thinking" && item.id === id)?.text ?? "") + (delta.delta.thinking ?? "");
 				if (text.trim() === "") return base;
 				const item = {
 					kind: "thinking",
-					id: STREAMING_THINKING_ID,
+					id,
 					text,
 					parentToolUseId: event.parentToolUseId
 				};
@@ -280,14 +360,18 @@ function applyEvent(state, event) {
 		case "turn_result": return {
 			...base,
 			totalCostUsd: event.totalCostUsd,
-			items: [...base.items.map((item) => item.kind === "assistant_text" && item.id === STREAMING_ID ? {
-				...item,
-				id: `text-${event.seq}`,
-				streaming: false
-			} : item.kind === "thinking" && item.id === STREAMING_THINKING_ID ? {
-				...item,
-				id: `thinking-${event.seq}`
-			} : item), {
+			items: [...base.items.map((item) => {
+				if (!isStreamingItem(item)) return item;
+				const agent = "parentToolUseId" in item && item.parentToolUseId ? `-${item.parentToolUseId}` : "";
+				return item.kind === "assistant_text" ? {
+					...item,
+					id: `text-${event.seq}${agent}`,
+					streaming: false
+				} : {
+					...item,
+					id: `thinking-${event.seq}${agent}`
+				};
+			}), {
 				kind: "turn_result",
 				id: `turn-${event.seq}`,
 				subtype: event.subtype,
@@ -437,11 +521,65 @@ function clearTranscriptCache() {
 	entries.clear();
 }
 //#endregion
+//#region src/lib/attach-plan.ts
+/**
+* The attach effect's decisions, pure.
+*
+* `useClaudeSession` is never rendered in tests — this package deliberately
+* carries no jsdom and no testing-library — so the logic that used to live
+* inline in the attach effect (which state an attach holds, whether the
+* reducer must be re-seeded, which `afterSeq` to request, whether the parting
+* state may go back into the cache) is decided here, where plain vitest
+* reaches it, and the effect keeps only glue: read its refs into inputs,
+* apply the returned instructions, subscribe. The refs themselves stay in the
+* hook — a decision function that owned React state would be the untestable
+* thing again — so everything stateful arrives as a value and leaves as an
+* instruction.
+*/
+/**
+* Which (resync, client identity, session) a reducer state was seeded for.
+* One format, shared by the hook's mount initializer and {@link planAttach},
+* so the two sites cannot drift: a token that dropped `resyncSeq` would leave
+* the stale-log retry looking already-seeded, and the fresh replay would
+* compose into the condemned state the resync just discarded.
+*/
+function attachSeedToken(resyncSeq, key) {
+	return `${resyncSeq}:${key}`;
+}
+/**
+* Decide what one run of the attach effect does before it opens the socket.
+*/
+function planAttach(input) {
+	const seedToken = attachSeedToken(input.resyncSeq, input.key);
+	const warm = input.cacheEnabled && !input.skipCache ? input.warm : void 0;
+	const seed = input.seededFor !== seedToken;
+	const held = seed ? warm ?? initialTranscriptState : input.current;
+	return {
+		held,
+		seed,
+		seedToken,
+		...held.lastSeq > 0 ? { afterSeq: held.lastSeq } : {}
+	};
+}
+/**
+* Whether the effect's cleanup may keep the parting transcript warm for a
+* switch-back. Refused when caching is off; after a stale-log detection —
+* writing the condemned state back would re-poison the very retry that just
+* discarded it; and when there is nothing real to keep — `lastSeq === 0` also
+* protects an existing entry from being clobbered by a mount that never
+* finished attaching, and a state with no `session` never saw its attached
+* frame at all.
+*/
+function shouldWriteParting(input) {
+	return input.cacheEnabled && !input.skipCache && input.parting.lastSeq > 0 && input.parting.session !== void 0;
+}
+//#endregion
 //#region src/hooks/use-session.ts
 /** Session events drive the reducer; the attach snapshot seeds fields (permission
 * mode, model) that a promptless session's event stream doesn't carry yet. */
 function reduce(state, action) {
 	if (action.type === "transcript_seed") return action.state;
+	if (action.type === "transcript_hydrate_result") return hydrateToolResult(state, action.toolUseId, action.text);
 	return action.type === "attached" ? seedFromSessionInfo(state, action.session) : applyEvent(state, action);
 }
 /** Failed attempts in a row before "reconnecting…" stops being the honest word.
@@ -531,26 +669,34 @@ function useClaudeSession(client, sessionId, options) {
 	optionsRef.current = options;
 	const stateRef = useRef(state);
 	stateRef.current = state;
-	const seededForRef = useRef(`0:${sessionId === void 0 ? "" : transcriptCacheKey(client, sessionId)}`);
+	const seededForRef = useRef(attachSeedToken(0, sessionId === void 0 ? "" : transcriptCacheKey(client, sessionId)));
 	const skipCacheRef = useRef(false);
 	useEffect(() => {
 		if (!sessionId) return;
 		const cache = optionsRef.current?.cacheTranscript !== false;
 		const key = transcriptCacheKey(client, sessionId);
-		const seedToken = `${resyncSeq}:${key}`;
-		const warm = cache && !skipCacheRef.current ? readTranscriptCache(key) : void 0;
+		const plan = planAttach({
+			resyncSeq,
+			key,
+			seededFor: seededForRef.current,
+			current: stateRef.current,
+			cacheEnabled: cache,
+			skipCache: skipCacheRef.current,
+			warm: readTranscriptCache(key)
+		});
 		skipCacheRef.current = false;
-		let held;
-		if (seededForRef.current === seedToken) held = stateRef.current;
-		else {
-			held = warm ?? initialTranscriptState;
+		if (plan.seed) {
 			dispatch({
 				type: "transcript_seed",
-				state: held
+				state: plan.held
 			});
-			seededForRef.current = seedToken;
+			seededForRef.current = plan.seedToken;
 		}
-		const handle = client.attach(sessionId, held.lastSeq > 0 ? { afterSeq: held.lastSeq } : {});
+		const handle = client.attach(sessionId, {
+			truncateResults: true,
+			imageRefs: true,
+			...plan.afterSeq === void 0 ? {} : { afterSeq: plan.afterSeq }
+		});
 		handleRef.current = handle;
 		setHandleState(handle);
 		const offEvent = handle.on("event", (event) => dispatch(event));
@@ -584,7 +730,11 @@ function useClaudeSession(client, sessionId, options) {
 			setProtocolMismatch(void 0);
 			setReplayTarget(void 0);
 			const parting = stateRef.current;
-			if (cache && !skipCacheRef.current && parting.lastSeq > 0 && parting.session) writeTranscriptCache(key, parting);
+			if (shouldWriteParting({
+				cacheEnabled: cache,
+				skipCache: skipCacheRef.current,
+				parting
+			})) writeTranscriptCache(key, parting);
 		};
 	}, [
 		client,
@@ -603,6 +753,23 @@ function useClaudeSession(client, sessionId, options) {
 	const connected = connection === "live";
 	const replaying = replayTarget !== void 0 && state.lastSeq < replayTarget;
 	const reconnectNow = useCallback(() => handleRef.current?.reconnectNow(), []);
+	const loadFullResult = useCallback(async (toolUseId) => {
+		if (!sessionId) return false;
+		const item = stateRef.current.items.find((candidate) => candidate.kind === "tool_call" && candidate.id === toolUseId);
+		const result = item?.kind === "tool_call" ? item.result : void 0;
+		if (!result?.truncated || result.sourceSeq === void 0) return false;
+		try {
+			const full = await client.toolResult(sessionId, result.sourceSeq, toolUseId);
+			dispatch({
+				type: "transcript_hydrate_result",
+				toolUseId,
+				text: typeof full.content === "string" ? full.content : (full.content ?? []).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n")
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}, [client, sessionId]);
 	return useMemo(() => ({
 		state,
 		connected,
@@ -619,7 +786,8 @@ function useClaudeSession(client, sessionId, options) {
 		setPermissionMode: (mode) => handleRef.current?.setPermissionMode(mode),
 		setModel: (model) => handleRef.current?.setModel(model),
 		closeSession: () => handleRef.current?.closeSession(),
-		reconnectNow
+		reconnectNow,
+		loadFullResult
 	}), [
 		state,
 		connected,
@@ -628,7 +796,8 @@ function useClaudeSession(client, sessionId, options) {
 		protocolMismatch,
 		models,
 		handleState,
-		reconnectNow
+		reconnectNow,
+		loadFullResult
 	]);
 }
 /**
@@ -1196,6 +1365,66 @@ function useHostFileTree(client, cwd) {
 	};
 }
 //#endregion
+//#region src/hooks/use-project-icons.ts
+/**
+* Project icon bytes for a list of sessions, as object URLs keyed by the icon's
+* own content hash.
+*
+* **Keyed by hash, and cached for the life of the page.** That is what the
+* wire's `ProjectIcon.image.hash` is for: every session in one project serves
+* identical bytes, so twelve rows of one repo cost one request, and two
+* *different* projects that happen to declare the same file cost one between
+* them. A hash names its bytes, so an entry can never go stale — editing the
+* icon changes the hash, which arrives on the next poll as a key this cache has
+* not seen. The old entry is dead weight rather than a wrong answer, and the
+* population is bounded by how many distinct icons an operator has open.
+*
+* The cache is **module scope on purpose**, like `useSessions`' store: the
+* sidebar and any other surface rendering rows mount this at once, and a
+* per-hook cache would be N copies each fetching the same bytes.
+*
+* A failure is cached as a failure. The route's 404 is the uniform "no icon"
+* (no project, a glyph, or one the gateway refused), so retrying it every poll
+* would be a request per session per poll for a picture that is never coming.
+*
+* Object URLs are never revoked, which is the same decision stated twice: they
+* are the cache. Revoking one would break every row still pointing at it, and
+* the whole point of hashing is that nothing here is ever superseded.
+*
+* The VS Code extension has the same three-set structure in `project-icons.ts`
+* and cannot share this one — its webview has no external `connect-src` at all,
+* so its bytes arrive as data URLs pushed from the extension host. One design,
+* two implementations, for a reason that is in the transport rather than here.
+*/
+const byHash = /* @__PURE__ */ new Map();
+const inFlight = /* @__PURE__ */ new Set();
+const failed = /* @__PURE__ */ new Set();
+function useProjectIcons(rows, clientFor) {
+	const [resolved, setResolved] = useState(() => Object.fromEntries(byHash));
+	useEffect(() => {
+		let alive = true;
+		for (const row of rows) {
+			const icon = row.info.project?.icon;
+			if (icon?.type !== "image") continue;
+			const { hash } = icon;
+			if (byHash.has(hash) || inFlight.has(hash) || failed.has(hash)) continue;
+			const client = clientFor(row.hostId);
+			if (!client) continue;
+			inFlight.add(hash);
+			client.projectIcon(row.info.id).then((blob) => {
+				byHash.set(hash, URL.createObjectURL(blob));
+				if (alive) setResolved(Object.fromEntries(byHash));
+			}).catch(() => {
+				failed.add(hash);
+			}).finally(() => inFlight.delete(hash));
+		}
+		return () => {
+			alive = false;
+		};
+	}, [rows, clientFor]);
+	return resolved;
+}
+//#endregion
 //#region src/hooks/use-profile-usage.ts
 /**
 * The gateway's per-profile plan usage, over REST.
@@ -1885,6 +2114,6 @@ function plural(count, one, many = `${one}s`) {
 	return `${count} ${count === 1 ? one : many}`;
 }
 //#endregion
-export { REPLAY_HOLD_MAX_MS, ancestorsWithin, applyEvent, attachmentKind, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useSessionInfo, useToolCallHost };
+export { REPLAY_HOLD_MAX_MS, ancestorsWithin, applyEvent, attachmentKind, clearTranscriptCache, createToolCallHost, currentText, flattenHostTree, hydrateToolResult, initialOpenFilesState, initialReplayTarget, initialTranscriptState, isDirty, openFilesReducer, rateLimitWindows, recapLine, scanPromptTokens, seedFromSessionInfo, staleAttach, summarizeSince, useAttachments, useClaudeSession, useHostFileRoots, useHostFileSearch, useHostFileTree, useOpenFiles, useProfileUsage, useProjectIcons, useSessionInfo, useToolCallHost };
 
 //# sourceMappingURL=index.mjs.map