@deepseek-ai/dsh-client-ui-trajectory 0.2.0-rc.2 → 0.2.1-alpha.2

package/README.i18n.yaml

@@ -18,14 +18,14 @@
   en: 4bd17d05b8385675
   zh: 5174e27f754f2a03
 /deepseek-ai-dsh-client-ui-trajectory/use-this-package/inspecting-records:
-  en: 89758270607a5fd4
-  zh: 0efba26195ef1f80
+  en: e4ba2d9cab2fb258
+  zh: 7db041270420b2ba
 /deepseek-ai-dsh-client-ui-trajectory/use-this-package/the-timing-overview:
-  en: 0331f90cbd904862
-  zh: bdc2d4ed1c3c1f5e
+  en: 0f4ee2189324ac06
+  zh: 12e76fed22c09bc1
 /deepseek-ai-dsh-client-ui-trajectory/understand-the-implementation:
-  en: 925abc8e4b092cb3
-  zh: ebe85c5acdbea3b1
+  en: 74cc8fc87241da34
+  zh: cd72ff9c0fdd2575
 /deepseek-ai-dsh-client-ui-trajectory/understand-the-implementation/virtual-rows:
   en: c85e342bc7eee4e6
   zh: 9feab66ef1755b94
@@ -45,5 +45,5 @@
   en: d7da620f56eb3c65
   zh: fb030b68322b94cd
 /deepseek-ai-dsh-client-ui-trajectory/known-limitations-and-deferred-work/dev-note:
-  en: f1893e3a6c69cc58
-  zh: b6e0dfe20567c35f
+  en: e67f633dc6fe7773
+  zh: 3bb0c20c93f16f98

package/README.md

@@ -29,17 +29,19 @@ Open the Trajectory tab in the conversation's view ring to inspect agent activit
 
 ### Inspecting records
 
-Calls are identified by their recorded tool name. For `run_code`, the row shows the program description and the inspector opens numbered, highlighted source. The Code tab provides wrapping, a `{}` toggle for the original JSON arguments, and exact source copying, including trailing newlines. Copying the original arguments retains their recorded JSON whitespace. Each newly opened code view takes the last wrapping choice; changing it leaves other open views as they are. Output preserves the recorded text, using a tree for complete JSON objects or arrays. Highlighting uses only an unambiguous TypeScript or Python hint in the recorded tool schema; missing or conflicting hints leave plain source. See the [PTC inspection decision](../../../.agents/notes/implemented/feature/2026-09-09-ptc-trajectory-code-inspection.md) for replay constraints.
+Calls are identified by their recorded tool name. For `run_code`, the row shows the program description and the inspector opens numbered, highlighted source. The Code tab provides wrapping, a `{}` toggle for the original JSON arguments, and exact source copying, including trailing newlines. Copying the original arguments retains their recorded JSON whitespace. Each newly opened code view takes the last wrapping choice; changing it leaves other open views as they are. Output preserves the recorded text, using a tree for complete JSON objects or arrays. Highlighting uses only an unambiguous TypeScript or Python hint in the recorded tool schema; missing or conflicting hints leave plain source.
 
 Selection, timeline navigation, folding, and search cover the React-visible window. Request numbers and cumulative usage cover the complete resident snapshot. Selecting a record opens a local inspector for token usage, duration, Input, Output, Timing, and durable images. Image URLs use the Conversation-owned per-session cache, so Chat and Trajectory share one authorized read per attachment. A user record shows both nonzero image and ordinary-file counts beside its text, including attachment-only records. A standalone compaction request appears chronologically in its own `Between turns` section, while a numbered compaction remains inside its owning turn.
 
 Summary and Preview share one ordered attachment list after the message text, preserving repeated references. Each row shows a contained image thumbnail or file-type icon, the recorded filename (a localized numbered label for unnamed images), and recorded size, type, and image dimensions where available. Zero-byte files retain their size, and truncated filenames expose the full name in a tooltip. Images open the existing lightbox. Raw keeps content-block order and unrendered text, with images and files in initially collapsed disclosures containing their complete recorded fields.
 
+Requests remain pending while awaiting output, streaming, or retrying. A request without assistant output has no result link; interrupted output remains inspectable and both the request and assistant record show failure, including when the Step start is outside the loaded history. Retry counts and the last attempt error remain available after recovery; they do not change the current request status. A completed model response does not imply that its tools or turn have finished.
+
 Thinking in the inspector uses compact Markdown at the inspector's fixed 13px size and 20px line height, independent of the content-size setting. Headings add bold weight without increasing size or line height. Assistant output keeps its regular Markdown typography.
 
 ### The timing overview
 
-Historical replies retain TTFT, generation duration, and throughput when their recorded streams contain token timestamps. TTFT measures from the Step start to its first token, including output from an earlier retry attempt; an unloaded Step start or a stream without tokens leaves the corresponding metric unavailable.
+Streaming replies retain their known start time and TTFT. After settlement, token timestamps provide generation duration; throughput also requires recorded usage. Historical replies retain the same recorded timing. TTFT measures from the Step start to its first token, including output from an earlier retry attempt; an unloaded Step start or a stream without tokens leaves the corresponding metric unavailable.
 
 A fixed Overview above the ledger projects real record start/duration timing from left to right; Assistant spans divide recorded TTFT from decoding, and a 500 ms hover reveals exact clock and duration details. Dragging an interval focuses the ledger on every record active at any point in that inclusive range; wheel gestures zoom the time domain; a right-button click clears the selected interval, and a right-button drag pans an already zoomed viewport. The initial view and streaming updates stay at the tail; scrolling upward suspends following so new records do not interrupt inspection of earlier rows.
 
@@ -53,9 +55,9 @@ A fixed Overview above the ledger projects real record start/duration timing fro
 
 The view is a pure projection: Trajectory-owned Definitions assemble business records from the shared Session window — including durable cancellation-finalized prefixes, chunk-only interruption fallbacks, and interrupted Tool records — so Trajectory neither reads nor changes the Chat conversation snapshot. Its steering classifier retains only next-step Inbox IDs through persistent splice state and shares each current claimed batch across later Contexts.
 
-Native and nested PTC Tool results retain their raw structured error details. Failed records show the error code in the ledger and the error name and code in the inspector.
+Native and nested PTC Tool results retain their raw structured error details and presentation metadata. Failed records show the error code in the ledger and the error name and code in the inspector.
 
-Tool records begin at durable tool/call events and use complete arguments. Chat's transient preparing stage does not create Trajectory tool rows or alter historical tool timing.
+Tool records begin at durable tool/call events and retain complete argument text with a lazy `args` view, reused by paired results. Chat's transient preparing stage does not create Trajectory tool rows or alter historical tool timing.
 
 A complete appended prompt without a loaded request header appears as a standalone system row; only its known text is available, with no inferred request options or tool catalog. Prepending its request history replaces that standalone presentation without duplicating the prompt. In-history system prompt changes compare against the most recent request state, including earlier prompt updates without a new request header. Each request retains the prompt and change that applied at its own position. Surface replacements, including compaction, restore the last nonempty surviving system prompt even without a new system event; an unloaded prompt remains unavailable until its page arrives.
 
@@ -112,5 +114,3 @@ These limits define what the view can show while work is in flight; they are cur
 None.
 
 </details>
-
-**Runtime invariant:** No companion is published. It is a pure-consumer plugin: it emits no Cordis events and owns no mutable cross-plugin state; its view-slot registration is a plain effect whose disposal the slot ledger's own specs and this package's behavior specs observe directly.

package/README.zh.md

@@ -29,17 +29,19 @@ Trajectory 标签页让你以按轮次组织的事件记录表和交互式时间
 
 ### 检查记录
 
-调用按已记录的工具名识别。对于 `run_code`，记录行展示程序说明，检查器显示带行号和语法高亮的源码。“代码”页提供换行、查看原始 JSON 参数的 `{}` 切换按钮，以及保留末尾换行的源码原样复制。复制原始参数时保留记录中 JSON 的空白。每个新打开的代码视图采用上次选择的换行状态；切换时，其他已打开视图保持原状。输出保留记录中的文本，完整 JSON 对象或数组使用树形展示。高亮只采用已记录工具 Schema 中明确且无冲突的 TypeScript 或 Python 提示；提示缺失或冲突时显示纯文本源码。回放约束见 [PTC 检查决策](../../../.agents/notes/implemented/feature/2026-09-09-ptc-trajectory-code-inspection.zh.md)。
+调用按已记录的工具名识别。对于 `run_code`，记录行展示程序说明，检查器显示带行号和语法高亮的源码。“代码”页提供换行、查看原始 JSON 参数的 `{}` 切换按钮，以及保留末尾换行的源码原样复制。复制原始参数时保留记录中 JSON 的空白。每个新打开的代码视图采用上次选择的换行状态；切换时，其他已打开视图保持原状。输出保留记录中的文本，完整 JSON 对象或数组使用树形展示。高亮只采用已记录工具 Schema 中明确且无冲突的 TypeScript 或 Python 提示；提示缺失或冲突时显示纯文本源码。
 
 选择、时间线导航、折叠与搜索只覆盖 React 可见窗口。请求编号与累计用量覆盖完整的驻留快照。选择记录会打开局部检查器，查看 token 用量、耗时、输入、输出、计时与持久保留的图片。图片 URL 使用 Conversation 拥有的逐会话缓存，因此 Chat 与 Trajectory 对每个附件共享一次已授权读取。用户记录会在文本旁同时显示非零的图片与普通文件数量，仅含附件的记录也显示这些数量。独立运行的压缩请求会按时间顺序显示在自己的 `Between turns` 区段中，而带编号的压缩仍位于其所属轮次内。
 
 概述与预览共用正文之后的有序附件列表，保留重复引用。每行展示完整缩放的图片缩略图或文件类型图标、已记录的文件名（未命名图片使用本地化的编号名称），以及可用的已记录大小、类型和图片尺寸。零字节文件保留大小显示，截断的文件名通过提示显示完整名称。图片打开现有灯箱。原始内容保留内容块顺序和未渲染文本，图片与文件使用默认折叠的展开项，包含完整的已记录字段。
 
+请求在等待输出、流式生成或重试期间保持等待状态。尚无助手输出的请求不提供结果链接；中断的输出仍可检查，请求和助手记录都显示失败，即使步骤起点位于已加载历史之外。恢复后仍可查看重试次数与上次尝试错误；这些历史信息不改变请求当前的状态。模型回复完成并不表示其工具或轮次已经结束。
+
 检查器中的思考内容使用紧凑 Markdown，沿用检查器固定的 13px 字号和 20px 行高，不受内容字号设置影响。标题只加粗，不放大字号或行高。助手输出保留常规 Markdown 排版。
 
 ### 时间概览
 
-当记录的流包含 token 时间戳时，历史回复会保留 TTFT、生成耗时与吞吐量。TTFT 从步骤开始计量到首个 token，包括更早重试尝试中的输出；步骤起点尚未加载或流中没有 token 时，对应指标保持不可用。
+流式回复保留已知的开始时间与 TTFT。回复结束后，token 时间戳用于计算生成耗时；吞吐量还需要已记录的用量。历史回复保留相同的已记录计时。TTFT 从步骤开始计量到首个 token，包括更早重试尝试中的输出；步骤起点尚未加载或流中没有 token 时，对应指标保持不可用。
 
 固定在记录表上方的 Overview 区域从左到右投影记录的真实开始时间与耗时；助手时间条区分记录到的 TTFT 与解码时间，悬停 500 ms 后可查看精确时刻与耗时详情。拖选区间会把记录表聚焦到该闭区间内任何时刻处于活动的记录；滚轮手势用于缩放时间域；右键单击会清除所选区间，在已放大的视口上按住右键拖动则会平移。初始视图与流式更新都停留在尾部；向上滚动会暂停跟随，因此新记录不会打断对旧记录的检查。
 
@@ -53,9 +55,9 @@ Trajectory 标签页让你以按轮次组织的事件记录表和交互式时间
 
 视图是纯投影：Trajectory 自有的定义从共享会话窗口组装业务记录——包括因取消而定稿并持久保留的前缀、仅有分片时采用的中断回退记录，以及被中断的工具记录——因此 Trajectory 既不读取也不改变 Chat 会话快照。其 steering（中途引导）分类器通过持续保留的拼接状态只保留下一步的 Inbox ID，并让后续上下文共享当前已认领的每个批次。
 
-原生与嵌套 PTC 工具结果保留原始结构化错误详情。失败记录在记录表中显示错误代码，在检查器中显示错误名称和代码。
+原生与嵌套 PTC 工具结果保留原始结构化错误详情和展示元数据。失败记录在记录表中显示错误代码，在检查器中显示错误名称和代码。
 
-工具记录从持久 tool/call 事件开始，使用完整参数。Chat 的瞬态 preparing 阶段不创建 Trajectory 工具行，也不改变历史工具计时。
+工具记录从持久 tool/call 事件开始，保留完整参数文本和由配对结果复用的懒计算 `args` 视图。Chat 的瞬态 preparing 阶段不创建 Trajectory 工具行，也不改变历史工具计时。
 
 完整的追加提示词在请求头未加载时显示为独立系统行；仅提供已知文本，不推断请求选项或工具目录。补入其请求历史后，该独立展示被替代而不重复提示词。历史中的系统提示词变更与最近的请求状态比较，包括没有新请求头的先前提示词更新。每个请求保留其所在位置生效的提示词与变更。包括压缩在内的 surface 替换会恢复最后一个非空的存活系统提示词，即使没有新的系统事件；未加载的提示词在对应分页到达前仍不可用。
 
@@ -112,5 +114,3 @@ Trajectory 要求会话壳把 composer 作为浮层置于全高记录表上方
 无。
 
 </details>
-
-**运行时不变式：** 不发布伴生入口。这是纯消费插件，不发出 Cordis 事件，也不持有跨插件可变状态；其 view-slot 注册是普通 effect，slot ledger 自身的规格测试与本包的行为规格测试会直接观察其释放。

package/lib/client.js

@@ -211,9 +211,9 @@ window.__ModuleLoader__.load({
 			"details.toolCalls": "工具调用",
 			"details.subtoolCalls": "子工具调用",
 			"details.error": "错误",
+			"details.lastAttemptError": "上次尝试错误",
 			"details.failure.auth": "API 密钥无效",
 			"details.retry": "重试",
-			"details.scheduled": "已计划",
 			"details.retryDelay": "重试延迟",
 			"details.result": "结果",
 			"details.compacted": "已压缩",
@@ -406,9 +406,9 @@ window.__ModuleLoader__.load({
 			"details.toolCalls": "Tool calls",
 			"details.subtoolCalls": "Subtool calls",
 			"details.error": "Error",
+			"details.lastAttemptError": "Last attempt error",
 			"details.failure.auth": "API key is invalid",
 			"details.retry": "Retry",
-			"details.scheduled": "Scheduled",
 			"details.retryDelay": "Retry delay",
 			"details.result": "Result",
 			"details.compacted": "Compacted",
@@ -445,6 +445,648 @@ window.__ModuleLoader__.load({
 			"layout.compactionInterrupted": "Compaction was interrupted before completion."
 		};
 		//#endregion
+		//#region ../../util/values/src/partial-json.ts
+		/**
+		* Lazily scanned view of one JSON object's top-level fields, built from text
+		* that may still be streaming or from an already parsed object. Nothing is
+		* scanned until a reader asks; the view remembers every question it answered
+		* and reports changed answers when the owner refreshes for publication.
+		* Used for model tool-call arguments: a row reads the fields it
+		* cares about at whatever granularity it displays, at every stage of the call.
+		* @module @deepseek-ai/dsh-util-values/src/partial-json
+		*/
+		const SIMPLE_ESCAPES = {
+			"\"": "\"",
+			"\\": "\\",
+			"/": "/",
+			b: "\b",
+			f: "\f",
+			n: "\n",
+			r: "\r",
+			t: "	"
+		};
+		const CONTENT_ESCAPE = /[\\\u0000-\u001f]/u;
+		function isWhitespace(c) {
+			return c === " " || c === "\n" || c === "\r" || c === "	";
+		}
+		function isHex(c) {
+			return c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+		}
+		/**
+		* The view. A streaming instance grows through {@link PartialArguments.append};
+		* {@link PartialArguments.fromText} and {@link PartialArguments.fromObject} build
+		* sealed instances over a finished call. Every reader is total: an absent or
+		* differently typed field answers `undefined` (or `false`), never throws.
+		*/
+		var PartialArguments = class PartialArguments {
+			/** The view of a call with no arguments available. */
+			static EMPTY = PartialArguments.fromObject({});
+			/**
+			* View finished argument text without scanning it until a reader asks.
+			* @param text - the complete argument JSON text.
+			* @returns a sealed view.
+			*/
+			static fromText(text) {
+				const view = new PartialArguments();
+				view.append(text);
+				view.sealed = true;
+				return view;
+			}
+			/**
+			* View an already parsed argument payload, such as a PTC dispatch object.
+			* @param value - the parsed argument value.
+			* @returns a sealed view; a non-object payload has no fields.
+			*/
+			static fromObject(value) {
+				const view = new PartialArguments();
+				view.object = typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+				view.sealed = true;
+				return view;
+			}
+			/**
+			* The source: text so far or a parsed object, plus whether it can still grow.
+			* These are the only enumerable fields, so two views over the same source
+			* compare equal structurally however far each has been read.
+			*/
+			chunks = [];
+			object;
+			sealed = false;
+			#ends = [];
+			#size = 0;
+			#consumed = 0;
+			#mode = "root";
+			#escape = false;
+			#keyStart = 0;
+			#keyEscaped = false;
+			#key = "";
+			#current = null;
+			#nestedEnds = [];
+			#nestedInString = false;
+			#invalidAt;
+			#invalidValue = false;
+			#entries = /* @__PURE__ */ new Map();
+			#order = [];
+			#reads = /* @__PURE__ */ new Map();
+			/** Whether this view rejects further appends; does not scan text or register reads. */
+			get isSealed() {
+				return this.sealed;
+			}
+			/** Whether indexing or a content read found invalid JSON; unread value contents are not validated. */
+			get invalid() {
+				this.scan();
+				return this.#mode === "invalid" || this.#invalidValue;
+			}
+			/**
+			* Retain streamed argument text without scanning or comparing observed answers.
+			* @param fragment - the text following every fragment appended before.
+			*/
+			append(fragment) {
+				if (this.sealed) throw new Error("PartialArguments: cannot append to a sealed view");
+				if (fragment.length === 0) return;
+				this.chunks.push(fragment);
+				this.#size += fragment.length;
+				this.#ends.push(this.#size);
+			}
+			/**
+			* Reconcile a streamed prefix with authoritative complete text without joining the fragments.
+			* @param text - the final argument text, which replaces missing or conflicting deltas.
+			* @returns this view sealed with its caches retained when every character matches; otherwise a new sealed view.
+			*/
+			settle(text) {
+				if (this.object !== void 0 || text.length !== this.#size) return PartialArguments.fromText(text);
+				let offset = 0;
+				for (const chunk of this.chunks) {
+					if (!text.startsWith(chunk, offset)) return PartialArguments.fromText(text);
+					offset += chunk.length;
+				}
+				this.chunks = text.length === 0 ? [] : [text];
+				this.#ends = text.length === 0 ? [] : [text.length];
+				this.sealed = true;
+				return this;
+			}
+			/**
+			* Compare observed answers and advance their publication baseline. Unread views remain unscanned.
+			* @returns whether any observed answer changed since its first read or the preceding refresh.
+			*/
+			refresh() {
+				if (this.#reads.size === 0) return false;
+				this.scan();
+				let changed = false;
+				let completions = false;
+				for (const read of this.#reads.values()) {
+					if (read.completion) {
+						completions = true;
+						continue;
+					}
+					changed = this.refreshRead(read) || changed;
+				}
+				if (completions) {
+					for (const read of this.#reads.values()) if (read.completion) changed = this.refreshRead(read) || changed;
+				}
+				if (this.sealed) this.#reads.clear();
+				return changed;
+			}
+			refreshRead(read) {
+				const now = read.answer();
+				if (Object.is(now, read.last)) return false;
+				read.last = now;
+				return true;
+			}
+			/**
+			* Check whether no further fields can arrive.
+			* @returns whether the outer object closed, indexing failed, or the view is sealed; unread values are not validated.
+			*/
+			closed() {
+				return this.remember("closed", "", () => this.closedNow());
+			}
+			/**
+			* List discovered fields in first-appearance order.
+			* @returns top-level keys seen so far, in first-appearance order.
+			*/
+			keys() {
+				return this.remember("keys", "", () => this.keysNow(), (keys) => keys.length);
+			}
+			/**
+			* Check whether a top-level field has appeared.
+			* @param key - argument name.
+			* @returns whether the field has appeared (a string opened or another value began).
+			*/
+			has(key) {
+				return this.remember("has", key, () => this.hasNow(key));
+			}
+			/**
+			* Check whether a field's closing delimiter has arrived, without validating its contents.
+			* @param key - argument name.
+			* @returns whether its delimiter arrived and no content reader has reported an error for this value.
+			*/
+			complete(key) {
+				return this.remember("complete", key, () => this.completeNow(key));
+			}
+			/**
+			* Read string length without materializing its text.
+			* @param key - argument name.
+			* @param options - change granularity for a streaming string.
+			* @returns decoded UTF-16 length of the string field so far; undefined when absent or not a string.
+			*/
+			stringLength(key, options) {
+				const step = Math.max(1, Math.floor(options?.step ?? 1));
+				const offset = options?.offset ?? 0;
+				return this.remember(`length:${step}:${offset}`, key, () => this.lengthNow(key), (length) => length === void 0 ? void 0 : Math.ceil((length + offset) / step));
+			}
+			/**
+			* Check a string against a decoded UTF-16 length limit without materializing it.
+			* @param key - argument name.
+			* @param maxLength - decoded UTF-16 limit, floored to at least zero.
+			* @returns whether the string is longer than the limit; false when absent or not a string.
+			*/
+			stringExceeds(key, maxLength) {
+				const limit = Math.max(0, Math.floor(maxLength));
+				return this.remember(`exceeds:${limit}`, key, () => (this.lengthNow(key, limit + 1) ?? 0) > limit);
+			}
+			/**
+			* Read a decoded string, including a streaming prefix.
+			* @param key - argument name.
+			* @returns the string field's decoded text so far; undefined when absent or not a string.
+			*/
+			text(key) {
+				return this.remember("text", key, () => this.textNow(key));
+			}
+			/**
+			* Read at most the first decoded UTF-16 units of a string.
+			* @param key - argument name.
+			* @param maxLength - maximum decoded UTF-16 length, floored to at least one.
+			* @returns the bounded string prefix; undefined when absent or not a string.
+			*/
+			textPrefix(key, maxLength) {
+				const limit = Math.max(1, Math.floor(maxLength));
+				return this.remember(`prefix:${limit}`, key, () => this.textPrefixNow(key, limit));
+			}
+			/**
+			* Read a completed non-string argument.
+			* @param key - argument name.
+			* @returns the parsed non-string value once it closed; undefined while open, absent, or a string.
+			*/
+			value(key) {
+				return this.remember("value", key, () => this.valueNow(key));
+			}
+			/** Answer a question and, on a streaming view, remember it for change detection. */
+			remember(kind, key, read, comparison) {
+				this.scan();
+				const result = read();
+				if (!this.sealed) {
+					const id = `${kind}/${key}`;
+					if (!this.#reads.has(id)) this.#reads.set(id, {
+						completion: kind === "complete",
+						answer: comparison === void 0 ? read : () => comparison(read()),
+						last: comparison === void 0 ? result : comparison(result)
+					});
+				}
+				return result;
+			}
+			closedNow() {
+				return this.sealed || this.#mode === "closed" || this.#mode === "invalid";
+			}
+			keysNow() {
+				return this.object === void 0 ? this.#order : Object.keys(this.object);
+			}
+			hasNow(key) {
+				return this.object === void 0 ? this.#entries.has(key) : Object.hasOwn(this.object, key);
+			}
+			completeNow(key) {
+				if (this.object !== void 0) return Object.hasOwn(this.object, key);
+				const entry = this.#entries.get(key);
+				return entry !== void 0 && entry.end >= 0 && (entry.kind === "string" ? entry.invalidAt === void 0 : !entry.invalid);
+			}
+			lengthNow(key, limit = Number.POSITIVE_INFINITY) {
+				if (this.object !== void 0) {
+					const field = Object.hasOwn(this.object, key) ? this.object[key] : void 0;
+					return typeof field === "string" ? field.length : void 0;
+				}
+				const entry = this.#entries.get(key);
+				if (entry?.kind !== "string") return void 0;
+				if (entry.text !== void 0 && entry.text.at === entry.end) return entry.text.length;
+				const read = entry.length ??= {
+					at: entry.start,
+					length: 0,
+					text: ""
+				};
+				this.readString(entry, read, limit, false);
+				return read.length;
+			}
+			textNow(key) {
+				if (this.object !== void 0) {
+					const field = Object.hasOwn(this.object, key) ? this.object[key] : void 0;
+					return typeof field === "string" ? field : void 0;
+				}
+				const entry = this.#entries.get(key);
+				if (entry?.kind !== "string") return void 0;
+				if (entry.text === void 0 && entry.end >= 0 && entry.needsDecoding && entry.invalidAt === void 0) {
+					let text;
+					try {
+						text = JSON.parse(`"${this.slice(entry.start, entry.end)}"`);
+					} catch (_error) {}
+					if (text !== void 0) entry.text = {
+						at: entry.end,
+						length: text.length,
+						text
+					};
+				}
+				const read = entry.text ??= {
+					at: entry.start,
+					length: 0,
+					text: ""
+				};
+				this.readString(entry, read, Number.POSITIVE_INFINITY, true);
+				return read.text;
+			}
+			textPrefixNow(key, maxLength) {
+				if (this.object !== void 0) {
+					const field = Object.hasOwn(this.object, key) ? this.object[key] : void 0;
+					return typeof field === "string" ? field.slice(0, maxLength) : void 0;
+				}
+				const entry = this.#entries.get(key);
+				if (entry?.kind !== "string") return void 0;
+				const prefixes = entry.prefixes ??= /* @__PURE__ */ new Map();
+				let read = prefixes.get(maxLength);
+				if (read === void 0) {
+					read = {
+						at: entry.start,
+						length: 0,
+						text: ""
+					};
+					prefixes.set(maxLength, read);
+				}
+				this.readString(entry, read, maxLength, true);
+				return read.text;
+			}
+			valueNow(key) {
+				if (this.object !== void 0) {
+					if (!Object.hasOwn(this.object, key)) return void 0;
+					const field = this.object[key];
+					return typeof field === "string" ? void 0 : field;
+				}
+				const entry = this.#entries.get(key);
+				if (entry?.kind !== "value" || entry.end < 0 || entry.invalid) return void 0;
+				if (entry.parsed === void 0) try {
+					entry.parsed = JSON.parse(this.slice(entry.start, entry.end));
+				} catch (_error) {
+					entry.invalid = true;
+					this.#invalidValue = true;
+				}
+				return entry.parsed;
+			}
+			chunkAt(at) {
+				let low = 0;
+				let high = this.#ends.length;
+				while (low < high) {
+					const mid = low + high >>> 1;
+					if (this.#ends[mid] <= at) low = mid + 1;
+					else high = mid;
+				}
+				return low;
+			}
+			/** Materialize only a requested range, never the cumulative source. */
+			slice(start, end) {
+				if (start >= end) return "";
+				const first = this.chunkAt(start);
+				const last = this.chunkAt(end - 1);
+				const base = first === 0 ? 0 : this.#ends[first - 1];
+				if (first === last) return this.chunks[first].slice(start - base, end - base);
+				const parts = [this.chunks[first].slice(start - base)];
+				for (let i = first + 1; i < last; i++) parts.push(this.chunks[i]);
+				parts.push(this.chunks[last].slice(0, end - this.#ends[last - 1]));
+				return parts.join("");
+			}
+			readString(entry, read, limit, materialize) {
+				const end = Math.min(entry.end < 0 ? this.#consumed : entry.end, entry.invalidAt ?? Number.POSITIVE_INFINITY, this.#invalidAt ?? Number.POSITIVE_INFINITY);
+				if (!entry.needsDecoding) {
+					const length = Math.min(end - read.at, limit - read.length);
+					if (length <= 0) return;
+					if (materialize) read.text += this.slice(read.at, read.at + length);
+					read.at += length;
+					read.length += length;
+					return;
+				}
+				let chunkIndex = this.chunkAt(read.at);
+				while (read.at < end && read.length < limit) {
+					const base = chunkIndex === 0 ? 0 : this.#ends[chunkIndex - 1];
+					const chunk = this.chunks[chunkIndex];
+					const remaining = chunk.slice(read.at - base, Math.min(chunk.length, end - base));
+					const boundary = remaining.search(CONTENT_ESCAPE);
+					const length = Math.min(boundary < 0 ? remaining.length : boundary, limit - read.length);
+					if (length > 0) {
+						if (materialize) read.text += remaining.slice(0, length);
+						read.at += length;
+						read.length += length;
+						if (read.at === base + chunk.length) chunkIndex++;
+						continue;
+					}
+					const type = remaining.length > 1 ? remaining[1] : read.at + 1 < end ? this.chunks[chunkIndex + 1][0] : void 0;
+					let decoded;
+					let width = 2;
+					if (remaining[0] === "\\" && type === void 0 && entry.end < 0) return;
+					if (remaining[0] === "\\" && type === "u") {
+						const hex = this.slice(read.at + 2, Math.min(end, read.at + 6));
+						let valid = true;
+						for (let i = 0; i < hex.length; i++) if (!isHex(hex[i])) valid = false;
+						if (valid) {
+							if (hex.length < 4 && entry.end < 0) return;
+							if (hex.length === 4) decoded = String.fromCharCode(Number.parseInt(hex, 16));
+						}
+						width = 6;
+					} else if (remaining[0] === "\\" && type !== void 0) decoded = SIMPLE_ESCAPES[type];
+					if (decoded === void 0) {
+						entry.invalidAt = read.at;
+						this.#invalidValue = true;
+						return;
+					}
+					if (materialize) read.text += decoded;
+					read.length++;
+					read.at += width;
+					while (chunkIndex < this.chunks.length && read.at >= this.#ends[chunkIndex]) chunkIndex++;
+				}
+			}
+			/** Locate new field ranges without decoding or parsing their contents. */
+			scan() {
+				if (this.object !== void 0 || this.#consumed === this.#size) return;
+				for (let i = this.chunkAt(this.#consumed); i < this.chunks.length && this.#invalidAt === void 0; i++) {
+					const pending = this.chunks[i];
+					const base = i === 0 ? 0 : this.#ends[i - 1];
+					for (let index = this.#consumed - base; index < pending.length && this.#mode !== "invalid"; index++) {
+						if (this.#mode === "string" || this.#mode === "nested" && this.#nestedInString) {
+							const end = this.stringBoundary(pending, index);
+							this.#consumed += end - index;
+							index = end;
+							if (index === pending.length) break;
+						}
+						this.step(pending[index], this.#consumed);
+						this.#consumed++;
+					}
+				}
+			}
+			/** Only raw quotes and their preceding backslash runs can terminate a string. */
+			stringBoundary(fragment, start) {
+				let at = start;
+				while (true) {
+					const quote = fragment.indexOf("\"", at);
+					const end = quote < 0 ? fragment.length : quote;
+					if (this.#mode === "string") {
+						const entry = this.#current;
+						if (!entry.needsDecoding && CONTENT_ESCAPE.test(fragment.slice(at, end))) entry.needsDecoding = true;
+					}
+					let slashStart = end;
+					while (slashStart > at && fragment[slashStart - 1] === "\\") slashStart--;
+					const escaped = (end - slashStart) % 2 === 1 !== (slashStart === at && this.#escape);
+					this.#escape = quote < 0 && escaped;
+					if (quote < 0 || !escaped) return end;
+					at = quote + 1;
+				}
+			}
+			step(c, at) {
+				switch (this.#mode) {
+					case "root":
+						if (isWhitespace(c)) return;
+						if (c === "{") {
+							this.#mode = "key-or-end";
+							return;
+						}
+						this.fail();
+						return;
+					case "key-or-end":
+						if (isWhitespace(c)) return;
+						if (c === "}") {
+							this.#mode = "closed";
+							return;
+						}
+						if (c === "\"") {
+							this.beginKey(at);
+							return;
+						}
+						this.fail();
+						return;
+					case "key-only":
+						if (isWhitespace(c)) return;
+						if (c === "\"") {
+							this.beginKey(at);
+							return;
+						}
+						this.fail();
+						return;
+					case "key":
+						this.stepKey(c, at);
+						return;
+					case "colon":
+						if (isWhitespace(c)) return;
+						if (c === ":") {
+							this.#mode = "value";
+							return;
+						}
+						this.fail();
+						return;
+					case "value":
+						this.beginValue(c, at);
+						return;
+					case "string": {
+						const entry = this.#current;
+						entry.end = at;
+						this.#current = null;
+						this.#mode = "comma-or-end";
+						return;
+					}
+					case "scalar":
+						this.stepScalar(c, at);
+						return;
+					case "nested":
+						this.stepNested(c, at);
+						return;
+					case "comma-or-end":
+						if (isWhitespace(c)) return;
+						if (c === ",") {
+							this.#mode = "key-only";
+							return;
+						}
+						if (c === "}") {
+							this.#mode = "closed";
+							return;
+						}
+						this.fail();
+						return;
+					case "closed":
+						if (isWhitespace(c)) return;
+						this.fail();
+						return;
+					/* v8 ignore next 2 -- scan() stops stepping once the view is invalid. */
+					case "invalid": return;
+					/* v8 ignore next 2 -- Every scanner mode has a handler above. */
+					default: assertNever(this.#mode);
+				}
+			}
+			fail() {
+				this.#invalidAt = this.#consumed;
+				this.#mode = "invalid";
+				this.#current = null;
+			}
+			beginKey(at) {
+				this.#mode = "key";
+				this.#keyStart = at + 1;
+				this.#keyEscaped = false;
+				this.#escape = false;
+			}
+			stepKey(c, at) {
+				if (c < " ") {
+					this.fail();
+					return;
+				}
+				if (this.#escape) {
+					this.#escape = false;
+					return;
+				}
+				if (c === "\\") {
+					this.#escape = true;
+					this.#keyEscaped = true;
+					return;
+				}
+				if (c !== "\"") return;
+				const raw = this.slice(this.#keyStart, at);
+				if (this.#keyEscaped) try {
+					this.#key = JSON.parse(`"${raw}"`);
+				} catch (_error) {
+					this.fail();
+					return;
+				}
+				else this.#key = raw;
+				this.#mode = "colon";
+			}
+			open(entry) {
+				if (!this.#entries.has(this.#key)) this.#order.push(this.#key);
+				this.#entries.set(this.#key, entry);
+				this.#current = entry;
+			}
+			beginValue(c, at) {
+				if (isWhitespace(c)) return;
+				if (c === "\"") {
+					this.open({
+						kind: "string",
+						start: at + 1,
+						end: -1,
+						needsDecoding: false,
+						invalidAt: void 0,
+						length: void 0,
+						text: void 0,
+						prefixes: void 0
+					});
+					this.#escape = false;
+					this.#mode = "string";
+					return;
+				}
+				if (c === "}" || c === "," || c === ":" || c === "]") {
+					this.fail();
+					return;
+				}
+				this.open({
+					kind: "value",
+					start: at,
+					end: -1,
+					parsed: void 0,
+					invalid: false
+				});
+				if (c === "{" || c === "[") {
+					this.#mode = "nested";
+					this.#nestedEnds = [c === "{" ? "}" : "]"];
+					this.#nestedInString = false;
+					this.#escape = false;
+					return;
+				}
+				this.#mode = "scalar";
+			}
+			stepScalar(c, at) {
+				if (c !== "," && c !== "}" && !isWhitespace(c)) return;
+				this.closeValue(at);
+				this.#mode = c === "," ? "key-only" : c === "}" ? "closed" : "comma-or-end";
+			}
+			stepNested(c, at) {
+				if (this.#nestedInString) {
+					this.#nestedInString = false;
+					return;
+				}
+				if (c === "\"") {
+					this.#nestedInString = true;
+					return;
+				}
+				if (c === "{" || c === "[") {
+					this.#nestedEnds.push(c === "{" ? "}" : "]");
+					return;
+				}
+				if (c === "}" || c === "]") {
+					if (this.#nestedEnds.pop() !== c) {
+						this.fail();
+						return;
+					}
+					if (this.#nestedEnds.length === 0) {
+						this.closeValue(at + 1);
+						this.#mode = "comma-or-end";
+					}
+				}
+			}
+			closeValue(end) {
+				const entry = this.#current;
+				entry.end = end;
+				this.#current = null;
+			}
+		};
+		//#endregion
+		//#region ../../util/values/src/index.ts
+		/**
+		* Mark an unreachable closed-union branch.
+		* @param value - impossible value; an unhandled typed variant fails at the call site.
+		* @param context - optional switch-site label included in the failure message.
+		* @returns never; a runtime value that escaped its type always throws.
+		*/
+		function assertNever(value, context) {
+			const rendered = JSON.stringify(value) ?? String(value);
+			throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+		}
+		//#endregion
 		//#region ../../llm/llm/src/assistant-stream.ts
 		/**
 		* Whether one chunk carries the model's first output token for latency measurement.
@@ -692,7 +1334,6 @@ window.__ModuleLoader__.load({
 				startSeq,
 				startTime,
 				started,
-				sawChunk: false,
 				blocks: [],
 				visibleBlocks: 0,
 				firstVisibleSeq: void 0,
@@ -735,7 +1376,6 @@ window.__ModuleLoader__.load({
 		function updateChunk(state, chunk, seq, time) {
 			if (chunk.type === "usage") return {
 				...state,
-				sawChunk: true,
 				usage: addUsage$1(state.usage, chunk.usage)
 			};
 			const blocks = [...state.blocks];
@@ -790,15 +1430,11 @@ window.__ModuleLoader__.load({
 					previousVisible = blockIsVisible(blocks[chunk.index]);
 					blocks[chunk.index] = toAssistantBlock(chunk.block);
 					break;
-				default: return {
-					...state,
-					sawChunk: true
-				};
+				default: return state;
 			}
 			const visibleBlocks = state.visibleBlocks - Number(previousVisible) + Number(blockIsVisible(blocks[changedIndex]));
 			return {
 				...state,
-				sawChunk: true,
 				blocks,
 				visibleBlocks,
 				...visibleBlocks > 0 && state.firstVisibleSeq === void 0 ? {
@@ -819,7 +1455,6 @@ window.__ModuleLoader__.load({
 			const blocks = toAssistantBlocks(event.data.message.content);
 			return {
 				...settleTiming(state, event),
-				sawChunk: false,
 				blocks,
 				visibleBlocks: countVisibleBlocks(blocks),
 				final: match,
@@ -893,7 +1528,7 @@ window.__ModuleLoader__.load({
 		}
 		function assistantRequest(state, node, boundary) {
 			if (!state.started) return void 0;
-			const status = node !== void 0 && node.interrupted !== true ? "complete" : state.retry !== void 0 || boundary !== void 0 ? "error" : "running";
+			const status = node !== void 0 ? node.interrupted === true ? "error" : "complete" : boundary !== void 0 ? "error" : "running";
 			return {
 				purpose: "assistant",
 				startSeq: state.startSeq,
@@ -970,10 +1605,14 @@ window.__ModuleLoader__.load({
 				if (state === void 0) return null;
 				const node = finalNode(state, context);
 				const boundary = closedBoundary(context);
-				const partial = node === void 0 && boundary === void 0 && state.sawChunk ? {
+				const partial = node === void 0 && boundary === void 0 && state.blocks.length > 0 ? {
 					turn: state.turn,
 					step: state.step,
-					blocks: compactBlocks(state.blocks)
+					blocks: compactBlocks(state.blocks),
+					timing: {
+						stepStartTime: state.started ? state.startTime : null,
+						firstTokenTime: state.firstTokenTime ?? null
+					}
 				} : null;
 				const request = assistantRequest(state, node, boundary);
 				if (node === void 0 && partial === null && request === void 0) return null;
@@ -1654,6 +2293,7 @@ window.__ModuleLoader__.load({
 				callId: String(match.event.data.callId),
 				name: match.event.data.name,
 				argsRaw: match.event.data.arguments,
+				args: PartialArguments.fromText(match.event.data.arguments),
 				turn: match.event.data.turn,
 				step: match.event.data.step,
 				time: match.event.time,
@@ -1668,6 +2308,8 @@ window.__ModuleLoader__.load({
 				seq: match.event.seq,
 				time: match.event.time,
 				callId: String(message.source.callId),
+				name: previous?.name ?? "",
+				args: previous?.args ?? PartialArguments.EMPTY,
 				call: previous === void 0 ? null : {
 					name: previous.name,
 					argsRaw: previous.argsRaw
@@ -1693,6 +2335,7 @@ window.__ModuleLoader__.load({
 				parentCallId: data.parentCallId,
 				name: data.name,
 				argsRaw: JSON.stringify(data.arguments),
+				args: PartialArguments.fromObject(data.arguments),
 				turn: locationTurn(match),
 				step: locationStep(match),
 				time: match.event.time,
@@ -1706,12 +2349,15 @@ window.__ModuleLoader__.load({
 				time: match.event.time,
 				callId: data.subCallId,
 				parentCallId: data.parentCallId,
+				name: data.name,
+				args: previous?.args ?? PartialArguments.fromObject(data.arguments),
 				call: {
 					name: data.name,
 					argsRaw: JSON.stringify(data.arguments)
 				},
 				callTime: previous === void 0 || "kind" in previous ? null : previous.time,
 				content: data.content ?? [],
+				meta: data.meta,
 				isError: data.isError === true,
 				...data.error === void 0 ? {} : { error: data.error },
 				subCalls: []
@@ -1800,6 +2446,8 @@ window.__ModuleLoader__.load({
 				time: interruptedAt.time,
 				callId: block.callId,
 				...block.parentCallId === void 0 ? {} : { parentCallId: block.parentCallId },
+				name: block.name,
+				args: block.args,
 				call: {
 					name: block.name,
 					argsRaw: block.argsRaw
@@ -1890,7 +2538,7 @@ window.__ModuleLoader__.load({
 			ctx.uiConversation.events.register(trajectoryToolDefinition);
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.7/node_modules/@tanstack/virtual-core/dist/esm/lazy-measurements.js
+		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/lazy-measurements.js
 		function createLazyMeasurementsView(count, flat, getItemKey) {
 			const cache = new Array(count);
 			return new Proxy(cache, { get(target, prop, receiver) {
@@ -1920,7 +2568,7 @@ window.__ModuleLoader__.load({
 			} });
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.7/node_modules/@tanstack/virtual-core/dist/esm/utils.js
+		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/utils.js
 		function memo$1(getDeps, fn, opts) {
 			let deps = opts.initialDeps ?? [];
 			let result;
@@ -1946,13 +2594,15 @@ window.__ModuleLoader__.load({
 		const approxEqual = (a, b) => Math.abs(a - b) < 1.01;
 		const debounce = (targetWindow, fn, ms) => {
 			let timeoutId;
-			return function(...args) {
+			return Object.assign(function(...args) {
 				targetWindow.clearTimeout(timeoutId);
 				timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
-			};
+			}, { cancel: () => {
+				targetWindow.clearTimeout(timeoutId);
+			} });
 		};
 		//#endregion
-		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.7/node_modules/@tanstack/virtual-core/dist/esm/index.js
+		//#region ../../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/index.js
 		let _isIOSResult;
 		const isIOSWebKit = () => {
 			if (_isIOSResult !== void 0) return _isIOSResult;
@@ -2034,6 +2684,7 @@ window.__ModuleLoader__.load({
 			return () => {
 				element.removeEventListener("scroll", handler);
 				if (registerScrollendEvent) element.removeEventListener("scrollend", endHandler);
+				fallback?.cancel();
 			};
 		};
 		const observeElementOffset = (instance, cb) => observeOffset(instance, cb, (el) => {
@@ -2115,6 +2766,7 @@ window.__ModuleLoader__.load({
 										}
 										return;
 									}
+									if (!this.isIndexInRange(index)) return;
 									if (this.shouldMeasureDuringScroll(index)) this.resizeItem(index, this.options.measureElement(node, entry, this));
 								};
 								this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
@@ -2258,6 +2910,8 @@ window.__ModuleLoader__.load({
 						this.rafId = null;
 					}
 					this.scrollState = null;
+					this.isScrolling = false;
+					this.scrollDirection = null;
 					this._iosDeferredAdjustment = 0;
 					this._iosTouching = false;
 					this._iosJustTouchEnded = false;
@@ -2410,6 +3064,7 @@ window.__ModuleLoader__.load({
 						gap
 					};
 				}, { key: false });
+				this.isIndexInRange = (index) => index >= 0 && index < this.options.count;
 				this.getMeasurements = memo$1(() => [this.getMeasurementOptions(), this.itemSizeCacheVersion], ({ count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode, gap }, _itemSizeCacheVersion) => {
 					const itemSizeCache = this.itemSizeCache;
 					if (!enabled) {
@@ -2608,6 +3263,7 @@ window.__ModuleLoader__.load({
 						return;
 					}
 					const index = this.indexFromElement(node);
+					if (!this.isIndexInRange(index)) return;
 					const key = this.options.getItemKey(index);
 					const prevNode = this.elementsCache.get(key);
 					if (prevNode !== node) {
@@ -2619,7 +3275,7 @@ window.__ModuleLoader__.load({
 				};
 				this.resizeItem = (index, size) => {
 					var _a, _b;
-					if (index < 0 || index >= this.options.count) return;
+					if (!this.isIndexInRange(index)) return;
 					let cachedSize;
 					let itemStart;
 					let key;
@@ -2966,7 +3622,7 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region ../../../node_modules/.pnpm/@tanstack+react-virtual@3.14.9_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@tanstack/react-virtual/dist/esm/index.js
+		//#region ../../../node_modules/.pnpm/@tanstack+react-virtual@3.14.10_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@tanstack/react-virtual/dist/esm/index.js
 		const useIsomorphicLayoutEffect = typeof document !== "undefined" ? react.useLayoutEffect : react.useEffect;
 		function useVirtualizerBase({ useFlushSync = true, directDomUpdates = false, directDomUpdatesMode = "transform", ...options }) {
 			const rerender = react.useReducer((x) => x + 1, 0)[1];
@@ -4406,6 +5062,7 @@ window.__ModuleLoader__.load({
 		function stateOf(record) {
 			if (record.cell.isError) return "error";
 			if (record.cell.kind === "compacted" && record.cell.timeSeconds === null) return "running";
+			if (record.cell.assistantMetrics?.completedTime === null) return "running";
 			if ((record.cell.kind === "tool" || record.cell.kind === "subtool") && record.cell.outputDetail === void 0) return "running";
 			return "complete";
 		}
@@ -5566,7 +6223,7 @@ window.__ModuleLoader__.load({
 			const selectedState = selected === void 0 ? void 0 : stateOf(selected);
 			const selectedRequestInfo = selectedRequest === null ? void 0 : sessionRequestNumbers?.find((request) => requestIdentity(request) === selectedRequest.identity);
 			const selectedRequestRecords = (0, react.useMemo)(() => selectedRequestInfo === void 0 ? [] : allRecords.filter((record) => record.turn === selectedRequestInfo.turn && record.group === selectedRequestInfo.group), [allRecords, selectedRequestInfo]).map(currentRecord);
-			const selectedRequestAssistant = selectedRequestRecords.find((record) => record.cell.kind === "message");
+			const selectedRequestAssistant = selectedRequestRecords.find((record) => record.cell.kind === "message" && record.cell.requestOnly !== true);
 			const selectedRequestAnchor = selectedRequestAssistant ?? selectedRequestRecords[0];
 			const selectedRequestNumber = selectedRequestInfo?.number;
 			const selectedRequestState = selectedRequestInfo === void 0 ? void 0 : selectedRequestInfo.status ?? (selectedRequestAssistant?.cell.assistantMetrics?.completedTime === null ? "running" : selectedRequestAssistant === void 0 && selectedRequestRecords.some((record) => stateOf(record) === "running") ? "running" : "complete");
@@ -6212,18 +6869,14 @@ window.__ModuleLoader__.load({
 										(selectedRequestInfo.model ?? selectedRequestInfo.requestConfig?.model) !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.model") }), (0, react_jsx_runtime.jsx)("dd", { children: selectedRequestInfo.model ?? selectedRequestInfo.requestConfig?.model })] }),
 										(0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.toolCalls") }), (0, react_jsx_runtime.jsx)("dd", { children: selectedRequestToolCalls })] }),
 										selectedRequestSubtoolCalls > 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.subtoolCalls") }), (0, react_jsx_runtime.jsx)("dd", { children: selectedRequestSubtoolCalls })] }),
-										selectedRequestInfo.error !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.error") }), (0, react_jsx_runtime.jsx)("dd", {
-											className: TrajectoryTable_module_css_default.error,
+										selectedRequestInfo.error !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t(selectedRequestState !== "error" && selectedRequestInfo.retry !== void 0 ? "details.lastAttemptError" : "details.error") }), (0, react_jsx_runtime.jsx)("dd", {
+											className: selectedRequestState === "error" ? TrajectoryTable_module_css_default.error : void 0,
 											children: requestErrorMessage(selectedRequestInfo, t)
 										})] }),
-										selectedRequestInfo.retry !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.retry") }), (0, react_jsx_runtime.jsxs)("dd", { children: [
-											t("details.scheduled"),
-											" ",
-											selectedRequestInfo.maxRetries === void 0 ? selectedRequestInfo.retry : t("request.retryProgress", {
-												retry: selectedRequestInfo.retry,
-												maximum: selectedRequestInfo.maxRetries
-											})
-										] })] }),
+										selectedRequestInfo.retry !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.retry") }), (0, react_jsx_runtime.jsx)("dd", { children: selectedRequestInfo.maxRetries === void 0 ? selectedRequestInfo.retry : t("request.retryProgress", {
+											retry: selectedRequestInfo.retry,
+											maximum: selectedRequestInfo.maxRetries
+										}) })] }),
 										selectedRequestInfo.retryDelayMs !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.retryDelay") }), (0, react_jsx_runtime.jsx)("dd", { children: formatDurationMs(selectedRequestInfo.retryDelayMs, t) })] }),
 										selectedRequestResult !== void 0 && (0, react_jsx_runtime.jsxs)("div", { children: [(0, react_jsx_runtime.jsx)("dt", { children: t("details.result") }), (0, react_jsx_runtime.jsx)("dd", {
 											className: TrajectoryTable_module_css_default.overviewParentLinks,
@@ -7672,7 +8325,10 @@ window.__ModuleLoader__.load({
 					turn: partial.turn,
 					step: partial.step,
 					blocks: partial.blocks
-				}, index + 1, prevAbsTime, resultByCall, callStartById, callById, t, { streaming: true }), t);
+				}, index + 1, prevAbsTime, resultByCall, callStartById, callById, t, {
+					streaming: true,
+					timing: partial.timing
+				}), t);
 				if (partial.step > 0) pushStep(partial.turn, partial.step, laidList);
 				else for (const laid of laidList) pushMessage(partial.turn, laid);
 				const last = laidList[laidList.length - 1];
@@ -7835,7 +8491,8 @@ window.__ModuleLoader__.load({
 			let index = startIndex - 1;
 			const usage = node.usage;
 			const streaming = opts?.streaming === true;
-			const recordedStart = finiteTime(node.timing?.stepStartTime);
+			const timing = opts?.timing ?? node.timing;
+			const recordedStart = finiteTime(timing?.stepStartTime);
 			const messageDuration = streaming ? null : durationSeconds(node.time, recordedStart ?? prevAbsTime);
 			const nodeAbs = streaming ? null : finiteTime(node.time);
 			const messageText = node.blocks.filter((block) => block.kind === "text" && (!streaming || block.text !== "")).map((block) => block.kind === "text" ? block.text : "").join("\n\n");
@@ -7850,14 +8507,15 @@ window.__ModuleLoader__.load({
 				...messageText !== "" ? { outputDetail: messageText } : {},
 				...thinkingText !== "" ? { thinkingDetail: thinkingText } : {},
 				sourceBlocks: node.blocks.map((block) => assistantSourceBlock(block)),
+				...node.interrupted === true ? { isError: true } : {},
 				timeSeconds: messageDuration,
 				startedAt: recordedStart
 			};
 			attachUsage(message, usage);
 			message.assistantMetrics = {
-				timingRecorded: node.timing !== void 0,
-				stepStartTime: node.timing?.stepStartTime ?? null,
-				firstTokenTime: node.timing?.firstTokenTime ?? null,
+				timingRecorded: timing !== void 0,
+				stepStartTime: timing?.stepStartTime ?? null,
+				firstTokenTime: timing?.firstTokenTime ?? null,
 				completedTime: streaming ? null : finiteTime(node.time),
 				usageProvided: usage !== void 0,
 				outputTokens: Number.isFinite(usage?.outputTokens) ? usage?.outputTokens ?? null : null
@@ -8410,18 +9068,21 @@ window.__ModuleLoader__.load({
 						const provider = request?.providerMetadata?.provider ?? node?.providerMetadata?.provider;
 						const model = request?.providerMetadata?.model ?? node?.providerMetadata?.model;
 						const requestConfig = request?.requestConfig ?? node?.requestConfig;
+						const startedAt = request?.startedAt;
+						const completedAt = request === void 0 ? node?.time : request.completedAt;
+						const resultSeq = request?.resultSeq ?? node?.seq;
 						numbered.push({
 							seq: entry.seq,
 							turn,
 							step,
 							group: t("group.step", { step }),
 							number: index + 1,
-							...request?.status === void 0 ? {} : { status: request.status },
-							...request?.startedAt === void 0 ? {} : { startedAt: request.startedAt },
-							...request?.completedAt === void 0 ? {} : { completedAt: request.completedAt },
+							status: request?.status ?? (node?.interrupted === true ? "error" : "complete"),
+							...startedAt === void 0 ? {} : { startedAt },
+							...completedAt === void 0 ? {} : { completedAt },
 							...request?.error === void 0 ? {} : { error: request.error },
 							...request?.errorCode === void 0 ? {} : { errorCode: request.errorCode },
-							...request?.resultSeq === void 0 ? {} : { resultSeq: request.resultSeq },
+							...resultSeq === void 0 ? {} : { resultSeq },
 							...request?.retry === void 0 ? {} : { retry: request.retry },
 							...request?.maxRetries === void 0 ? {} : { maxRetries: request.maxRetries },
 							...request?.retryDelayMs === void 0 ? {} : { retryDelayMs: request.retryDelayMs },
@@ -8446,7 +9107,7 @@ window.__ModuleLoader__.load({
 						completedAt: request.completedAt,
 						...request.error === void 0 ? {} : { error: request.error },
 						...request.errorCode === void 0 ? {} : { errorCode: request.errorCode },
-						resultSeq: request.startSeq,
+						...request.status === "running" ? {} : { resultSeq: request.startSeq },
 						...request.providerMetadata?.provider === void 0 ? {} : { provider: request.providerMetadata.provider },
 						...request.providerMetadata?.model === void 0 ? {} : { model: request.providerMetadata.model },
 						...request.requestConfig === void 0 ? {} : { requestConfig: request.requestConfig },
@@ -8491,14 +9152,20 @@ window.__ModuleLoader__.load({
 				callSchemas,
 				t
 			]);
+			const timelinePartialSignature = partialStructureSignature(partial);
+			const partialStartTime = partial?.timing?.stepStartTime;
+			const partialFirstTokenTime = partial?.timing?.firstTokenTime;
 			const timelinePartial = (0, react.useMemo)(() => partial === null ? null : {
 				turn: partial.turn,
 				step: partial.step,
-				blocks: partial.blocks.map((block) => timelineBlock(block))
+				blocks: partial.blocks.map((block) => timelineBlock(block)),
+				...partial.timing === void 0 ? {} : { timing: partial.timing }
 			}, [
 				partialStep,
 				partialTurn,
-				partialStructureSignature(partial)
+				timelinePartialSignature,
+				partialStartTime,
+				partialFirstTokenTime
 			]);
 			const timelineTurns = (0, react.useMemo)(() => appendTrajectoryPartialLayout(finalized.turns, timelinePartial, finalized.lastIndex, t), [
 				finalized,

package/lib/types/client/locales.d.ts

@@ -158,9 +158,9 @@ export declare const zh: {
     readonly 'details.toolCalls': "工具调用";
     readonly 'details.subtoolCalls': "子工具调用";
     readonly 'details.error': "错误";
+    readonly 'details.lastAttemptError': "上次尝试错误";
     readonly 'details.failure.auth': "API 密钥无效";
     readonly 'details.retry': "重试";
-    readonly 'details.scheduled': "已计划";
     readonly 'details.retryDelay': "重试延迟";
     readonly 'details.result': "结果";
     readonly 'details.compacted': "已压缩";

package/lib/types/client/trajectory-contract.d.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessageNode, ConversationLocation, ConversationNode, ConversationPromptSnapshot, ConversationViewNode, MessageImagesOwnerProps, PartialAssistant, RequestPromptChange, RequestView, RunningToolCall, SystemPromptNode, ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { AssistantMessageNode, AssistantTiming, ConversationLocation, ConversationNode, ConversationPromptSnapshot, ConversationViewNode, MessageImagesOwnerProps, PartialAssistant, RequestPromptChange, RequestView, RunningToolCall, SystemPromptNode, ToolCallBlock } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
 /** Request-header facts retained by the Trajectory target. */
 export interface TrajectoryRequestHeaderState {
@@ -8,6 +8,10 @@ export interface TrajectoryRequestHeaderState {
     readonly change?: RequestPromptChange;
     readonly location: ConversationLocation;
 }
+/** In-flight assistant output with the loaded Step start and first token timestamps. */
+export interface TrajectoryPartialAssistant extends PartialAssistant {
+    readonly timing?: Pick<AssistantTiming, 'stepStartTime' | 'firstTokenTime'>;
+}
 /** One independently assembled contribution to the legacy Trajectory ledger. */
 export type TrajectoryContribution = {
     readonly kind: 'system-prompt';
@@ -18,7 +22,7 @@ export type TrajectoryContribution = {
 } | {
     readonly kind: 'assistant';
     readonly node?: AssistantMessageNode;
-    readonly partial: PartialAssistant | null;
+    readonly partial: TrajectoryPartialAssistant | null;
     readonly request?: Extract<RequestView, {
         purpose: 'assistant';
     }>;
@@ -59,7 +63,7 @@ export interface TrajectorySnapshot {
     readonly eventLocations: ReadonlyMap<number, ConversationLocation>;
     readonly requests: readonly RequestView[];
     readonly callSchemas: ReadonlyMap<string, ConversationPromptSnapshot['tools'][number]>;
-    readonly partial: PartialAssistant | null;
+    readonly partial: TrajectoryPartialAssistant | null;
     readonly runningCalls: readonly RunningToolCall[];
 }
 /** Selector hook over the current Conversation binding's Trajectory target. */

package/lib/types/client/trajectory-record.d.ts

@@ -72,7 +72,7 @@ export interface TrajectoryCellProps extends HTMLAttributes<HTMLDivElement> {
     callId?: string;
     /** Recorded tool name; independent of the display summary. */
     toolName?: string;
-    /** Tool-only result failure state. */
+    /** Failed operation or interrupted assistant output. */
     isError?: boolean;
     /** Own duration in seconds, or `null` when no duration is known. */
     timeSeconds: number | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-trajectory",
   "description": "Trajectory event ledger with an interactive timing overview: pure-consumer plugin registering into the conversation ViewMap (no service)",
-  "version": "0.2.0-rc.2",
+  "version": "0.2.1-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -39,32 +39,33 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.4"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1"
   },
   "devDependencies": {
+    "@deepseek-ai/dsh-agent": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-test-runtime": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-compaction": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-alpha.2",
     "@types/react": "~18.3.1",
     "@types/react-dom": "~18.3.0",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "@tanstack/react-virtual": "^3.14.9",
-    "diff": "^9.0.0",
-    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-compaction": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
-    "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-client-store": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-api-session-controller": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-session": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-chat": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-test-runtime": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-client-store": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-attachment": "0.2.1-alpha.2",
+    "@tanstack/react-virtual": "^3.14.10",
+    "diff": "^9.0.0"
   },
   "files": [
     "lib/index.js",