@tea-agent/loop-agent 0.43.0 → 0.44.0-next.2

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

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
@@ -179,10 +179,11 @@ function mergeCompactionMessages(messages, compactions) {
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
     const { origin, refs, setSession, thread, composer, browser, setError, setNotice, onCompactionChange, setProcessOpen, setAutoScroll, } = params;
-    const { applyActivatedSession, resetForNewSession, setMessages } = thread;
+    const { applyActivatedSession, resetForNewSession, setMessages, refreshSessionTelemetry, } = thread;
     const { seedSession, releaseSession } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const { workspaceId, blocked } = params;
+    const visibleWorkspaceIds = useMemo(() => new Set(params.visibleWorkspaceIds), [params.visibleWorkspaceIds]);
     const workspaceQuery = workspaceId
         ? `?workspaceId=${encodeURIComponent(workspaceId)}`
         : "";
@@ -276,10 +277,13 @@ export function useChatSessions(params) {
                 return;
             }
             const sessions = body.sessions ?? [];
-            const durable = sessions.filter((item) => !pendingDeletedIdsRef.current.has(item.sessionId));
-            const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => !durable.some((session) => session.sessionId === item.sessionId));
-            // Preserve every workspace's summaries. ChatWorkspaceSidebar applies the
-            // visible recent-item limit independently inside each workspace group.
+            const belongsToVisibleWorkspace = (item) => !item.workspaceId || visibleWorkspaceIds.has(item.workspaceId);
+            const durable = sessions.filter((item) => belongsToVisibleWorkspace(item) &&
+                !pendingDeletedIdsRef.current.has(item.sessionId));
+            const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => belongsToVisibleWorkspace(item) &&
+                !durable.some((session) => session.sessionId === item.sessionId));
+            // Preserve summaries for visible workspaces. ChatWorkspaceSidebar applies
+            // the recent-item limit independently inside each workspace group.
             const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
             sessionListRef.current = next;
             setSessionList(next);
@@ -292,7 +296,7 @@ export function useChatSessions(params) {
                 return;
             setError(`会话列表加载失败：${error instanceof Error ? error.message : String(error)}`);
         }
-    }, [origin, blocked, setError]);
+    }, [origin, blocked, setError, visibleWorkspaceIds]);
     const deleteSession = useCallback(async (sessionId) => {
         if (pendingDeletedIdsRef.current.has(sessionId))
             return false;
@@ -500,6 +504,7 @@ export function useChatSessions(params) {
                 sessionStats: body.sessionStats,
                 usage: body.usage,
                 turnTelemetry: body.turnTelemetry,
+                sddSessionIdentity: body.sddDataAlignment ?? null,
                 streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                 turnPhase: body.session.turnPhase ??
                     (body.session.activeTurnId ? "running" : "idle"),
@@ -634,6 +639,7 @@ export function useChatSessions(params) {
                     sessionStats: body.sessionStats,
                     usage: body.usage,
                     turnTelemetry: body.turnTelemetry,
+                    sddSessionIdentity: body.sddDataAlignment ?? null,
                     streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                     turnPhase: body.session.turnPhase ??
                         (body.session.activeTurnId ? "running" : "idle"),
@@ -760,6 +766,7 @@ export function useChatSessions(params) {
             setSelectedSession(created);
             rememberActiveChatSession(window.localStorage, created.workspaceId ?? options?.workspaceId ?? workspaceId, created.sessionId);
             setSession(created);
+            void refreshSessionTelemetry();
             return created;
         }
         catch (e) {
@@ -783,6 +790,7 @@ export function useChatSessions(params) {
         activateSession,
         blocked,
         workspaceId,
+        refreshSessionTelemetry,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */

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

@@ -1,5 +1,6 @@
 import { useCallback, useEffect } from "react";
 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";
@@ -104,6 +105,7 @@ export function useChatStream(params) {
      * means replay cannot render duplicate messages while live text remains
      * smooth (M4.1/M4.3). */
     const openEventsStream = useCallback(async (sessionId, generation, signal) => {
+        const gapReplayBuffer = [];
         while (!signal.aborted) {
             const state = refs.eventsStreamStateRef.current;
             if (!state ||
@@ -129,21 +131,38 @@ export function useChatStream(params) {
                 const decoder = new TextDecoder();
                 let buffer = "";
                 let replay = true;
+                let replayRepairNeeded = false;
+                let liveContinuityCursor = null;
                 const fallbackAssistantId = requestId("a");
-                for (;;) {
+                readLoop: for (;;) {
                     const { done, value } = await reader.read();
                     if (done)
                         break;
                     buffer += decoder.decode(value, { stream: true });
                     const blocks = buffer.split("\n\n");
                     buffer = blocks.pop() ?? "";
-                    for (const block of blocks) {
+                    for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+                        const block = blocks[blockIndex];
+                        if (block === undefined)
+                            continue;
+                        if (!replay) {
+                            const continuity = inspectChatSseContinuity(block, liveContinuityCursor);
+                            if (continuity.action === "reconnect") {
+                                // Buffer this block and the rest of the decoded chunk before closing
+                                // the reader. Retained replay repairs structure; the buffer preserves
+                                // cumulative text frames that persistence may have coalesced away.
+                                gapReplayBuffer.push(...blocks.slice(blockIndex));
+                                replayRepairNeeded = true;
+                                break readLoop;
+                            }
+                        }
                         if (sseEventName(block) === "stream_ready") {
                             const current = refs.eventsStreamStateRef.current;
                             if (current?.sessionId === sessionId &&
                                 current.generation === generation)
                                 current.ready = true;
                             replay = false;
+                            liveContinuityCursor = readChatStreamReadyCursor(block);
                             // Fall through: the applier owns the buffered-replay flush and
                             // returns immediately for this event. `continue` here silently
                             // dropped that flush, so a reconnect that landed after the
@@ -155,15 +174,38 @@ export function useChatStream(params) {
                             targetSessionId: sessionId,
                             generation,
                         });
-                        if (eventId)
-                            refs.lastEventIdRef.current = eventId;
+                        if (eventId) {
+                            refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, eventId);
+                            if (!replay)
+                                liveContinuityCursor = selectLaterChatEventId(liveContinuityCursor, eventId);
+                        }
+                        if (sseEventName(block) === "stream_ready" &&
+                            gapReplayBuffer.length > 0) {
+                            const repairedBlocks = selectChatSseRepairBlocks(gapReplayBuffer.splice(0), liveContinuityCursor);
+                            for (const repairedBlock of repairedBlocks) {
+                                const repairedEventId = applySseBlock(repairedBlock, refs.assistantIdRef.current ?? fallbackAssistantId, {
+                                    replay: false,
+                                    targetSessionId: sessionId,
+                                    generation,
+                                });
+                                if (!repairedEventId)
+                                    continue;
+                                refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, repairedEventId);
+                            }
+                        }
                     }
                 }
+                if (replayRepairNeeded) {
+                    await reader.cancel().catch(() => undefined);
+                }
                 const current = refs.eventsStreamStateRef.current;
                 if (current?.sessionId === sessionId &&
                     current.generation === generation)
                     current.ready = false;
-                await sleep(1_000, signal);
+                // A detected hole is expected to be immediately recoverable from the
+                // durable ring. Other EOFs retain the normal reconnect backoff.
+                if (!replayRepairNeeded)
+                    await sleep(1_000, signal);
             }
             catch {
                 if (signal.aborted)

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

@@ -140,6 +140,8 @@ export function useChatThread(params) {
     const [usage, setUsage] = useState(EMPTY_USAGE);
     const [sessionStats, setSessionStats] = useState(EMPTY_SESSION_STATS);
     const [turnTelemetry, setTurnTelemetry] = useState([]);
+    const [operatorActions, setOperatorActions] = useState([]);
+    const [sddSessionIdentity, setSddSessionIdentity] = useState(null);
     const [streaming, setStreaming] = useState(false);
     const [turnPhase, setTurnPhase] = useState("idle");
     const [deferredTurn, setDeferredTurn] = useState(null);
@@ -167,6 +169,7 @@ export function useChatThread(params) {
             if (body.usage)
                 setUsage(body.usage);
             setTurnTelemetry(body.turnTelemetry ?? []);
+            setSddSessionIdentity(body.sddDataAlignment ?? null);
         }
         catch {
             // Telemetry is supplementary; the normal event stream remains authoritative.
@@ -188,6 +191,8 @@ export function useChatThread(params) {
         setPendingQuestion,
         setTodos,
         setGoal,
+        setOperatorActions,
+        setSddSessionIdentity,
         setStreamingAssistantId,
         setUnread,
         setOperationCards,
@@ -421,6 +426,8 @@ export function useChatThread(params) {
         setUsage(EMPTY_USAGE);
         setSessionStats(EMPTY_SESSION_STATS);
         setTurnTelemetry([]);
+        setOperatorActions([]);
+        setSddSessionIdentity(null);
         setStreaming(false);
         setTurnPhase("idle");
         setDeferredTurn(null);
@@ -477,6 +484,8 @@ export function useChatThread(params) {
         setUsage(next.usage ?? EMPTY_USAGE);
         setSessionStats(next.sessionStats ?? EMPTY_SESSION_STATS);
         setTurnTelemetry(next.turnTelemetry ?? []);
+        setOperatorActions([]);
+        setSddSessionIdentity(next.sddSessionIdentity ?? null);
         refs.usageResponseKeysRef.current = new Set();
         setStreaming(visuallyStopped ? false : next.streaming);
         setTurnPhase(visuallyStopped
@@ -500,13 +509,15 @@ export function useChatThread(params) {
      *  operation/human-gate/artifact/interview cards, which the reconnected tail
      *  stream will not replay (they live in the ring, already consumed). */
     const recoverSession = useCallback(async (targetSessionId) => {
+        const targetGeneration = refs.sessionGenerationRef.current;
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}`, { credentials: "include" });
             if (!res.ok)
                 return false;
             const body = (await res.json());
             if (!body.session ||
-                refs.sessionRef.current?.sessionId !== targetSessionId)
+                refs.sessionRef.current?.sessionId !== targetSessionId ||
+                refs.sessionGenerationRef.current !== targetGeneration)
                 return false;
             const activeTurnId = body.session.activeTurnId ?? null;
             const visuallyStopped = body.session.turnPhase === "stopping";
@@ -526,6 +537,7 @@ export function useChatThread(params) {
             if (body.usage)
                 setUsage(body.usage);
             setTurnTelemetry(body.turnTelemetry ?? []);
+            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
             // are reset so any follow-up tail replay re-applies cleanly.
@@ -534,7 +546,13 @@ export function useChatThread(params) {
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
-            const pending = refs.pendingSubmissionRef.current;
+            // 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).
+            const pending = refs.pendingSubmissionRef.current?.sessionId === targetSessionId &&
+                refs.pendingSubmissionRef.current.sessionGeneration === targetGeneration
+                ? refs.pendingSubmissionRef.current
+                : undefined;
             const recovered = mergePendingSubmissionOnHydration(hydrated.messages, pending
                 ? {
                     clientRequestId: pending.clientRequestId,
@@ -599,6 +617,9 @@ export function useChatThread(params) {
         usage,
         sessionStats,
         turnTelemetry,
+        operatorActions,
+        sddSessionIdentity,
+        setSddSessionIdentity,
         streaming,
         setStreaming,
         turnPhase,
@@ -621,6 +642,7 @@ export function useChatThread(params) {
         applySseBlock,
         loadTaskContext,
         applyOperationLinkMutation,
+        refreshSessionTelemetry,
         resetForNewSession,
         applyActivatedSession,
         recoverSession,

package/dist/worker/console/workspace-context.js

@@ -265,6 +265,7 @@ export async function createWorkspaceContext(record, deps) {
     const aimaxAuth = new AimaxAuthReader();
     await aimaxAuth.getToken();
     const sddDataAlignment = new SddDataAlignmentService(chatStore, aimaxAuth, deps.fetchImpl);
+    actionContext.sddDataAlignment = sddDataAlignment;
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { lstat, readFile, readlink, realpath } from "node:fs/promises";
 import path from "node:path";
@@ -7,6 +7,59 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { scheduledGoalDraftSchema } from "./scheduled-goal-types.js";
 const execFileAsync = promisify(execFile);
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/** Working-copy paths that are plain files, so Git can read them back. */
+async function plainFileNames(root, names) {
+    const plain = [];
+    for (const name of names) {
+        const info = await lstat(path.resolve(root, name)).catch(() => undefined);
+        if (info?.isFile())
+            plain.push(name);
+    }
+    return plain;
+}
+/**
+ * Repository-form blob IDs for working-copy files, computed by Git itself so
+ * that `core.autocrlf` and `eol` attributes normalize exactly as a commit
+ * would. Hashing never consults the index, so staged-only and
+ * `assume-unchanged` paths keep their raw-byte meaning. A failure degrades to
+ * the caller's raw-byte blob, which can only over-report change, never hide it;
+ * `--stdin-paths` cannot carry names containing a newline.
+ */
+async function gitNormalizedBlobIds(root, names) {
+    const ids = new Map();
+    const candidates = names.filter((name) => !name.includes("\n"));
+    if (candidates.length === 0)
+        return ids;
+    let stdout;
+    try {
+        stdout = await new Promise((resolve, reject) => {
+            const child = spawn("git", ["-C", root, "hash-object", "--stdin-paths"], { stdio: ["pipe", "pipe", "pipe"] });
+            let output = "";
+            let failure = "";
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => { output += chunk; });
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => { failure += chunk; });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve(output);
+                else
+                    reject(new Error(`git hash-object failed: ${failure.trim()}`));
+            });
+            child.stdin.end(`${candidates.join("\n")}\n`);
+        });
+    }
+    catch {
+        return ids;
+    }
+    const hashes = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+    if (hashes.length !== candidates.length)
+        return ids;
+    for (let index = 0; index < candidates.length; index += 1)
+        ids.set(candidates[index], hashes[index]);
+    return ids;
+}
 /** Run only frozen AC commands. A timeout is uncertain execution, never a passing or repairable failure. */
 export async function evaluateScheduledGoalCriteria(frozen, options = {}) {
     frozen = scheduledGoalDraftSchema.pick({ worktreeRef: true, frozenBase: true, allowedPaths: true, forbiddenPaths: true, acceptance: true, time: true }).strip().parse(frozen);
@@ -115,6 +168,11 @@ export async function captureScheduledGoalTree(worktree, base, allowedPaths, for
     const blobId = (bytes) => createHash(objectFormat).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
     const names = [...new Set([...entries(tracked), ...entries(untracked), ...baseEntries.keys()])].sort();
     const deliveryNames = new Set(names);
+    // Compare content identity through Git's own normalization: a working copy
+    // materialized with `core.autocrlf` (or an `eol` attribute) is stored as LF
+    // while the checkout is CRLF, and raw bytes would report that as drift on
+    // every text file.
+    const normalizedIds = await gitNormalizedBlobIds(root, await plainFileNames(root, names));
     const files = [];
     const changedPaths = [];
     for (const name of names) {
@@ -144,7 +202,7 @@ 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 = blobId(bytes);
+                actualId = normalizedIds.get(name) ?? blobId(bytes);
                 actualMode = stat.mode & 0o111 ? "100755" : "100644";
             }
             else

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

@@ -16,6 +16,16 @@ async function syncDirectory(directoryPath) {
     try {
         await directory.sync();
     }
+    catch (error) {
+        // The file body is already durable from the file-level fsync above.
+        // Windows refuses to flush a directory handle (EPERM) and some
+        // filesystems reject the call outright, so a directory-only failure must
+        // not abort a transaction whose data is already on disk.
+        const code = error.code;
+        if (code !== "EPERM" && code !== "EACCES" && code !== "EINVAL"
+            && code !== "ENOTSUP" && code !== "EOPNOTSUPP" && code !== "ENOSYS")
+            throw error;
+    }
     finally {
         await directory.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0",
+  "version": "0.44.0-next.2",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -84,7 +84,9 @@
     "commander": "^12.1.0",
     "katex": "^0.16.47",
     "mermaid": "^11.16.1",
+    "mysql2": "^3.24.4",
     "node-pty": "^1.2.0-beta.15",
+    "pg": "^8.23.0",
     "playwright-core": "^1.63.0",
     "rehype-highlight": "^7.0.2",
     "rehype-katex": "^7.0.1",

package/dist/worker/console/static/assets/channel-ChE7y-cx.js

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

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

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-CxcKZ9mV.js";import{_ as i}from"./mermaid.core-7pKqYtpZ.js";import"./chunk-5VM5RSS4-XKxoJNJ4.js";import"./chunk-XXDRQBXY-DC_Ds11b.js";import"./chunk-KBJHAD2P-DebTtdFp.js";import"./chunk-2GRJ4B5K-YBHmhik1.js";import"./index-Cdkvw_H6.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-C01TCf2X.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-CxcKZ9mV.js";import{_ as i}from"./mermaid.core-7pKqYtpZ.js";import"./chunk-5VM5RSS4-XKxoJNJ4.js";import"./chunk-XXDRQBXY-DC_Ds11b.js";import"./chunk-KBJHAD2P-DebTtdFp.js";import"./chunk-2GRJ4B5K-YBHmhik1.js";import"./index-Cdkvw_H6.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};