@tea-agent/loop-agent 0.44.0-next.6 → 0.44.0-next.8

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

@@ -3,8 +3,50 @@ import { formatOperatorUserError } from "../../operator-user-error.js";
 import { inspectChatSseContinuity, readChatStreamReadyCursor, selectChatSseRepairBlocks, selectLaterChatEventId, } from "./chat-stream-continuity.js";
 import { confirmationToken, requestId, sleep } from "./format.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, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, createBoundedOwnerSignal, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
 import { appendPendingSubmission, removePendingSubmission } from "./pending-user-message.js";
+import { createTurnStateReconcileQueue, turnStateReconcileTrigger, } from "./turn-state-projection.js";
+const STATE_REQUEST_TIMEOUT_MS = 2_000;
+async function fetchReconciledSessionState(origin, sessionId, options) {
+    const bounded = createBoundedOwnerSignal({
+        ownerSignal: options?.ownerSignal,
+        timeoutMs: STATE_REQUEST_TIMEOUT_MS,
+    });
+    try {
+        const res = await fetch(operatorChatStateUrl(origin, sessionId, options?.turnIds), {
+            credentials: "include",
+            signal: bounded.signal,
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (!res.ok)
+            return null;
+        return body.state ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        bounded.dispose();
+    }
+}
+function readChatSseTurnId(block) {
+    const data = block
+        .split("\n")
+        .filter((line) => line.startsWith("data: "))
+        .map((line) => line.slice(6))
+        .join("");
+    if (!data)
+        return undefined;
+    try {
+        const parsed = JSON.parse(data);
+        return typeof parsed.turnId === "string" && parsed.turnId
+            ? parsed.turnId
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -106,6 +148,17 @@ export function useChatStream(params) {
      * smooth (M4.1/M4.3). */
     const openEventsStream = useCallback(async (sessionId, generation, signal) => {
         const gapReplayBuffer = [];
+        const turnStateReconciles = createTurnStateReconcileQueue({
+            read: (turnIds) => fetchReconciledSessionState(origin, sessionId, {
+                turnIds,
+                ownerSignal: signal,
+            }),
+            apply: (summaries) => thread.reconcileTurnStates([...summaries]),
+            wait: (delayMs) => sleep(delayMs, signal),
+            isCancelled: () => signal.aborted ||
+                refs.sessionRef.current?.sessionId !== sessionId ||
+                refs.sessionGenerationRef.current !== generation,
+        });
         while (!signal.aborted) {
             const state = refs.eventsStreamStateRef.current;
             if (!state ||
@@ -145,6 +198,16 @@ export function useChatStream(params) {
                         const block = blocks[blockIndex];
                         if (block === undefined)
                             continue;
+                        const eventName = sseEventName(block);
+                        const reconcileTrigger = turnStateReconcileTrigger(replay, eventName);
+                        if (reconcileTrigger) {
+                            const settledTurnId = readChatSseTurnId(block);
+                            if (settledTurnId) {
+                                turnStateReconciles.enqueue(settledTurnId, {
+                                    defer: reconcileTrigger === "after-replay",
+                                });
+                            }
+                        }
                         if (!replay) {
                             const continuity = inspectChatSseContinuity(block, liveContinuityCursor);
                             if (continuity.action === "reconnect") {
@@ -156,7 +219,7 @@ export function useChatStream(params) {
                                 break readLoop;
                             }
                         }
-                        if (sseEventName(block) === "stream_ready") {
+                        if (eventName === "stream_ready") {
                             const current = refs.eventsStreamStateRef.current;
                             if (current?.sessionId === sessionId &&
                                 current.generation === generation)
@@ -179,7 +242,7 @@ export function useChatStream(params) {
                             if (!replay)
                                 liveContinuityCursor = selectLaterChatEventId(liveContinuityCursor, eventId);
                         }
-                        if (sseEventName(block) === "stream_ready" &&
+                        if (eventName === "stream_ready" &&
                             gapReplayBuffer.length > 0) {
                             const repairedBlocks = selectChatSseRepairBlocks(gapReplayBuffer.splice(0), liveContinuityCursor);
                             for (const repairedBlock of repairedBlocks) {
@@ -193,6 +256,9 @@ export function useChatStream(params) {
                                 refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, repairedEventId);
                             }
                         }
+                        if (eventName === "stream_ready") {
+                            void turnStateReconciles.start();
+                        }
                     }
                 }
                 if (replayRepairNeeded) {
@@ -213,7 +279,7 @@ export function useChatStream(params) {
                 await sleep(2_000, signal);
             }
         }
-    }, [origin, refs, applySseBlock]);
+    }, [origin, refs, applySseBlock, thread.reconcileTurnStates]);
     const startEventsStream = useCallback((sessionId, generation) => {
         const existing = refs.eventsStreamStateRef.current;
         if (existing?.sessionId === sessionId &&
@@ -249,20 +315,7 @@ export function useChatStream(params) {
         }
         throw new Error("事件连接未就绪，请检查 Console 连接后重试");
     }, [refs, startEventsStream]);
-    const fetchSessionState = useCallback(async (sessionId) => {
-        try {
-            const res = await fetch(operatorChatStateUrl(origin, sessionId), {
-                credentials: "include",
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (!res.ok)
-                return null;
-            return body.state ?? null;
-        }
-        catch {
-            return null;
-        }
-    }, [origin]);
+    const fetchSessionState = useCallback((sessionId) => fetchReconciledSessionState(origin, sessionId), [origin]);
     const postCreateTurn = useCallback(async (input) => {
         try {
             // Resolve against the configured Console origin and fail closed if a
@@ -1042,20 +1095,20 @@ export function useChatStream(params) {
         const sessionId = session.sessionId;
         const sessionIdentity = { ...session };
         const generation = refs.sessionGenerationRef.current;
+        const stateReconcileAbort = new AbortController();
         let cancelled = false;
         let syncInFlight = null;
         const runSync = async () => {
             try {
-                const res = await fetch(operatorChatStateUrl(origin, sessionId), {
-                    credentials: "include",
+                const state = await fetchReconciledSessionState(origin, sessionId, {
+                    ownerSignal: stateReconcileAbort.signal,
                 });
-                const body = (await res.json().catch(() => ({})));
                 if (cancelled ||
-                    !res.ok ||
+                    !state ||
                     refs.sessionRef.current?.sessionId !== sessionId ||
                     refs.sessionGenerationRef.current !== generation)
                     return;
-                const state = body.state;
+                thread.reconcileTurnStates(state?.turnStates);
                 const pending = refs.pendingSubmissionRef.current;
                 // Pending ownership reconcile. Controller owns bind/release; same
                 // clientRequestId only. Re-enter after acceptedTurnId so terminal
@@ -1200,6 +1253,7 @@ export function useChatStream(params) {
         void sync().finally(scheduleStopRetry);
         return () => {
             cancelled = true;
+            stateReconcileAbort.abort();
             window.clearInterval(interval);
             if (stopRetryTimer !== undefined)
                 window.clearTimeout(stopRetryTimer);
@@ -1216,6 +1270,7 @@ export function useChatStream(params) {
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
+        thread.reconcileTurnStates,
     ]);
     // Exactly one owner starts/aborts GET /events. Switching sessions or
     // recovering a cursor aborts the prior stream before the next one is made.

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

@@ -9,6 +9,7 @@ import { taskContextUnchanged } from "./format.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
 import { sameTurnGroupInputs } from "./turn-group-equality.js";
 import { conversationNodesFromEvents, } from "../../chat/conversation-nodes.js";
+import { mergeTurnStateSummaries, setProjectedTurnState, } from "./turn-state-projection.js";
 const EMPTY_USAGE = {
     inputTokens: 0,
     outputTokens: 0,
@@ -141,8 +142,13 @@ export function useChatThread(params) {
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [sessionStats, setSessionStats] = useState(EMPTY_SESSION_STATS);
     const [turnTelemetry, setTurnTelemetry] = useState([]);
+    const [userTurnOutline, setUserTurnOutline] = useState([]);
     const [operatorActions, setOperatorActions] = useState([]);
     const [conversationNodes, setConversationNodes] = useState([]);
+    const [turnStatesById, setTurnStatesById] = useState({});
+    const reconcileTurnStates = useCallback((summaries) => {
+        setTurnStatesById((current) => mergeTurnStateSummaries(current, summaries));
+    }, []);
     const [sddSessionIdentity, setSddSessionIdentity] = useState(null);
     const [streaming, setStreaming] = useState(false);
     const [turnPhase, setTurnPhase] = useState("idle");
@@ -172,11 +178,12 @@ export function useChatThread(params) {
                 setUsage(body.usage);
             setTurnTelemetry(body.turnTelemetry ?? []);
             setSddSessionIdentity(body.sddDataAlignment ?? null);
+            reconcileTurnStates(body.session?.turnStates);
         }
         catch {
             // Telemetry is supplementary; the normal event stream remains authoritative.
         }
-    }, [origin, refs]);
+    }, [origin, refs, reconcileTurnStates]);
     // All inputs are stable (state setters + the memoized refs bag), so the
     // applier identity is stable across renders.
     const applyChatSseEvent = useMemo(() => createChatSseEventApplier({
@@ -195,6 +202,7 @@ export function useChatThread(params) {
         setGoal,
         setOperatorActions,
         setConversationNodes,
+        setTurnState: (turnId, state) => setTurnStatesById((current) => setProjectedTurnState(current, turnId, state)),
         setSddSessionIdentity,
         setStreamingAssistantId,
         setUnread,
@@ -334,6 +342,7 @@ export function useChatThread(params) {
             streaming,
             activeAssistantId: streamingAssistantId,
             conversationNodes,
+            turnStatesById,
         });
         // Preserve completed group objects across streaming tokens. Stable
         // historical groups keep their references so
@@ -353,11 +362,12 @@ export function useChatThread(params) {
         streaming,
         streamingAssistantId,
         conversationNodes,
+        turnStatesById,
         historyLimit,
     ]);
-    const loadEarlierMessages = useCallback(async (beforePrepend) => {
+    const loadHistoryPages = useCallback(async (input) => {
         const targetSessionId = refs.sessionRef.current?.sessionId;
-        const beforeId = historyNextCursor;
+        let beforeId = historyNextCursor;
         if (!targetSessionId || !historyHasMore || !beforeId || historyLoadingRef.current)
             return false;
         const generation = refs.sessionGenerationRef.current;
@@ -365,17 +375,29 @@ export function useChatThread(params) {
         historyLoadingRef.current = request;
         setHistoryLoading(true);
         try {
-            const query = new URLSearchParams({ limit: "50", beforeId });
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/messages?${query.toString()}`, { credentials: "include" });
-            if (!res.ok || refs.sessionRef.current?.sessionId !== targetSessionId)
-                return false;
-            const body = (await res.json());
-            if (refs.sessionRef.current?.sessionId !== targetSessionId ||
-                refs.sessionGenerationRef.current !== generation ||
-                historyLoadingRef.current !== request)
-                return false;
-            const page = hydrateSessionThread(body.messages ?? []);
-            beforePrepend?.();
+            const collectedMessages = [];
+            const collectedTurnStates = [];
+            let hasMore = historyHasMore;
+            let found = false;
+            do {
+                const query = new URLSearchParams({ limit: "50", beforeId });
+                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/messages?${query.toString()}`, { credentials: "include" });
+                if (!res.ok || refs.sessionRef.current?.sessionId !== targetSessionId)
+                    return false;
+                const body = (await res.json());
+                if (refs.sessionRef.current?.sessionId !== targetSessionId ||
+                    refs.sessionGenerationRef.current !== generation ||
+                    historyLoadingRef.current !== request)
+                    return false;
+                const pageMessages = body.messages ?? [];
+                collectedMessages.unshift(...pageMessages);
+                collectedTurnStates.push(...(body.turnStates ?? []));
+                found = Boolean(input?.untilMessageId && pageMessages.some((message) => message.id === input.untilMessageId));
+                hasMore = body.hasMore === true;
+                beforeId = body.nextCursor ?? "";
+            } while (input?.untilMessageId && !found && hasMore && beforeId);
+            const page = hydrateSessionThread(collectedMessages);
+            input?.beforePrepend?.();
             setMessages((current) => {
                 const seen = new Set();
                 const merged = [...page.messages, ...current].filter((message) => {
@@ -392,10 +414,11 @@ export function useChatThread(params) {
                     byId.set(tool.id, tool);
                 return [...byId.values()].sort((a, b) => a.createdAt - b.createdAt);
             });
-            setHistoryHasMore(body.hasMore === true);
-            setHistoryNextCursor(body.nextCursor ?? null);
-            setHistoryLimit((value) => value + 50);
-            return true;
+            setTurnStatesById((current) => mergeTurnStateSummaries(current, collectedTurnStates));
+            setHistoryHasMore(hasMore);
+            setHistoryNextCursor(beforeId || null);
+            setHistoryLimit((value) => value + collectedMessages.length);
+            return input?.untilMessageId ? found : true;
         }
         catch (error) {
             if (refs.sessionRef.current?.sessionId === targetSessionId && refs.sessionGenerationRef.current === generation) {
@@ -410,6 +433,10 @@ export function useChatThread(params) {
             }
         }
     }, [historyHasMore, historyNextCursor, origin, refs, setError]);
+    const loadEarlierMessages = useCallback((beforePrepend) => loadHistoryPages({ beforePrepend }), [loadHistoryPages]);
+    const loadThroughMessage = useCallback((messageId) => messagesRef.current.some((message) => message.id === messageId)
+        ? Promise.resolve(true)
+        : loadHistoryPages({ untilMessageId: messageId }), [loadHistoryPages]);
     const visibleMessages = useMemo(() => {
         const next = [];
         for (const group of turnGroups) {
@@ -431,8 +458,10 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         setSessionStats(EMPTY_SESSION_STATS);
         setTurnTelemetry([]);
+        setUserTurnOutline([]);
         setOperatorActions([]);
         setConversationNodes([]);
+        setTurnStatesById({});
         setSddSessionIdentity(null);
         setStreaming(false);
         setTurnPhase("idle");
@@ -483,6 +512,7 @@ export function useChatThread(params) {
             : undefined));
         setToolCalls(next.toolCalls);
         setConversationNodes(conversationNodesFromEvents(next.conversationEvents ?? []));
+        setTurnStatesById(mergeTurnStateSummaries({}, next.turnStates));
         setOperationCards([]);
         setHumanGateCards([]);
         setArtifactCards([]);
@@ -491,6 +521,7 @@ export function useChatThread(params) {
         setUsage(next.usage ?? EMPTY_USAGE);
         setSessionStats(next.sessionStats ?? EMPTY_SESSION_STATS);
         setTurnTelemetry(next.turnTelemetry ?? []);
+        setUserTurnOutline(next.userTurnOutline ?? []);
         setOperatorActions([]);
         setSddSessionIdentity(next.sddSessionIdentity ?? null);
         refs.usageResponseKeysRef.current = new Set();
@@ -544,6 +575,7 @@ export function useChatThread(params) {
             if (body.usage)
                 setUsage(body.usage);
             setTurnTelemetry(body.turnTelemetry ?? []);
+            setUserTurnOutline(body.userTurnOutline ?? []);
             setSddSessionIdentity(body.sddDataAlignment ?? null);
             // Resume the events stream from the snapshot tail so the next
             // reconnect never immediately re-expires (AC-003). The refs below
@@ -554,6 +586,7 @@ export function useChatThread(params) {
             refs.sealedAssistantIdsRef.current = new Set();
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
             setConversationNodes(conversationNodesFromEvents(body.conversationEvents ?? []));
+            setTurnStatesById((current) => mergeTurnStateSummaries(current, body.session?.turnStates));
             // Recovery is addressed to targetSessionId, so an optimistic
             // submission from another session must never be projected into
             // this snapshot (the activation path enforces the same owner gate).
@@ -616,6 +649,7 @@ export function useChatThread(params) {
         historyNextCursor,
         historyLoading,
         loadEarlierMessages,
+        loadThroughMessage,
         unread,
         humanGateCards,
         interview,
@@ -625,8 +659,11 @@ export function useChatThread(params) {
         usage,
         sessionStats,
         turnTelemetry,
+        userTurnOutline,
         operatorActions,
         conversationNodes,
+        turnStatesById,
+        reconcileTurnStates,
         sddSessionIdentity,
         setSddSessionIdentity,
         streaming,

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

@@ -94,7 +94,7 @@ export function useRepoBrowser(params) {
         document.addEventListener("visibilitychange", onVisibility);
         return () => document.removeEventListener("visibilitychange", onVisibility);
     }, [refreshTree]);
-    const openPreview = useCallback(async (file) => {
+    const openPreview = useCallback(async (file, focusLine) => {
         if (blocked)
             return; // AC-R5-002: fail-closed
         if (!workspaceScopeReady(workspaceId))
@@ -108,7 +108,10 @@ export function useRepoBrowser(params) {
                 return;
             if (!res.ok || !body.data)
                 throw new Error(body.error?.message ?? "无法预览文件");
-            const loaded = withHtmlPreviewUrl(body.data, origin, workspaceId);
+            const loaded = {
+                ...withHtmlPreviewUrl(body.data, origin, workspaceId),
+                ...(focusLine ? { focusLine } : {}),
+            };
             setPreviews((current) => {
                 const next = [
                     ...current.filter((item) => item.path !== loaded.path),

package/dist/worker/scheduler/scheduled-goal-dispatch.js

@@ -69,10 +69,11 @@ export async function prepareScheduledGoalDraft(input, client) {
     if (!assessment.ok)
         throw new Error(`scheduled goal ineligible: ${assessment.reason}`);
     const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+    const repositoryPath = (file) => path.relative(root, file).split(path.sep).join("/");
     return scheduledGoalDraftSchema.parse({ ...parsed, controllerRef: identity.packageFingerprint.value,
         prepared: { gateToken: `${snapshot.gate.id}:${snapshot.gate.digest}`,
-            dagPath: path.relative(root, paths.dagDraftPath), dagHash: digest(dagBytes),
-            contractPath: path.relative(root, paths.taskConfigPath), contractHash: digest(configBytes) }, });
+            dagPath: repositoryPath(paths.dagDraftPath), dagHash: digest(dagBytes),
+            contractPath: repositoryPath(paths.taskConfigPath), contractHash: digest(configBytes) }, });
 }
 /** Materialize only contract/runtime inputs; execution remains owned by the operation host. */
 export async function prepareDerivedScheduledGoalTask(goalId, ownerToken, goals, client) {

package/dist/worker/scheduler/scheduled-goal-evidence.js

@@ -201,8 +201,13 @@ export async function captureScheduledGoalTree(worktree, base, allowedPaths, for
             }
             else if (stat.isFile()) {
                 const bytes = await readFile(target);
-                files.push({ name, kind: "file", hash: sha256(bytes), executable: Boolean(stat.mode & 0o111) });
                 actualId = normalizedIds.get(name) ?? blobId(bytes);
+                files.push({
+                    name,
+                    kind: "file",
+                    hash: sha256(`${objectFormat}:${actualId}`),
+                    executable: Boolean(stat.mode & 0o111),
+                });
                 actualMode = stat.mode & 0o111 ? "100755" : "100644";
             }
             else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.44.0-next.6",
+  "version": "0.44.0-next.8",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/dist/worker/console/static/assets/channel-DNWB4hpR.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-C0HdXtOf.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-COhFgJji.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-BTbmx3-k.js";import{_ as i}from"./mermaid.core-C0HdXtOf.js";import"./chunk-5VM5RSS4-BpJIdTKV.js";import"./chunk-XXDRQBXY-DrTdoYZG.js";import"./chunk-KBJHAD2P-B487SORR.js";import"./chunk-2GRJ4B5K-BKKnyR9Z.js";import"./index-CJh6pVLm.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-COhFgJji.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-BTbmx3-k.js";import{_ as i}from"./mermaid.core-C0HdXtOf.js";import"./chunk-5VM5RSS4-BpJIdTKV.js";import"./chunk-XXDRQBXY-DrTdoYZG.js";import"./chunk-KBJHAD2P-B487SORR.js";import"./chunk-2GRJ4B5K-BKKnyR9Z.js";import"./index-CJh6pVLm.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};