@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

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

@@ -1,8 +1,9 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { classifyRecoveryFact, consoleRecoveryCtas, partitionRecoveryCtas, recommendedRecoveryCtaId, } from "../../recovery-cta.js";
 import { buildRecoveryReason, isAutoRecoveryReason, pickDefaultRecoveryNodeId, pickDefaultRecoveryRunId, sortRecoveryNodeCandidates, } from "../../recovery-selection.js";
-import { postOperator, RECOVERY_FACT_LABEL, } from "./console-types.js";
+import { postOperator, scopedReadUrl, RECOVERY_FACT_LABEL, } from "./console-types.js";
 import { useRecoveryActions } from "./useRecoveryActions.js";
+import { applyCanonicalHref, buildInspectHref, } from "../shell/workspace-route.js";
 /** Recovery workspace: DAG-run / node candidate selection, fact-classified
  *  CTA lanes, structured reason prefill, plan preflight and gated reruns. */
 export function useRecoveryConsole(params) {
@@ -36,12 +37,12 @@ export function useRecoveryConsole(params) {
     const inspectPath = useCallback(() => {
         if (dagRunId.trim()) {
             // from=recovery 激活统一壳的对象上下文 chip 与显式返回路径
-            return `/inspect/#/dag/${encodeURIComponent(dagRunId.trim())}?from=recovery`;
+            return buildInspectHref(`/dag/${encodeURIComponent(dagRunId.trim())}`, "from=recovery");
         }
-        return "/inspect/#/";
+        return "/#/inspect";
     }, [dagRunId]);
     const openFullInspect = useCallback(() => {
-        window.location.assign(inspectPath());
+        applyCanonicalHref(inspectPath());
     }, [inspectPath]);
     /** Resolve DAG run id for inspect (side panel or full page). */
     const resolveDagRunForInspect = useCallback(async () => {
@@ -70,7 +71,7 @@ export function useRecoveryConsole(params) {
                 setDagRunId(resolvedDag);
                 setObserveLinkStatus("match");
                 setObserveLinkMessage(null);
-                setObserveUrl(`/inspect/#/dag/${encodeURIComponent(resolvedDag)}`);
+                setObserveUrl(buildInspectHref(`/dag/${encodeURIComponent(resolvedDag)}`));
                 return resolvedDag;
             }
             setOpError("尚未找到该任务的 DAG 运行，请稍后再打开检视");
@@ -97,7 +98,7 @@ export function useRecoveryConsole(params) {
         const resolved = await resolveDagRunForInspect();
         if (!resolved)
             return;
-        window.location.assign(`/inspect/#/dag/${encodeURIComponent(resolved)}?from=recovery`);
+        applyCanonicalHref(buildInspectHref(`/dag/${encodeURIComponent(resolved)}`, "from=recovery"));
     }, [resolveDagRunForInspect]);
     const loadRecoveryRuns = useCallback(async () => {
         setRecoveryRunsLoading(true);
@@ -107,7 +108,7 @@ export function useRecoveryConsole(params) {
             if (id)
                 qs.set("taskId", id);
             qs.set("limit", "40");
-            const res = await fetch(`/api/operator/v1/recovery/candidates?${qs.toString()}`, { credentials: "same-origin" });
+            const res = await fetch(scopedReadUrl(`/api/operator/v1/recovery/candidates?${qs.toString()}`), { credentials: "same-origin" });
             if (!res.ok) {
                 setRecoveryRuns([]);
                 return;
@@ -133,7 +134,7 @@ export function useRecoveryConsole(params) {
         }
         setRecoveryNodesLoading(true);
         try {
-            const res = await fetch(`/api/dag-runs/${encodeURIComponent(id)}`, {
+            const res = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(id)}`), {
                 credentials: "same-origin",
             });
             if (!res.ok) {
@@ -253,9 +254,7 @@ export function useRecoveryConsole(params) {
             if (!refreshRunStatus)
                 return;
             try {
-                const res = await fetch(`/api/dag-runs/${encodeURIComponent(runId)}`, {
-                    credentials: "same-origin",
-                });
+                const res = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(runId)}`), { credentials: "same-origin" });
                 if (!res.ok || cancelled)
                     return;
                 const runBody = (await res.json());

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

@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 import { isTerminalDagRun } from "../../inspect-split.js";
+import { scopedReadUrl } from "./console-types.js";
 import { summarizeRunProgress, } from "../pages/tasks/run-panel-progress.js";
 const RUN_PROGRESS_POLL_INTERVAL_MS = 5000;
 /**
@@ -18,7 +19,7 @@ export function useRunProgress(dagRunId) {
         let timer;
         const load = async () => {
             try {
-                const response = await fetch(`/api/dag-runs/${encodeURIComponent(runId)}`, { credentials: "same-origin", signal: controller.signal });
+                const response = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(runId)}`), { credentials: "same-origin", signal: controller.signal });
                 if (!response.ok)
                     return;
                 const body = (await response.json());

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";
+import { requestId, scopedReadUrl, WORKFLOW_OPTIONS, } from "./console-types.js";
+export async function fetchLedgerSummary(taskId, fetchImpl) {
+    const impl = fetchImpl ?? fetch;
+    const response = await impl(scopedReadUrl(`/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/night/useNightBoard.js

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useState } from "react";
+import { scopedReadUrl } from "../app/console-types.js";
 /** Night board data plane: schedules list + doctor report + task pool +
  *  foreground aux-ticker projection, loaded together on mount/refresh. */
 export function useNightBoard(params) {
@@ -16,10 +17,12 @@ export function useNightBoard(params) {
         setLoadError(null);
         try {
             const [jobsRes, doctorRes, tasksRes, tickerRes] = await Promise.all([
-                fetch("/api/night-jobs", { credentials: "same-origin" }),
-                fetch("/api/night-jobs/doctor", { credentials: "same-origin" }),
-                fetch("/api/tasks", { credentials: "same-origin" }),
-                fetch("/api/operator/v1/night-aux-ticker", {
+                fetch(scopedReadUrl("/api/night-jobs"), { credentials: "same-origin" }),
+                fetch(scopedReadUrl("/api/night-jobs/doctor"), {
+                    credentials: "same-origin",
+                }),
+                fetch(scopedReadUrl("/api/tasks"), { credentials: "same-origin" }),
+                fetch(scopedReadUrl("/api/operator/v1/night-aux-ticker"), {
                     credentials: "same-origin",
                 }),
             ]);
@@ -59,7 +62,7 @@ export function useNightBoard(params) {
     }, [refreshBoard]);
     const onMorningReport = useCallback(async () => {
         try {
-            const res = await fetch("/api/night-jobs/morning", {
+            const res = await fetch(scopedReadUrl("/api/night-jobs/morning"), {
                 credentials: "same-origin",
             });
             if (!res.ok) {

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

@@ -3,6 +3,7 @@ import { humanGateCardFromEventPayload, mergeHumanGateCardState, } from "../../c
 import { mergeOperationCardState, operationFromEventPayload, } from "../../chat/operation-card.js";
 import { requestId } from "./format.js";
 import { parseAssistantContent } from "../../chat/assistant-content.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 /** Shared handler for a single parsed Chat SSE event (M1 reconnect).
  *
  * Used by BOTH the inline prompt POST SSE and the background reconnect
@@ -10,7 +11,9 @@ 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, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setDeferredTurns = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, onTelemetryRefresh, setMessages, setToolCalls, setPendingQuestion = () => undefined, setTodos = () => undefined, } = deps;
+    let queueOwner;
+    let queueRevision = -1;
     return (eventName, data, assistantId, options) => {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
@@ -42,6 +45,26 @@ export function createChatSseEventApplier(deps) {
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
+        if (eventName === "todo_updated" || eventName === "todo_cleared") {
+            const todos = Array.isArray(payload.todos) ? payload.todos : [];
+            setTodos(todos.filter((item) => Boolean(item) && typeof item === "object" && typeof item.content === "string" && (item.status === "pending" || item.status === "in_progress" || item.status === "completed")));
+            return;
+        }
+        if ((eventName === "question_requested" ||
+            eventName === "question_resolved" ||
+            eventName === "question_cancelled") &&
+            payload.question &&
+            typeof payload.question === "object") {
+            const question = payload.question;
+            if (typeof question.requestId === "string" &&
+                typeof question.sessionId === "string" &&
+                question.sessionId === refs.sessionRef.current?.sessionId) {
+                setPendingQuestion(eventName === "question_requested" && question.status === "pending"
+                    ? question
+                    : null);
+            }
+            return;
+        }
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
         const eventSeq = typeof data.seq === "number" && Number.isFinite(data.seq)
             ? data.seq
@@ -51,13 +74,20 @@ export function createChatSseEventApplier(deps) {
             : 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;
-            });
+            const owner = refs.sessionRef.current?.sessionId;
+            if (owner !== queueOwner) {
+                queueOwner = owner;
+                queueRevision = -1;
+            }
+            if (revision < queueRevision)
+                return;
+            queueRevision = revision;
+            setDeferredTurn(payload.deferredTurn && typeof payload.deferredTurn === "object"
+                ? payload.deferredTurn
+                : null);
+            if (Array.isArray(payload.deferredTurns)) {
+                setDeferredTurns(payload.deferredTurns);
+            }
             return;
         }
         if (eventName === "user_message") {
@@ -84,6 +114,17 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "compact" ||
+            eventName === "compaction_start" ||
+            eventName === "compaction_end") {
+            setMessages((messages) => upsertCompactionMessage(messages, {
+                eventId: typeof data.eventId === "string" ? data.eventId : undefined,
+                kind: eventName,
+                at: new Date(eventAt).toISOString(),
+                data: payload,
+            }));
+            return;
+        }
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -186,6 +227,16 @@ export function createChatSseEventApplier(deps) {
                 refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
             }
+            if (refs.stopRequestedRef.current &&
+                (!turnId ||
+                    turnId === refs.stoppingTurnIdRef.current ||
+                    turnId === refs.activeTurnIdRef.current)) {
+                refs.streamingRef.current = false;
+                setStreaming(false);
+                setTurnPhase("idle");
+                setStreamingAssistantId(null);
+                return;
+            }
             refs.streamingRef.current = true;
             setStreaming(true);
             setTurnPhase("running");
@@ -200,9 +251,22 @@ export function createChatSseEventApplier(deps) {
             // (M4.4). It must not prematurely close the visible turn.
             if (eventName === "agent_end")
                 return;
+            const pending = refs.pendingSubmissionRef.current;
+            if (pending && turnId && pending.acceptedTurnId === turnId) {
+                refs.releasedClientRequestIdsRef.current.add(pending.clientRequestId);
+                refs.pendingSubmissionRef.current = null;
+                refs.submitInFlightRef.current = false;
+            }
+            if (!turnId ||
+                turnId === refs.stoppingTurnIdRef.current ||
+                turnId === refs.activeTurnIdRef.current) {
+                refs.stoppingTurnIdRef.current = null;
+                refs.stopRequestedRef.current = false;
+            }
             if (turnId === refs.activeTurnIdRef.current)
                 refs.activeTurnIdRef.current = null;
             refs.streamingRef.current = false;
+            refs.assistantIdRef.current = null;
             setStreaming(false);
             setTurnPhase("idle");
             setStreamingAssistantId(null);
@@ -236,10 +300,21 @@ export function createChatSseEventApplier(deps) {
                     return true;
                 return assistantOwnsTools;
             }));
+            if (!replay)
+                onTelemetryRefresh?.();
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {
             const operation = operationFromEventPayload(payload);
+            // R9: tombstones are session-scoped. The same operation may be linked
+            // to another session, but delayed frames cannot resurrect it here.
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operation &&
+                currentSessionId &&
+                refs.unlinkedOperationIdsRef.current
+                    .get(currentSessionId)
+                    ?.has(operation.operationId))
+                return;
             if (operation) {
                 const toolCallId = typeof payload.toolCallId === "string"
                     ? payload.toolCallId
@@ -256,6 +331,23 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "operation-unlinked") {
+            // R8 AC-001/AC-R8-001: durable tombstone — the server persisted an
+            // operation-unlinked event that OVERSHADOWS any earlier operation-ref.
+            // Drop the card from the projection; replay/recovery can never
+            // resurrect it because the tombstone is appended after the ref in
+            // the same ring.
+            const operationId = typeof payload.operationId === "string" ? payload.operationId : "";
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operationId && currentSessionId) {
+                const sessionTombstones = refs.unlinkedOperationIdsRef.current.get(currentSessionId) ??
+                    new Set();
+                sessionTombstones.add(operationId);
+                refs.unlinkedOperationIdsRef.current.set(currentSessionId, sessionTombstones);
+                setOperationCards((current) => current.filter((card) => card.operationId !== operationId));
+            }
+            return;
+        }
         if (eventName === "usage") {
             if (replay)
                 return;
@@ -451,6 +543,47 @@ export function createChatSseEventApplier(deps) {
             });
         }
         else if (eventName === "error") {
+            const candidate = payload.providerError && typeof payload.providerError === "object"
+                ? payload.providerError
+                : undefined;
+            if (candidate &&
+                typeof candidate.message === "string" &&
+                typeof candidate.raw === "string" &&
+                (candidate.category === "authentication" ||
+                    candidate.category === "context-overflow" ||
+                    candidate.category === "rate-limit" ||
+                    candidate.category === "provider")) {
+                // Session hydration already restores the durable card; retained replay
+                // must not add a second synthetic row on top of it.
+                if (replay)
+                    return;
+                const providerError = candidate;
+                const errorContent = parseAssistantContent(payload.content);
+                const id = turnId && eventSeq !== undefined
+                    ? `provider-error-${turnId}-${eventSeq}`
+                    : requestId("provider-error");
+                setMessages((messages) => {
+                    if (messages.some((message) => message.id === id))
+                        return messages;
+                    const activeAlreadyOwnsContent = messages.some((message) => message.id === resolvedAssistantId &&
+                        Boolean(message.content?.length));
+                    return [
+                        ...messages,
+                        {
+                            id,
+                            role: "assistant",
+                            kind: "provider-error",
+                            text: providerError.message,
+                            createdAt: eventAt,
+                            providerError,
+                            ...(!activeAlreadyOwnsContent && errorContent
+                                ? { content: errorContent }
+                                : {}),
+                        },
+                    ];
+                });
+                return;
+            }
             setError(typeof payload.message === "string" ? payload.message : "chat error");
         }
     };

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

@@ -0,0 +1,79 @@
+function finiteToken(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.max(0, Math.floor(value))
+        : undefined;
+}
+/** Project legacy final snapshots and lifecycle events to one stable row. */
+export function compactionMessageFromEvent(item) {
+    const data = item.data && typeof item.data === "object"
+        ? item.data
+        : {};
+    const eventId = typeof item.eventId === "string" ? item.eventId : undefined;
+    const compactionId = typeof data.compactionId === "string" && data.compactionId
+        ? data.compactionId
+        : eventId;
+    if (!compactionId)
+        return undefined;
+    const status = data.status === "running" ||
+        data.status === "completed" ||
+        data.status === "failed" ||
+        data.status === "aborted"
+        ? data.status
+        : "completed";
+    const reason = data.reason === "manual" ||
+        data.reason === "threshold" ||
+        data.reason === "overflow"
+        ? data.reason
+        : "manual";
+    const summary = typeof data.summary === "string" ? data.summary : "";
+    const errorMessage = typeof data.errorMessage === "string" ? data.errorMessage : undefined;
+    return {
+        id: `compaction-${compactionId}`,
+        role: "assistant",
+        kind: "compaction",
+        text: summary ||
+            errorMessage ||
+            (status === "completed"
+                ? "历史上下文已精简，关键决策与当前任务已保留。"
+                : ""),
+        createdAt: Date.parse(item.at ?? "") || Date.now(),
+        compaction: {
+            compactionId,
+            status,
+            reason,
+            willRetry: data.willRetry === true,
+            ...(finiteToken(data.tokensBefore) === undefined
+                ? {}
+                : { tokensBefore: finiteToken(data.tokensBefore) }),
+            ...(finiteToken(data.estimatedTokensAfter) === undefined
+                ? {}
+                : { estimatedTokensAfter: finiteToken(data.estimatedTokensAfter) }),
+            ...(typeof data.firstKeptEntryId === "string" && data.firstKeptEntryId
+                ? { firstKeptEntryId: data.firstKeptEntryId }
+                : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(eventId ? { eventId } : {}),
+        },
+    };
+}
+export function upsertCompactionMessage(messages, item) {
+    const next = compactionMessageFromEvent(item);
+    if (!next)
+        return messages;
+    const existing = messages.find((message) => message.id === next.id);
+    const result = existing
+        ? messages.map((message) => message.id === next.id
+            ? {
+                ...message,
+                ...next,
+                createdAt: Math.min(message.createdAt, next.createdAt),
+                text: next.text || message.text,
+                compaction: {
+                    ...message.compaction,
+                    ...next.compaction,
+                },
+            }
+            : message)
+        : [...messages, next];
+    return result.sort((a, b) => a.createdAt - b.createdAt);
+}