@tea-agent/loop-agent 0.38.1 → 0.38.3

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -1,8 +1,8 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
-import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, } from "./turn-stream-controller.js";
+import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, decideSubmissionRoute, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcileDeferredSubmissionFromState, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, } from "./turn-stream-controller.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -57,7 +57,7 @@ function clearEmptyAssistant(setMessages, assistantId) {
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
     const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
-    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
+    const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
     const { setInput, setPendingImages } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
@@ -78,9 +78,10 @@ export function useChatStream(params) {
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
         setStreaming(false);
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    }, [refs, setStreaming, setTurnPhase, setStreamingAssistantId, setMessages]);
     /** Follow one session's event stream until it is explicitly aborted. The
      * server's `stream_ready` marker separates replay from live events; this
      * means replay cannot render duplicate messages while live text remains
@@ -242,13 +243,12 @@ export function useChatStream(params) {
     /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
     const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
         refs.stoppingTurnIdRef.current = turnId;
-        // Optimistic stop (pi-web parity): the abort signal kills the SDK
-        // process tree promptly, so flip the UI idle NOW instead of holding
-        // the busy spinner through the whole POST /abort round-trip. If the
-        // server later reports the turn still running (TURN_ABORT_PENDING
-        // or owner-lost reconcile), applyAbortDecision restores busy state.
+        // Optimistic visual stop: remove the running spinner immediately, but
+        // retain ownership as `stopping` until the server proves a terminal state.
+        // This keeps the composer responsive without falsely advertising idle.
         refs.streamingRef.current = false;
         setStreaming(false);
+        setTurnPhase("stopping");
         setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
@@ -283,6 +283,7 @@ export function useChatStream(params) {
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
+                setTurnPhase(turnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -290,6 +291,7 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
+            setTurnPhase(turnPhaseFromOwnership(bag));
             // Sync the post-decision busy state back to React: optimistic stop
             // flipped it idle up front; pending/keep-busy outcomes restore it.
             if (bag.streaming)
@@ -310,11 +312,13 @@ export function useChatStream(params) {
             // so the turn is not silently dropped; /state reconcile converges.
             refs.streamingRef.current = true;
             setStreaming(true);
+            setTurnPhase("stopping");
         }
     }, [
         origin,
         refs,
         setStreaming,
+        setTurnPhase,
         markIdleIfCurrent,
         fetchSessionState,
         noticeSink,
@@ -364,10 +368,12 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase(turnPhaseFromOwnership(bag));
     }, [
         refs,
         noticeSink,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
         setPendingImages,
         watchSessionTitle,
@@ -376,10 +382,190 @@ export function useChatStream(params) {
         setError,
         postAbortForTurn,
     ]);
+    const queueDeferredTurn = useCallback(async (input) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession || (!input.text.trim() && input.images.length === 0))
+            return { action: "handled" };
+        const existing = thread.deferredTurn;
+        showNotice("正在排队…");
+        const acceptDeferred = (deferredTurn) => {
+            setDeferredTurn(deferredTurn);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice(existing ? "已更新停止后发送的消息" : "已排队，将在上一轮停止后自动发送");
+        };
+        const acceptDispatched = () => {
+            setDeferredTurn(null);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice("消息已进入发送");
+        };
+        const putOnce = async () => {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    text: input.text,
+                    images: input.images,
+                    ...(existing ? { expectedRevision: existing.revision } : {}),
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            return { response, body };
+        };
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const { response, body } = await putOnce();
+                if (response.ok && body.accepted && body.deferredTurn) {
+                    acceptDeferred(body.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (body.deferredTurn)
+                    setDeferredTurn(body.deferredTurn);
+                if (body.error?.code !== "TURN_NOT_STOPPING") {
+                    setError(body.error?.message ??
+                        `待发送消息未被服务端接受（HTTP ${response.status}）`);
+                    return { action: "handled" };
+                }
+                const canonical = await fetchSessionState(activeSession.sessionId);
+                const decision = reconcileDeferredSubmissionFromState({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    state: canonical ?? undefined,
+                });
+                if (decision.action === "deferred") {
+                    acceptDeferred(decision.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (decision.action === "accepted") {
+                    acceptDispatched();
+                    return { action: "handled" };
+                }
+                if (decision.action === "retry-deferred" && attempt === 0)
+                    continue;
+                if (decision.action === "send-now" && !existing) {
+                    showNotice("上一轮已停止，正在发送当前消息…");
+                    return { action: "send-now" };
+                }
+                setError(body.error?.message ?? "停止状态已变化，当前消息仍保留在输入框");
+                return { action: "handled" };
+            }
+            return { action: "handled" };
+        }
+        catch (error) {
+            const canonical = await fetchSessionState(activeSession.sessionId);
+            const decision = reconcileDeferredSubmissionFromState({
+                clientRequestId: input.clientRequestId,
+                blockedByTurnId: input.blockedByTurnId,
+                state: canonical ?? undefined,
+            });
+            if (decision.action === "deferred") {
+                acceptDeferred(decision.deferredTurn);
+                return { action: "handled" };
+            }
+            if (decision.action === "accepted") {
+                acceptDispatched();
+                return { action: "handled" };
+            }
+            if (decision.action === "send-now" && !existing) {
+                showNotice("上一轮已停止，正在发送当前消息…");
+                return { action: "send-now" };
+            }
+            setError(error instanceof Error
+                ? `无法确认消息是否已排队：${error.message}`
+                : "无法确认消息是否已排队，请刷新后查看服务端状态");
+            return { action: "handled" };
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+        fetchSessionState,
+    ]);
+    const cancelDeferredTurn = useCallback(async () => {
+        const activeSession = refs.sessionRef.current;
+        const deferred = thread.deferredTurn;
+        if (!activeSession || !deferred)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "DELETE",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: deferred.clientRequestId,
+                    expectedRevision: deferred.revision,
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.cancelled) {
+                setError(body.error?.message ?? "待发送消息撤回失败");
+                return;
+            }
+            setDeferredTurn(null);
+            setInput(body.deferredTurn?.text ?? "");
+            setPendingImages(body.deferredTurn?.images ?? []);
+            setError(null);
+            showNotice("待发送消息已移回输入框");
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+    ]);
     const sendPrompt = useCallback(async (text, images) => {
+        const initialSession = refs.sessionRef.current;
+        if (!initialSession || (!text.trim() && images.length === 0))
+            return;
+        const ownership = ownershipBagFromRefs(refs);
+        const route = decideSubmissionRoute({
+            turnPhase: turnPhaseFromOwnership(ownership),
+            blockedByTurnId: ownership.stoppingTurnId ?? ownership.activeTurnId,
+        });
+        const clientRequestId = requestId("chat-submit");
+        if (route.action === "hold") {
+            if (turnPhaseFromOwnership(ownership) === "stopping")
+                showNotice("正在确认上一轮停止状态，当前消息已保留");
+            return;
+        }
+        if (route.action === "queue-deferred") {
+            const deferred = await queueDeferredTurn({
+                text,
+                images,
+                clientRequestId,
+                blockedByTurnId: route.blockedByTurnId,
+            });
+            if (deferred.action !== "send-now")
+                return;
+        }
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
+            activeSession.sessionId !== initialSession.sessionId ||
             (!text.trim() && images.length === 0) ||
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
@@ -389,7 +575,6 @@ export function useChatStream(params) {
         // AC-001: acquire synchronous submit ownership before the first await.
         refs.submitInFlightRef.current = true;
         const submitGeneration = ++refs.submitGenerationRef.current;
-        const clientRequestId = requestId("chat-submit");
         const userMessageId = requestId("u");
         const assistantId = requestId("a");
         const draftText = text.trim();
@@ -437,6 +622,7 @@ export function useChatStream(params) {
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
+        setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
@@ -532,7 +718,9 @@ export function useChatStream(params) {
         setAutoScroll,
         setError,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
+        queueDeferredTurn,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -548,6 +736,7 @@ export function useChatStream(params) {
             notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase("stopping");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -656,6 +845,9 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
+                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    if (state && "deferredTurn" in state)
+                        setDeferredTurn(state.deferredTurn ?? null);
                     if (result === "bound") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
@@ -755,6 +947,7 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
+        setTurnPhase,
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
@@ -776,5 +969,5 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, openEventsStream };
+    return { sendPrompt, handleStop, cancelDeferredTurn, openEventsStream };
 }

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -31,6 +31,8 @@ export function useChatThread(params) {
     const [contextLoading, setContextLoading] = useState(false);
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [streaming, setStreaming] = useState(false);
+    const [turnPhase, setTurnPhase] = useState("idle");
+    const [deferredTurn, setDeferredTurn] = useState(null);
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
@@ -44,6 +46,8 @@ export function useChatThread(params) {
         setHumanGateCards,
         setArtifactCards,
         setStreaming,
+        setTurnPhase,
+        setDeferredTurn,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -190,6 +194,8 @@ export function useChatThread(params) {
         setTaskContext(null);
         setUsage(EMPTY_USAGE);
         setStreaming(false);
+        setTurnPhase("idle");
+        setDeferredTurn(null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -207,6 +213,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(next.streaming);
+        setTurnPhase(next.turnPhase ?? (next.streaming ? "running" : "idle"));
+        setDeferredTurn(next.deferredTurn ?? null);
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
@@ -228,6 +236,8 @@ export function useChatThread(params) {
             const activeTurnId = body.session.activeTurnId ?? null;
             refs.activeTurnIdRef.current = activeTurnId;
             refs.streamingRef.current = Boolean(activeTurnId);
+            setTurnPhase(body.session.turnPhase ?? (activeTurnId ? "running" : "idle"));
+            setDeferredTurn(body.session.deferredTurn ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -246,7 +256,15 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setToolCalls, setStreamingAssistantId]);
+    }, [
+        origin,
+        refs,
+        setMessages,
+        setToolCalls,
+        setStreamingAssistantId,
+        setTurnPhase,
+        setDeferredTurn,
+    ]);
     return {
         messages,
         setMessages,
@@ -265,6 +283,10 @@ export function useChatThread(params) {
         usage,
         streaming,
         setStreaming,
+        turnPhase,
+        setTurnPhase,
+        deferredTurn,
+        setDeferredTurn,
         streamingAssistantId,
         setStreamingAssistantId,
         visibleMessages,

package/dist/worker/observe/node-input.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -33,6 +33,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
+        piExtensionRunFacts: null,
         warnings,
     };
 }
@@ -137,7 +138,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -268,6 +269,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             kind,
             skills,
             modelHint: resolveModelHint(spec, task),
+            piExtensions: redactStringList(task.piExtensions),
             shell,
             static: staticBlock,
         },
@@ -284,9 +286,72 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
         },
         promptFingerprint: fingerprint,
+        piExtensionRunFacts,
         warnings,
     };
 }
+/**
+ * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
+ * 2026-08-22 R2). Returns null when the node declares no piExtensions
+ * (no expected artifact). Never throws: unreadable/corrupt artifacts degrade
+ * to parseError stubs so the node-input endpoint stays 200.
+ */
+async function loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declared, warnings) {
+    if (declared.length === 0)
+        return null;
+    const artifact = path.posix.join(nodeId, "pi-extensions.json");
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "pi-extensions.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous pi-extensions.json lifecycle copies.");
+        }
+        return {
+            artifact,
+            exists: false,
+            requested: [...declared],
+            resolved: [],
+            missing: [],
+        };
+    }
+    const empty = {
+        artifact,
+        exists: false,
+        requested: [...declared],
+        resolved: [],
+        missing: [],
+    };
+    try {
+        const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+        const resolvedList = Array.isArray(raw.resolved) ? raw.resolved : [];
+        const missingList = Array.isArray(raw.missing) ? raw.missing : [];
+        const projected = resolvedList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            packageName: redactSecrets(String(entry.packageName ?? "")),
+            version: redactSecrets(String(entry.version ?? "")),
+        }));
+        const missingProjected = missingList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            reason: redactSecrets(String(entry.reason ?? "")),
+        }));
+        return {
+            artifact,
+            exists: true,
+            requested: redactStringList(raw.requested ?? declared),
+            resolved: projected,
+            missing: missingProjected,
+        };
+    }
+    catch {
+        return { ...empty, parseError: "read-failed" };
+    }
+}
 async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
     const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
     if (!resolved.ok) {
@@ -415,8 +480,12 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
     }
     const warnings = [];
     const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    const declaredPiExtensions = Array.isArray(task.piExtensions)
+        ? task.piExtensions.filter((item) => typeof item === "string")
+        : [];
+    const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {

package/dist/worker/observe/static/dag-history-labels.js

@@ -14,6 +14,10 @@ const ATTEMPT_FAILURE_LABELS = {
 	timeout: "执行超时",
 	"nonzero-exit": "命令执行失败",
 	"invalid-output": "输出格式无效",
+	"structured-output-truncated": "结构化输出被截断",
+	"output-too-large": "输出超出体积上限",
+	"structured-repair-exhausted": "结构化修复耗尽",
+	"governance-blocked": "治理规则阻断",
 	"empty-output": "输出为空",
 	auth: "认证失败",
 	quota: "额度或限流",

package/dist/worker/observe/static/state.js

@@ -76,8 +76,8 @@ export const uiState = {
 	dagNodeExecutionOutputLoading: false,
 	dagNodeExecutionOutputError: null,
 	dagNodeExecutionOutputKey: null,
-	/** When true,「执行过程」展开 message_start/end 原始协议事件。 */
-	sessionTimelineShowProtocol: false,
+	/** When true,「执行过程」展开 message_start/end 原始协议事件。默认展开，用户可点选隐藏。 */
+	sessionTimelineShowProtocol: true,
 	/** Open <details> keys restored across timeline re-renders. */
 	sessionTimelineOpenDetails: null,
 	lastSnapshot: null,

package/dist/worker/observe/static/views/dag-inspector.js

@@ -725,6 +725,11 @@ function renderDagNodeInputDetail(content, data) {
 		}
 		section.appendChild(dl);
 		appendCodeList(section, "skills", data.executorInput.skills);
+		appendCodeList(
+			section,
+			"piExtensions（声明）",
+			data.executorInput.piExtensions,
+		);
 		if (data.executorInput.shell) {
 			const shell = data.executorInput.shell;
 			const shellDl = el("dl", "node-input-summary");
@@ -799,6 +804,52 @@ function renderDagNodeInputDetail(content, data) {
 		wrap.appendChild(section);
 	}
 
+	if (data.piExtensionRunFacts) {
+		const facts = data.piExtensionRunFacts;
+		const section = el("section", "node-input-section");
+		section.appendChild(el("h4", null, "Pi 扩展运行事实"));
+		if (!facts.exists) {
+			section.appendChild(
+				el(
+					"p",
+					"muted",
+					facts.parseError
+					? `产物 ${facts.artifact} 读取失败（${facts.parseError}）。`
+					: `产物 ${facts.artifact} 尚未生成（节点未执行或缺失）。`,
+				),
+			);
+		} else {
+			const dl = el("dl", "node-input-summary");
+			appendMetaRow(
+				dl,
+				"resolved",
+				facts.resolved
+					.map((entry) => `${entry.id} → ${entry.packageName}@${entry.version}`)
+					.join(", ") || "(none)",
+				null,
+			);
+			section.appendChild(dl);
+			appendCodeList(
+				section,
+				"requested",
+				facts.requested,
+			);
+			for (const missingEntry of facts.missing ?? []) {
+				section.appendChild(
+					el(
+						"p",
+						"node-input-warning",
+						`降级：${missingEntry.id} 未加载（${missingEntry.reason || "unknown"}）`,
+					),
+				);
+			}
+			if ((facts.missing ?? []).length === 0) {
+				section.appendChild(el("p", "muted", "全部声明扩展均已解析加载。"));
+			}
+		}
+		wrap.appendChild(section);
+	}
+
 	if (data.promptFingerprint?.exists) {
 		const section = el("section", "node-input-section");
 		section.appendChild(el("h4", null, "Assembled prompt 指纹"));

package/dist/worker/observe/static/views/session-timeline.js

@@ -439,12 +439,25 @@ function ensureOpenDetailsSet() {
 	return uiState.sessionTimelineOpenDetails;
 }
 
-function bindDetailsToggle(details, detailKey) {
+function closedDetailKey(detailKey) {
+	return `${detailKey}::user-closed`;
+}
+
+function bindDetailsToggle(details, detailKey, defaultOpen = false) {
 	const openSet = ensureOpenDetailsSet();
-	if (openSet.has(detailKey)) details.open = true;
+	if (defaultOpen) {
+		if (!openSet.has(closedDetailKey(detailKey))) details.open = true;
+	} else if (openSet.has(detailKey)) {
+		details.open = true;
+	}
 	details.addEventListener("toggle", () => {
-		if (details.open) openSet.add(detailKey);
-		else openSet.delete(detailKey);
+		if (details.open) {
+			openSet.add(detailKey);
+			openSet.delete(closedDetailKey(detailKey));
+		} else {
+			openSet.delete(detailKey);
+			openSet.add(closedDetailKey(detailKey));
+		}
 	});
 }
 
@@ -599,7 +612,7 @@ function renderProtocolCard(item) {
 	const details = document.createElement("details");
 	details.className = "process-timeline-details";
 	details.dataset.detailKey = item.detailKey;
-	bindDetailsToggle(details, item.detailKey);
+	bindDetailsToggle(details, item.detailKey, true);
 	const summary = document.createElement("summary");
 	summary.className = "process-timeline-summary";
 	summary.textContent = `消息收发 · ${item.protocolCount} 条协议事件`;