@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

package/dist/worker/console/static-src/app/useTaskWizard.js

@@ -1,6 +1,14 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { ensureUniqueDocumentNames, operatorRequestFits, operatorRequestTooLargeMessage, } from "../prd-file-import.js";
 import { requestId, WORKFLOW_OPTIONS, } from "./console-types.js";
+export async function fetchLedgerSummary(taskId, fetchImpl) {
+    const impl = fetchImpl ?? fetch;
+    const response = await impl(`/api/tasks/${encodeURIComponent(taskId)}/ledger`, { credentials: "same-origin" });
+    if (!response.ok)
+        return { ok: false };
+    const summary = (await response.json());
+    return { ok: true, summary };
+}
 /** Happy Path task wizard: import-prd → interview → contract → dag-confirm →
  *  run. Owns task identity, interview projection and contract preflight/apply. */
 export function useTaskWizard(params) {
@@ -24,16 +32,27 @@ export function useTaskWizard(params) {
     const [contractDiffSummary, setContractDiffSummary] = useState(null);
     const [contractApplied, setContractApplied] = useState(false);
     const [spineOk, setSpineOk] = useState(null);
+    const [ledgerLoading, setLedgerLoading] = useState(false);
+    const [ledgerError, setLedgerError] = useState(null);
+    const [ledgerSummary, setLedgerSummary] = useState(null);
     const [contractPreflightKey, setContractPreflightKey] = useState(null);
     const contractPreflightRunning = useRef(false);
+    /** Epoch guard for ledger fetches: only the newest request may write wizard
+     *  state, so a concurrent in-flight preflight response can never overwrite
+     *  a fresh post-apply result (AC-001). */
+    const ledgerFetchEpoch = useRef(0);
     const resetContractLanding = useCallback(() => {
         setContractValidateOk(null);
         setContractValidateSummary(null);
         setContractDiffSummary(null);
         setContractApplied(false);
         setSpineOk(null);
+        setLedgerLoading(false);
+        setLedgerError(null);
+        setLedgerSummary(null);
         setContractPreflightKey(null);
         contractPreflightRunning.current = false;
+        ledgerFetchEpoch.current = 0;
     }, []);
     const enterContractStep = useCallback(() => {
         resetContractLanding();
@@ -56,6 +75,39 @@ export function useTaskWizard(params) {
                 : "访谈已完成：草稿已绑定完整评估结果");
         }
     }, [enterContractStep, setOpMessage]);
+    /** Epoch-guarded shared ledger refresh used by both the contract-step
+     *  preflight and the post-apply re-GET. `failureSemantics` keeps the
+     *  preflight five-state behavior (non-ok → empty state, no error) while the
+     *  post-apply refresh treats a non-ok/network failure as a safe-degrade
+     *  error per AC-001. */
+    const refreshLedgerState = useCallback(async (id, failureSemantics) => {
+        const epoch = ++ledgerFetchEpoch.current;
+        setLedgerLoading(true);
+        setLedgerError(null);
+        try {
+            const outcome = await fetchLedgerSummary(id);
+            if (ledgerFetchEpoch.current !== epoch)
+                return;
+            if (!outcome.ok) {
+                setLedgerSummary(null);
+                if (failureSemantics) {
+                    setLedgerError("ledger 接口不可达（安全降级）");
+                }
+                return;
+            }
+            setLedgerSummary(outcome.summary);
+        }
+        catch {
+            if (ledgerFetchEpoch.current !== epoch)
+                return;
+            setLedgerError("ledger 接口不可达（安全降级）");
+            setLedgerSummary(null);
+        }
+        finally {
+            if (ledgerFetchEpoch.current === epoch)
+                setLedgerLoading(false);
+        }
+    }, []);
     const runContractPreflight = useCallback(async (force = false) => {
         const id = taskId.trim();
         if (!id)
@@ -74,6 +126,9 @@ export function useTaskWizard(params) {
         setContractDiffSummary(null);
         setSpineOk(null);
         setContractApplied(false);
+        // Shared epoch-guarded refresh preserves the five-state semantics:
+        // non-ok → empty state, network failure → safe-degrade error.
+        await refreshLedgerState(id, false);
         try {
             const validateBody = await runAction("contractValidate", {
                 taskId: id,
@@ -101,6 +156,7 @@ export function useTaskWizard(params) {
         contractPreflightKey,
         contractValidateOk,
         isActionSuccess,
+        refreshLedgerState,
         runAction,
         setOpMessage,
         summarizeEnvelope,
@@ -116,6 +172,11 @@ export function useTaskWizard(params) {
             return;
         }
         setContractApplied(true);
+        // AC-001: re-GET the read-only ledger right after apply succeeds and
+        // write the latest summary BEFORE spineCheck/setStep, so the first
+        // dag-confirm frame shows post-apply statistics (never a loading/empty
+        // flash); refresh failure safe-degrades via ledgerError.
+        await refreshLedgerState(id, true);
         const spineBody = await runAction("spineCheck", { taskId: id });
         if (isActionSuccess(spineBody)) {
             setSpineOk(true);
@@ -125,7 +186,15 @@ export function useTaskWizard(params) {
         }
         setSpineOk(false);
         setOpMessage("契约已应用，但 Spine 审计未通过：可重试 Spine");
-    }, [assessmentId, isActionSuccess, runAction, setOpMessage, setStep, taskId]);
+    }, [
+        assessmentId,
+        isActionSuccess,
+        refreshLedgerState,
+        runAction,
+        setOpMessage,
+        setStep,
+        taskId,
+    ]);
     const retrySpineOnly = useCallback(async () => {
         const id = taskId.trim();
         if (!id)
@@ -282,6 +351,9 @@ export function useTaskWizard(params) {
         contractValidateOk,
         contractValidateSummary,
         contractDiffSummary,
+        ledgerLoading,
+        ledgerError,
+        ledgerSummary,
         contractApplied,
         spineOk,
         applyInterviewPayload,

package/dist/worker/console/static-src/operator-chat/cards/failure-category-advice.js

@@ -0,0 +1,25 @@
+/**
+ * Operator-facing recovery advice per normalized DAG failure category
+ * (mirrors DAG_NORMALIZED_FAILURE_CATEGORIES). The task journey card used to
+ * stop at "原因分类为 X" without telling the operator what to do next; this
+ * maps each class to the concrete next move, aligned with the Recovery
+ * workspace CTAs (node rerun / reconcile / models page).
+ */
+const FAILURE_CATEGORY_ADVICE = {
+    validation: "节点输出未通过契约或门禁校验。可在恢复页从失败节点重跑；若错误指向任务契约（如验证命令、Mock 策略），先修正任务配置并重新生成 DAG。",
+    executor: "执行器或模型提供方调用失败（网络、配额或运行时错误）。稍后可在恢复页从失败节点重跑；反复出现请到「模型与认证」页检查配置与凭据。",
+    "write-guard": "写入越过了授权边界（writeSet / allowedPaths）。检查计划中的写入路径是否越界，修正后从失败节点重跑。",
+    timeout: "节点执行超时。可在恢复页从失败节点重跑；反复超时建议缩小任务范围或排查卡住的命令。",
+    auth: "模型或服务认证失败。请先到「模型与认证」页检查 API Key 与模型配置，再从失败节点重跑。",
+    "human-required": "节点正在等待人工审批。完成审批后该节点可继续执行；也可在恢复页查看对账状态。",
+    "human-rejected": "人工审批被拒绝。请调整任务描述或契约后重新发起任务。",
+    "shell-command": "验证/构建命令以非零退出。进入 DAG 查看命令输出定位具体失败，修复后从失败节点重跑。",
+    "static-error": "静态检查（typecheck / lint 等）失败。修复对应代码错误后从失败节点重跑。",
+    "decision-envelope": "决策与证据不匹配（决策包络校验失败）。进入 DAG 查看节点决策依据，修正后重跑。",
+    unknown: "失败原因未归类。进入 DAG 查看节点详情，或在恢复页使用对账 / 诊断入口。",
+};
+export function failureCategoryAdvice(category) {
+    if (!category)
+        return undefined;
+    return FAILURE_CATEGORY_ADVICE[category];
+}

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

@@ -10,7 +10,7 @@ import { parseAssistantContent } from "../../chat/assistant-content.js";
  * original request would have. `assistantId` is the in-flight assistant
  * message id to patch for streaming text; reconnect creates one if none. */
 export function createChatSseEventApplier(deps) {
-    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
     return (eventName, data, assistantId, options) => {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
@@ -49,6 +49,41 @@ export function createChatSseEventApplier(deps) {
         const eventAt = typeof data.at === "string" && Number.isFinite(Date.parse(data.at))
             ? Date.parse(data.at)
             : Date.now();
+        if (eventName === "queue_update") {
+            const revision = typeof payload.revision === "number" ? payload.revision : -1;
+            setDeferredTurn((current) => {
+                if (current && revision < current.revision)
+                    return current;
+                return payload.deferredTurn && typeof payload.deferredTurn === "object"
+                    ? payload.deferredTurn
+                    : null;
+            });
+            return;
+        }
+        if (eventName === "user_message") {
+            const message = payload.message && typeof payload.message === "object"
+                ? payload.message
+                : null;
+            if (message &&
+                typeof message.id === "string" &&
+                typeof message.text === "string") {
+                const createdAt = typeof message.at === "string" && Number.isFinite(Date.parse(message.at))
+                    ? Date.parse(message.at)
+                    : Date.now();
+                setMessages((messages) => messages.some((item) => item.id === message.id)
+                    ? messages
+                    : [
+                        ...messages,
+                        {
+                            id: message.id,
+                            role: "user",
+                            text: message.text,
+                            createdAt,
+                        },
+                    ]);
+            }
+            return;
+        }
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -153,6 +188,7 @@ export function createChatSseEventApplier(deps) {
             }
             refs.streamingRef.current = true;
             setStreaming(true);
+            setTurnPhase("running");
             setStreamingAssistantId(resolvedAssistantId);
             return;
         }
@@ -168,6 +204,7 @@ export function createChatSseEventApplier(deps) {
                 refs.activeTurnIdRef.current = null;
             refs.streamingRef.current = false;
             setStreaming(false);
+            setTurnPhase("idle");
             setStreamingAssistantId(null);
             if (eventName === "agent_settled" &&
                 !replay &&
@@ -175,19 +212,30 @@ export function createChatSseEventApplier(deps) {
                 document.hidden) {
                 setUnread((current) => current + 1);
             }
-            setMessages((m) => m.filter((msg) => !(msg.id === resolvedAssistantId &&
-                msg.role === "assistant" &&
-                !msg.text.trim())));
-            // Close out tool calls that never got a tool_result (abort/fail):
-            // without this the process rail keeps showing "运行中" forever even
-            // though the turn is over. Match by turnId when the frame carries one
-            // (covers tools attributed to remapped/stale assistant ids); fall back
-            // to the resolved assistant id otherwise.
-            setToolCalls((prev) => prev.map((t) => t.status === "running" &&
-                ((turnId !== undefined && t.turnId === turnId) ||
-                    t.assistantMessageId === resolvedAssistantId)
-                ? { ...t, status: "error", finishedAt: Date.now() }
-                : t));
+            // Close dangling running tools first so the empty-bubble decision can
+            // see whether this assistant still owns any cards.
+            let assistantOwnsTools = false;
+            setToolCalls((prev) => {
+                assistantOwnsTools = prev.some((t) => t.assistantMessageId === resolvedAssistantId);
+                return prev.map((t) => t.status === "running" &&
+                    ((turnId !== undefined && t.turnId === turnId) ||
+                        t.assistantMessageId === resolvedAssistantId)
+                    ? { ...t, status: "error", finishedAt: Date.now() }
+                    : t);
+            });
+            // Drop only a true placeholder. An empty bubble that still owns tools
+            // (or has content blocks) is the grouping anchor; deleting it orphans
+            // the previous turn's bash cards onto the next prompt.
+            setMessages((m) => m.filter((msg) => {
+                if (msg.id !== resolvedAssistantId || msg.role !== "assistant") {
+                    return true;
+                }
+                if (msg.text.trim())
+                    return true;
+                if (msg.content && msg.content.length > 0)
+                    return true;
+                return assistantOwnsTools;
+            }));
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {
@@ -227,6 +275,15 @@ export function createChatSseEventApplier(deps) {
                 const cacheWrite = sample.cacheWriteTokens ?? 0;
                 const total = sample.totalTokens ?? input + output + cacheRead + cacheWrite;
                 const cu = sample.contextUsage;
+                const nextContext = cu && typeof cu === "object"
+                    ? {
+                        tokens: typeof cu.tokens === "number" ? cu.tokens : null,
+                        contextWindow: typeof cu.contextWindow === "number"
+                            ? cu.contextWindow
+                            : 0,
+                        percent: typeof cu.percent === "number" ? cu.percent : null,
+                    }
+                    : current.contextUsage;
                 return {
                     inputTokens: current.inputTokens + input,
                     outputTokens: current.outputTokens + output,
@@ -236,18 +293,9 @@ export function createChatSseEventApplier(deps) {
                     cost: sample.cost === undefined
                         ? current.cost
                         : (current.cost ?? 0) + sample.cost,
-                    // Context usage is a live snapshot, not an accumulator: replace it.
-                    ...(cu && typeof cu === "object"
-                        ? {
-                            contextUsage: {
-                                tokens: typeof cu.tokens === "number" ? cu.tokens : null,
-                                contextWindow: typeof cu.contextWindow === "number"
-                                    ? cu.contextWindow
-                                    : 0,
-                                percent: typeof cu.percent === "number" ? cu.percent : null,
-                            },
-                        }
-                        : {}),
+                    // Context fill is independent of per-message token deltas. Keep the
+                    // last known snapshot unless this event carries a fresh one.
+                    ...(nextContext ? { contextUsage: nextContext } : {}),
                 };
             });
             return;

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

@@ -0,0 +1,76 @@
+/**
+ * Pure composer input-history state machine for Operator Chat.
+ *
+ * Extracted so ArrowUp/ArrowUp recall, unsent-draft retention and history
+ * recording can be unit-tested without mounting the React composer.
+ */
+export const INPUT_HISTORY_LIMIT = 100;
+export function createInputHistoryState() {
+    return { entries: [], index: -1, draft: "" };
+}
+/** Record one sent text and reset browsing back to the present draft. */
+export function recordInputHistoryEntry(state, text) {
+    if (!text.trim())
+        return state;
+    if (state.entries[state.entries.length - 1] === text) {
+        return state.index === -1 ? state : { ...state, index: -1, draft: "" };
+    }
+    const entries = [...state.entries, text].slice(-INPUT_HISTORY_LIMIT);
+    return { entries, index: -1, draft: "" };
+}
+/** Leave browse mode (manual typing edits the recalled text in place). */
+export function resetInputHistoryBrowsing(state) {
+    return state.index === -1 ? state : { ...state, index: -1 };
+}
+/**
+ * Recall an earlier input with the arrow keys (terminal-style).
+ *
+ * Up only engages while the caret sits on the first line and Down while it
+ * sits on the last line, so plain caret movement inside multi-line drafts is
+ * never swallowed. The unsent draft is stashed when browsing leaves the
+ * present position and restored when Down walks past the newest entry.
+ */
+export function navigateInputHistory(state, direction, context) {
+    const { text, caretStart, caretEnd } = context;
+    if (state.entries.length === 0)
+        return { handled: false };
+    if (direction === "up") {
+        if (text.slice(0, caretStart).includes("\n"))
+            return { handled: false };
+        if (state.index === -1) {
+            const index = state.entries.length - 1;
+            return {
+                handled: true,
+                state: { ...state, index, draft: text },
+                text: state.entries[index],
+            };
+        }
+        if (state.index === 0) {
+            // Already at the oldest entry: stay there (terminal behaviour).
+            return { handled: true, state, text: state.entries[0] };
+        }
+        const index = state.index - 1;
+        return {
+            handled: true,
+            state: { ...state, index },
+            text: state.entries[index],
+        };
+    }
+    if (state.index === -1)
+        return { handled: false };
+    if (text.slice(caretEnd).includes("\n"))
+        return { handled: false };
+    if (state.index >= state.entries.length - 1) {
+        return {
+            handled: true,
+            state: { ...state, index: -1 },
+            text: state.draft,
+        };
+    }
+    const index = state.index + 1;
+    return {
+        handled: true,
+        state: { ...state, index },
+        text: state.entries[index],
+    };
+}

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

@@ -30,7 +30,7 @@ export function isStaleTokenFailure(code) {
 /** Chinese, actionable copy for mutation-gate rejections. */
 export function describeMutationGateFailure(code) {
     if (isStaleTokenFailure(code)) {
-        return "页面已过期（控制台已重启），请刷新页面（F5）后重试。";
+        return "页面凭证已失效（控制台可能已重启），请刷新页面（F5）后重试。";
     }
     if (code === "host-not-loopback") {
         return "请求主机校验失败：非回环绑定时要求 Host 头，请刷新页面或检查访问地址。";