@tea-agent/loop-agent 0.43.0-next.10 → 0.43.0-next.12

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

@@ -1,31 +1,70 @@
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, } from "react";
 import { filterSlashCommands, mergeSlashCommands, } from "../../chat/shortcuts.js";
-import { confirmationToken } from "./format.js";
+import { ComposerSessionLedger, composerSessionKey, } from "./composer-session-ledger.js";
+import { confirmationToken, requestId } from "./format.js";
 import { clampShortcutIndex } from "./slash-palette-nav.js";
-import { createInputHistoryState, navigateInputHistory, recordInputHistoryEntry, resetInputHistoryBrowsing, } from "./input-history.js";
 import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
+function sameComposerSession(left, right) {
+    if (!left || !right)
+        return left === right;
+    return composerSessionKey(left) === composerSessionKey(right);
+}
+function readPendingImage(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => reject(reader.error ?? new Error("图片读取失败"));
+        reader.onload = () => {
+            const value = String(reader.result ?? "");
+            resolve({
+                name: file.name,
+                type: "image",
+                mimeType: file.type,
+                data: value.slice(value.indexOf(",") + 1),
+            });
+        };
+        reader.readAsDataURL(file);
+    });
+}
 /** Composer state: input text, @file palette, image attachments, /shortcuts,
  *  IME composition guards, auto-grow and server-side draft sync. */
 export function useComposer(params) {
-    const { origin, sessionId, sessionMode, refs, setError, onUnrecoverableSession, } = params;
-    const [input, setInputState] = useState("");
+    const { origin, sessionIdentity, sessionMode, sessionReady = true, refs, setError, onUnrecoverableSession, } = params;
+    const sessionId = sessionIdentity?.sessionId;
+    const ledgerRef = useRef(null);
+    if (!ledgerRef.current)
+        ledgerRef.current = new ComposerSessionLedger();
+    const ledger = ledgerRef.current;
+    const activeIdentityRef = useRef(sessionIdentity);
+    activeIdentityRef.current = sessionIdentity;
+    const [, forceRender] = useReducer((version) => version + 1, 0);
+    const activeSnapshot = sessionIdentity
+        ? ledger.snapshot(sessionIdentity)
+        : { draft: "", images: [] };
+    const input = activeSnapshot.draft;
+    const pendingImages = activeSnapshot.images;
     const [fileOptions, setFileOptions] = useState([]);
-    const [pendingImages, setPendingImages] = useState([]);
     const [shortcutOpen, setShortcutOpen] = useState(false);
     /** Any composer text that starts with `/` should reveal the palette,
      *  including draft restore. Escape can still close it without clearing. */
     const setInput = useCallback((value) => {
-        if (typeof value === "function") {
-            setInputState((prev) => {
-                const next = value(prev);
-                setShortcutOpen(next.startsWith("/"));
-                return next;
-            });
+        const identity = activeIdentityRef.current;
+        if (!identity)
             return;
-        }
-        setInputState(value);
-        setShortcutOpen(value.startsWith("/"));
-    }, []);
+        const previous = ledger.snapshot(identity).draft;
+        const next = typeof value === "function" ? value(previous) : value;
+        if (ledger.setDraft(identity, next))
+            forceRender();
+        setShortcutOpen(next.startsWith("/"));
+    }, [ledger]);
+    const setPendingImages = useCallback((value) => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return;
+        const previous = ledger.snapshot(identity).images;
+        const next = typeof value === "function" ? value(previous) : value;
+        ledger.setImages(identity, next);
+        forceRender();
+    }, [ledger]);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
     const [commandCapabilities, setCommandCapabilities] = useState({
@@ -36,30 +75,29 @@ export function useComposer(params) {
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
     const textareaRef = useRef(null);
-    /** Arrow-key input history; unsent drafts survive history browsing. */
-    const historyRef = useRef(createInputHistoryState());
     /** Active session generation for /commands; bumped immediately on switch (AC-2). */
     const commandsSessionRef = useRef(sessionId);
     const commandsGenerationRef = useRef(0);
     const handleInputChange = useCallback((value) => {
         setInput(value);
-        setShortcutOpen(value.startsWith("/"));
         setShortcutIndex(0);
-        // Manual typing edits a recalled entry in place → back to present draft.
-        historyRef.current = resetInputHistoryBrowsing(historyRef.current);
-    }, []);
+    }, [setInput]);
     /** Recall an earlier input via ↑/↓; returns true when the key was consumed. */
     const navigateHistory = useCallback((direction) => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return false;
+        const current = ledger.snapshot(identity).draft;
         const textarea = textareaRef.current;
-        const decision = navigateInputHistory(historyRef.current, direction, {
-            text: input,
-            caretStart: textarea?.selectionStart ?? input.length,
-            caretEnd: textarea?.selectionEnd ?? input.length,
+        const decision = ledger.navigateHistory(identity, direction, {
+            text: current,
+            caretStart: textarea?.selectionStart ?? current.length,
+            caretEnd: textarea?.selectionEnd ?? current.length,
         });
         if (!decision.handled)
             return false;
-        historyRef.current = decision.state;
-        setInput(decision.text);
+        forceRender();
+        setShortcutOpen(decision.text.startsWith("/"));
         const caret = decision.text.length;
         queueMicrotask(() => {
             const el = textareaRef.current;
@@ -68,22 +106,76 @@ export function useComposer(params) {
             }
         });
         return true;
-    }, [input, setInput]);
-    /** Record a submitted text into history (consecutive duplicates collapse). */
+    }, [ledger]);
+    /** Record a submitted text into the selected session's history. */
     const recordHistory = useCallback((text) => {
-        historyRef.current = recordInputHistoryEntry(historyRef.current, text);
-    }, []);
+        const identity = activeIdentityRef.current;
+        if (identity)
+            ledger.recordHistory(identity, text);
+    }, [ledger]);
+    const claimSubmission = useCallback(() => {
+        const identity = activeIdentityRef.current;
+        if (!identity)
+            return null;
+        const attempt = ledger.beginSubmission(identity, refs.sessionGenerationRef.current, requestId("chat-submit"));
+        if (!attempt)
+            return null;
+        forceRender();
+        setShortcutOpen(false);
+        setShortcutIndex(0);
+        return attempt;
+    }, [ledger, refs]);
+    const claimSessionSubmission = useCallback((identity, text, images = []) => {
+        ledger.setDraft(identity, text);
+        ledger.setImages(identity, images);
+        const attempt = ledger.beginSubmission(identity, refs.sessionGenerationRef.current, requestId("chat-submit"));
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return attempt;
+    }, [ledger, refs]);
+    const settleSubmission = useCallback((attempt, outcome) => {
+        const result = ledger.settle(attempt, outcome);
+        if (sameComposerSession(activeIdentityRef.current, attempt.identity))
+            forceRender();
+        return result;
+    }, [ledger]);
+    const settleSubmissionByRequest = useCallback((identity, clientRequestId, outcome) => {
+        const result = ledger.settleByRequest(identity, clientRequestId, outcome);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return result;
+    }, [ledger]);
+    const seedSession = useCallback((identity, draft) => {
+        const seeded = ledger.seedDraft(identity, draft);
+        if (seeded && sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+        return seeded;
+    }, [ledger]);
+    const replaceSessionDraft = useCallback((identity, draft, images) => {
+        ledger.setDraft(identity, draft);
+        ledger.setImages(identity, images);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+    }, [ledger]);
+    const releaseSession = useCallback((identity) => {
+        ledger.release(identity);
+        if (sameComposerSession(activeIdentityRef.current, identity))
+            forceRender();
+    }, [ledger]);
     // Immediate invalidation on A→B even when B palette never opens (AC-2).
     useLayoutEffect(() => {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
+        refs.isComposingRef.current = false;
+        setFileOptions([]);
+        setShortcutOpen(input.startsWith("/"));
         setDynamicCommands([]);
         setCommandCapabilities({ sddBingo: false, sessionMode });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
     }, [sessionId, sessionMode]);
     const loadDynamicCommands = useCallback(async () => {
-        if (!sessionId) {
+        if (!sessionId || !sessionReady) {
             setDynamicCommands([]);
             setDynamicCommandsError(null);
             setDynamicCommandsLoading(false);
@@ -147,21 +239,21 @@ export function useComposer(params) {
                 setDynamicCommandsLoading(false);
             }
         }
-    }, [origin, sessionId, sessionMode]);
+    }, [origin, sessionId, sessionMode, sessionReady]);
     // Lazy-load dynamic commands when slash palette opens or session changes.
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionReady)
             return;
         if (!shortcutOpen && commandsEpoch === 0)
             return;
         void loadDynamicCommands();
-    }, [sessionId, shortcutOpen, commandsEpoch, loadDynamicCommands]);
+    }, [sessionId, sessionReady, shortcutOpen, commandsEpoch, loadDynamicCommands]);
     const retryDynamicCommands = useCallback(() => {
         setCommandsEpoch((n) => n + 1);
         void loadDynamicCommands();
     }, [loadDynamicCommands]);
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionIdentity || !sessionReady)
             return;
         const match = input
             .slice(0, textareaRef.current?.selectionStart ?? input.length)
@@ -170,13 +262,29 @@ export function useComposer(params) {
             setFileOptions([]);
             return;
         }
+        const owner = { ...sessionIdentity };
+        const ownerKey = composerSessionKey(owner);
+        const generation = refs.sessionGenerationRef.current;
+        const controller = new AbortController();
         const timer = window.setTimeout(() => {
-            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`)
+            void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(match[1] ?? "")}`, { signal: controller.signal })
                 .then((r) => (r.ok ? r.json() : null))
-                .then((body) => setFileOptions((body?.files ?? []).map((item) => item.path)));
+                .then((body) => {
+                const active = activeIdentityRef.current;
+                if (controller.signal.aborted ||
+                    !active ||
+                    composerSessionKey(active) !== ownerKey ||
+                    refs.sessionGenerationRef.current !== generation)
+                    return;
+                setFileOptions((body?.files ?? []).map((item) => item.path));
+            })
+                .catch(() => undefined);
         }, 150);
-        return () => window.clearTimeout(timer);
-    }, [origin, sessionId, input]);
+        return () => {
+            window.clearTimeout(timer);
+            controller.abort();
+        };
+    }, [origin, sessionId, sessionIdentity, sessionReady, input, refs]);
     const insertFileReference = useCallback((file) => {
         const caret = textareaRef.current?.selectionStart ?? input.length;
         const before = input.slice(0, caret);
@@ -185,33 +293,31 @@ export function useComposer(params) {
             return;
         setInput(`${input.slice(0, start)}@${file} ${input.slice(caret)}`);
         setFileOptions([]);
-    }, [input]);
+    }, [input, setInput]);
     const addImagesFromFiles = useCallback((files) => {
-        for (const file of Array.from(files).slice(0, 4)) {
-            if (!file.type.startsWith("image/") || file.size > 5 * 1024 * 1024) {
-                setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
-                continue;
-            }
-            const reader = new FileReader();
-            reader.onload = () => {
-                const value = String(reader.result ?? "");
-                const data = value.slice(value.indexOf(",") + 1);
-                setPendingImages((items) => [
-                    ...items,
-                    {
-                        name: file.name,
-                        type: "image",
-                        mimeType: file.type,
-                        data,
-                    },
-                ].slice(0, 4));
-            };
-            reader.readAsDataURL(file);
-        }
-    }, [setError]);
+        const owner = activeIdentityRef.current;
+        if (!owner)
+            return;
+        const ownerIdentity = { ...owner };
+        const selected = Array.from(files).slice(0, 4);
+        const valid = selected.filter((file) => file.type.startsWith("image/") && file.size <= 5 * 1024 * 1024);
+        if (valid.length !== selected.length)
+            setError("图片仅支持 PNG/JPEG/GIF/WebP，单张不超过 5 MiB");
+        void Promise.all(valid.map(readPendingImage)).then((loaded) => {
+            if (!ledger.has(ownerIdentity) || loaded.length === 0)
+                return;
+            const current = ledger.snapshot(ownerIdentity).images;
+            ledger.setImages(ownerIdentity, [...current, ...loaded].slice(0, 4));
+            if (sameComposerSession(activeIdentityRef.current, ownerIdentity))
+                forceRender();
+        }, (error) => {
+            if (sameComposerSession(activeIdentityRef.current, ownerIdentity))
+                setError(error instanceof Error ? error.message : "图片读取失败");
+        });
+    }, [ledger, setError]);
     const removeImage = useCallback((image) => {
         setPendingImages((items) => items.filter((item) => item !== image));
-    }, []);
+    }, [setPendingImages]);
     // Chromium handles growth in CSS without forcing a layout read on every key.
     // Keep a deferred fallback for browsers that do not support field-sizing.
     useEffect(() => {
@@ -231,7 +337,7 @@ export function useComposer(params) {
     }, [input]);
     // Debounced server-side composer draft sync.
     useEffect(() => {
-        if (!sessionId)
+        if (!sessionId || !sessionReady)
             return;
         const timer = window.setTimeout(() => {
             void fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/draft`, {
@@ -245,7 +351,7 @@ export function useComposer(params) {
             });
         }, 400);
         return () => window.clearTimeout(timer);
-    }, [origin, sessionId, input]);
+    }, [origin, sessionId, sessionReady, input]);
     const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands, commandCapabilities), [dynamicCommands, commandCapabilities]);
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
@@ -279,17 +385,24 @@ export function useComposer(params) {
     useEffect(() => {
         attachRuntimeSnapshotController({
             origin,
-            sessionId,
+            sessionId: sessionReady ? sessionId : undefined,
             refs,
             onUnrecoverableSession,
         });
-    }, [origin, sessionId, refs, onUnrecoverableSession]);
+    }, [origin, sessionId, sessionReady, refs, onUnrecoverableSession]);
     return {
         input,
         setInput,
         handleInputChange,
         navigateHistory,
         recordHistory,
+        claimSubmission,
+        claimSessionSubmission,
+        settleSubmission,
+        settleSubmissionByRequest,
+        seedSession,
+        replaceSessionDraft,
+        releaseSession,
         fileOptions,
         pendingImages,
         setPendingImages,

package/dist/workflows/dag/frontend-closeout.js

@@ -114,7 +114,7 @@ export function buildFrontendTestHandoff(input) {
  * required verification evidence. Anything else downgrades to pending.
  */
 export function deriveFrontendIntegrationFacts(input) {
-    const requiredEvidenceSatisfied = input.verificationTargets.length > 0 &&
+    const requiredEvidenceSatisfied = input.verificationTargets.some((target) => target.mode === "behavior") &&
         input.verificationTargets.every((target) => target.status === "ok");
     if (input.realApiEvidence.present &&
         input.realApiEvidence.passed &&

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -702,10 +702,10 @@ export async function runFrontendPrewriteGate(input) {
             failureCode: "mock-strategy-outside-allowed",
         });
     }
-    // Mock command binding (main): a non-not-needed strategy can only be proven
-    // by the DAG's frozen Mock verification commands. Block before any write is
-    // authorized when none were materialized at generation time.
+    // Behavior verification needs bound Mock evidence. Build-only implementation
+    // does not claim tested Mock behavior and may defer those commands.
     if (mockStrategy !== "not-needed" &&
+        analysis.canonical.verificationTargets.some((target) => target.mode === "behavior") &&
         (input.config.mockCommandLabels?.length ?? 0) === 0) {
         return finalizePrewrite(input, {
             ...basePending,

package/dist/workflows/dag/frontend-review-context.js

@@ -246,7 +246,8 @@ function assertReviewEvidence(input) {
     const trace = input.verificationTrace;
     const expectedTargets = new Map(contract.data.verificationTargets.map((target) => [target.id, target]));
     const actualTargets = Array.isArray(trace?.targets) ? trace.targets : [];
-    const mockEvidenceBound = contract.data.mockApi.strategy === "not-needed" ||
+    const mockEvidenceBound = contract.data.verificationTargets.every((target) => target.mode === "static") ||
+        contract.data.mockApi.strategy === "not-needed" ||
         (typeof trace?.mockCommandNodeId === "string" && trace.mockCommandNodeId.length > 0 &&
             Array.isArray(trace?.mockCommandLabels) && trace.mockCommandLabels.length > 0 &&
             Array.isArray(trace?.mockCommandTexts) && trace.mockCommandTexts.length === trace.mockCommandLabels.length &&

package/dist/workflows/dag/frontend-review-scopes.js

@@ -121,11 +121,11 @@ export function createFrontendReviewScopeProtocol(input) {
         committedFacts: () => readCommittedEvents(input.getStore(), input.attemptId),
         assertComplete() { const missing = input.inventory?.scopes.filter(s => !completedScopeIds().has(s.id)) ?? []; if (missing.length)
             throw Object.assign(Error(`FRONTEND_REVIEW_SCOPE_INCOMPLETE: ${missing.map(s => s.id).join(", ")}`), { code: "FRONTEND_REVIEW_SCOPE_INCOMPLETE" }); },
-        customTools: !input.inventory ? [] : [{ name: "complete_review_scope", label: "complete_review_scope", description: "After reviewing the supplied complete scope and saving its findings, checkpoint its exact runtime id. This does not approve the implementation or design.", parameters: { type: "object", properties: { id: { type: "string", minLength: 1 } }, required: ["id"], additionalProperties: false },
+        customTools: !input.inventory ? [] : [{ name: "complete_review_scope", label: "complete_review_scope", description: "After reviewing the supplied complete scope and saving its findings, checkpoint its exact runtime id. This does not approve the implementation or design.", parameters: { type: "object", properties: { id: { type: "string", minLength: 1, enum: input.inventory.scopes.map(scope => scope.id) } }, required: ["id"], additionalProperties: false },
                 async execute(callId, params) {
                     const scope = input.inventory.scopes.find(s => s.id === params.id);
                     if (!scope || !active.has(params.id))
-                        return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: "Only the supplied active review scope may be completed" });
+                        return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: "Only the supplied active review scope may be completed; use an exact activeScopeIds entry, not the node name", activeScopeIds: [...active], completedScopeIds: [...completedScopeIds()] });
                     await input.inventory.validate();
                     const store = input.getStore();
                     const requestId = `${input.attemptId}:${callId}:${randomUUID()}`;

package/dist/workflows/dag/frontend-verification-trace.js

@@ -462,7 +462,7 @@ export async function runFrontendVerificationTraceGate(input) {
     const mockCommandLabels = input.evidence?.mock?.commandLabels ?? [];
     const mockCommandNodeId = input.evidence?.mock?.nodeId;
     const mockCommandTexts = input.evidence?.mock?.commandTexts ?? [];
-    if (input.evidence && contract.mockApi.strategy !== "not-needed" && mockCommandLabels.length === 0) {
+    if (input.evidence && contract.verificationTargets.some((target) => target.mode === "behavior") && contract.mockApi.strategy !== "not-needed" && mockCommandLabels.length === 0) {
         throw new Error("trace: selected Mock strategy requires successful Mock verification commands");
     }
     if (input.evidence) {