npm - @tea-agent/loop-agent - Versions diffs - 0.33.7-beta.0 → 0.34.1 - Mend

@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (101) hide show

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-CteJFFL2.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CnUXAqxG.css">
+    <script type="module" crossorigin src="/assets/index-BpuHmlSP.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BQkhJpV8.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/worker/console/static-src/app/console-types.js CHANGED Viewed

@@ -107,6 +107,7 @@ export async function postOperator(action, actionParams = {}, clientRequestId) {
 export const LONG_RUNNING_ACTIONS = new Set([
     "runDag",
     "dagRerun",
+    "dagReconcileRun",
     "standaloneTaskRerun",
 ]);
 export function formatDagRerunIneligible(plan) {

package/dist/worker/console/static-src/app/usePrdImport.js CHANGED Viewed

@@ -3,7 +3,8 @@ import { composePrdDocuments, importPrdFiles, validatePrdFileList, } from "../pr
 /** PRD multi-file import: drag/drop + selection, primary-volume selection,
  *  reorder/remove and composed-text regeneration with dirty tracking. */
 export function usePrdImport() {
-    const [prdText, setPrdText] = useState("# 需求\n\n实现 Loop Operator Console Happy Path：Interview → 契约落地 → DAG confirm → run。\n");
+    // Empty placeholder — do not prefill Console Happy Path sample text (design 2026-08-11).
+    const [prdText, setPrdText] = useState("");
     const [prdDocuments, setPrdDocuments] = useState([]);
     const [prdPrimaryIndex, setPrdPrimaryIndex] = useState(0);
     const [prdComposedDirty, setPrdComposedDirty] = useState(false);

package/dist/worker/console/static-src/app/useRecoveryActions.js CHANGED Viewed

@@ -234,7 +234,30 @@ export function useRecoveryActions(params) {
                 setOpError("对账恢复需要 DAG 运行 ID");
                 return;
             }
-            setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);
+            // Default supersede: orphan/interrupted runs should not be resumed.
+            // The browser Human Gate binds the destructive action + reason; the CLI
+            // still fail-closes when runner is not proven dead/stopped.
+            const actionParams = {
+                runId,
+                reason,
+                reconcileAction: "supersede",
+            };
+            const prep = await runAction("prepareMutationGate", {
+                action: "dagReconcileRun",
+                actionParams,
+            });
+            if (!isActionSuccess(prep))
+                return;
+            const receipt = (prep?.result ?? prep);
+            if (!receipt.receiptId || !receipt.humanGateToken) {
+                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+                return;
+            }
+            await runAction("dagReconcileRun", {
+                ...actionParams,
+                confirmationId: receipt.receiptId,
+                humanGateToken: receipt.humanGateToken,
+            }, { clientRequestId });
             return;
         }
         setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);

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

@@ -21,6 +21,7 @@ export function useRecoveryConsole(params) {
     const [recoveryRunsLoading, setRecoveryRunsLoading] = useState(false);
     const [recoveryNodesLoading, setRecoveryNodesLoading] = useState(false);
     const [recoveryRunStatus, setRecoveryRunStatus] = useState(null);
+    const [recoveryFailureCategory, setRecoveryFailureCategory] = useState(null);
     const [manualRunId, setManualRunId] = useState(false);
     const [manualNodeId, setManualNodeId] = useState(false);
     const [recoveryReport, setRecoveryReport] = useState(null);
@@ -122,6 +123,7 @@ export function useRecoveryConsole(params) {
         if (!id) {
             setRecoveryNodes([]);
             setRecoveryRunStatus(null);
+            setRecoveryFailureCategory(null);
             return;
         }
         setRecoveryNodesLoading(true);
@@ -132,10 +134,16 @@ export function useRecoveryConsole(params) {
             if (!res.ok) {
                 setRecoveryNodes([]);
                 setRecoveryRunStatus(null);
+                setRecoveryFailureCategory(null);
                 return;
             }
             const body = (await res.json());
-            setRecoveryRunStatus(typeof body.status === "string" ? body.status : null);
+            // Prefer adaptive effectiveStatus (running-suspected-stall / interrupted)
+            // over raw state.status so Recovery CTAs match doctor/liveness facts.
+            const status = (typeof body.effectiveStatus === "string" && body.effectiveStatus) ||
+                (typeof body.status === "string" && body.status) ||
+                null;
+            setRecoveryRunStatus(status);
             const rawNodes = Array.isArray(body.nodes) ? body.nodes : [];
             const nodes = sortRecoveryNodeCandidates(rawNodes
                 .map((n) => {
@@ -151,10 +159,19 @@ export function useRecoveryConsole(params) {
             })
                 .filter((n) => n !== null));
             setRecoveryNodes(nodes);
+            // Surface controller-interrupted (or other) from node records when run-level
+            // failureCategory is absent — needed for S6 interrupt CTA classification.
+            const runFailure = (typeof body.failureCategory === "string" && body.failureCategory) ||
+                undefined;
+            const nodeFailure = rawNodes.find((n) => typeof n.failureCategory === "string" &&
+                n.failureCategory &&
+                n.failureCategory !== "success")?.failureCategory;
+            setRecoveryFailureCategory(runFailure ?? nodeFailure ?? null);
         }
         catch {
             setRecoveryNodes([]);
             setRecoveryRunStatus(null);
+            setRecoveryFailureCategory(null);
         }
         finally {
             setRecoveryNodesLoading(false);
@@ -210,6 +227,7 @@ export function useRecoveryConsole(params) {
         operationState: recoveryRunStatus ? null : lastOpState,
         errorCode: recoveryRunStatus ? null : opErrorCode,
         dagStatus: recoveryRunStatus,
+        failureCategory: recoveryFailureCategory,
     });
     const recoveryCtas = useMemo(() => consoleRecoveryCtas(recoveryFact), [recoveryFact]);
     const recoveryLanes = useMemo(() => partitionRecoveryCtas(recoveryCtas), [recoveryCtas]);

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

@@ -10,6 +10,9 @@ export function useTaskWizard(params) {
     const [taskId, setTaskId] = useState("");
     const [taskTitle, setTaskTitle] = useState("");
     const [taskKind, setTaskKind] = useState("standard");
+    const [allowedPathsText, setAllowedPathsText] = useState("");
+    const [forbiddenPathsText, setForbiddenPathsText] = useState("");
+    const [verifyCommandsText, setVerifyCommandsText] = useState("");
     const workflowMeta = WORKFLOW_OPTIONS.find((w) => w.kind === taskKind) ?? WORKFLOW_OPTIONS[0];
     const [sessionId, setSessionId] = useState(null);
     const [question, setQuestion] = useState(null);
@@ -166,14 +169,26 @@ export function useTaskWizard(params) {
             return;
         void runContractPreflight(false);
     }, [step, taskId, assessmentId, runContractPreflight]);
+    const splitBoundaryList = useCallback((text) => {
+        return text
+            .split(/[\n,;，；]+/)
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }, []);
     const importPrdAndCreate = useCallback(async () => {
         const docsPayload = prd.prdDocuments.length > 0
             ? ensureUniqueDocumentNames(prd.prdDocuments)
             : undefined;
+        const allowedPaths = splitBoundaryList(allowedPathsText);
+        const forbiddenPaths = splitBoundaryList(forbiddenPathsText);
+        const verifyCommands = splitBoundaryList(verifyCommandsText);
         const actionParams = {
             content: prd.prdText,
             taskKind,
             ...(docsPayload ? { documents: docsPayload } : {}),
+            ...(allowedPaths.length > 0 ? { allowedPaths } : {}),
+            ...(forbiddenPaths.length > 0 ? { forbiddenPaths } : {}),
+            ...(verifyCommands.length > 0 ? { verifyCommands } : {}),
         };
         if (!operatorRequestFits("bootstrapFromPrd", actionParams)) {
             prd.setPrdFileError(operatorRequestTooLargeMessage());
@@ -187,9 +202,33 @@ export function useTaskWizard(params) {
             setTaskId(result.taskId);
         if (result.title)
             setTaskTitle(result.title);
-        setOpMessage(`已创建任务「${result.title ?? ""}」（${result.taskId ?? ""}），来源：${result.identitySource ?? "prd"}`);
+        const parseLabel = result.parseStatus ?? "pending";
+        const objectiveHint = result.draftPreview?.objective?.trim();
+        const gapCount = Array.isArray(result.gaps) ? result.gaps.length : 0;
+        const semanticNote = result.semanticIntake?.applied
+            ? "semantic"
+            : (result.semanticIntake?.code ?? "no-semantic");
+        setOpMessage([
+            `已创建任务「${result.title ?? ""}」（${result.taskId ?? ""}）`,
+            `来源：${result.identitySource ?? "prd"}`,
+            `解析：${parseLabel}（${semanticNote}）`,
+            objectiveHint ? `目标：${objectiveHint.slice(0, 120)}` : null,
+            gapCount > 0 ? `缺口 ${gapCount} 项待确认` : null,
+        ]
+            .filter(Boolean)
+            .join(" · "));
         setStep("interview");
-    }, [prd, runAction, setOpMessage, setStep, taskKind]);
+    }, [
+        allowedPathsText,
+        forbiddenPathsText,
+        prd,
+        runAction,
+        setOpMessage,
+        setStep,
+        splitBoundaryList,
+        taskKind,
+        verifyCommandsText,
+    ]);
     const wizardSteps = [
         { id: "setup", label: "就绪检查" },
         { id: "import-prd", label: "导入需求" },
@@ -205,6 +244,22 @@ export function useTaskWizard(params) {
         taskTitle,
         taskKind,
         setTaskKind,
+        engineering: {
+            allowedPathsText,
+            forbiddenPathsText,
+            verifyCommandsText,
+        },
+        setEngineering: (patch) => {
+            if (patch.allowedPathsText !== undefined) {
+                setAllowedPathsText(patch.allowedPathsText);
+            }
+            if (patch.forbiddenPathsText !== undefined) {
+                setForbiddenPathsText(patch.forbiddenPathsText);
+            }
+            if (patch.verifyCommandsText !== undefined) {
+                setVerifyCommandsText(patch.verifyCommandsText);
+            }
+        },
         workflowMeta,
         sessionId,
         question,

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

@@ -9,20 +9,47 @@ import { requestId } from "./format.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, setError, setProcessOpen, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setProcessOpen, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
     return (eventName, data, assistantId, options) => {
+        if (options?.generation !== undefined &&
+            refs.sessionGenerationRef.current !== options.generation)
+            return;
         const replay = options?.replay === true;
+        if (eventName === "stream_ready")
+            return;
         if (eventName === "reconcile") {
-            // Cursor aged out of the server ring: history may be incomplete.
-            // Surface a non-fatal notice rather than silently rendering a gap.
+            // Cursor aged out of the server ring (or the turn changed under us):
+            // retained history may be incomplete. Surface recovery via the callback
+            // (reload canonical facts -> new cursor -> reconnect) instead of a fatal
+            // global error; the snapshot replay frames that follow are still applied
+            // as ordinary blocks (deduped by eventId, replay text skipped).
             const reason = typeof data.reason === "string" ? data.reason : "cursor_expired";
-            setError(`会话事件窗口已过期（${reason}），建议刷新历史或新建会话。`);
+            onReconcile?.({
+                reason,
+                ...(typeof data.minSeq === "number" ? { minSeq: data.minSeq } : {}),
+                ...(typeof data.epoch === "string" ? { epoch: data.epoch } : {}),
+                ...(typeof data.latestTurnId === "string"
+                    ? { latestTurnId: data.latestTurnId }
+                    : {}),
+                ...(typeof data.latestEventId === "string"
+                    ? { latestEventId: data.latestEventId }
+                    : data.latestEventId === null
+                        ? { latestEventId: null }
+                        : {}),
+            });
             return;
         }
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
+        if (turnId &&
+            (eventName === "agent_start" || eventName === "message_update") &&
+            refs.settledTurnIdsRef.current.has(turnId)) {
+            // A delayed start/text frame from a completed turn must not create a
+            // ghost bubble or set streaming again (M5.4).
+            return;
+        }
         let resolvedAssistantId = assistantId;
         if (turnId) {
             const mapped = refs.turnAssistantIdsRef.current.get(turnId);
@@ -102,16 +129,26 @@ export function createChatSseEventApplier(deps) {
                 turnId !== refs.activeTurnIdRef.current) {
                 return;
             }
-            if (turnId)
+            if (turnId) {
+                refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
+            }
+            refs.streamingRef.current = true;
             setStreaming(true);
             setStreamingAssistantId(resolvedAssistantId);
             return;
         }
         if (eventName === "agent_settled" || eventName === "agent_end") {
-            // Both are terminal: agent_end = SDK run finished, agent_settled =
-            // post-turn continuation idle. Clear streaming and drop an empty
-            // placeholder bubble so a settled turn never shows a stuck "…" row.
+            if (turnId)
+                refs.settledTurnIdsRef.current.add(turnId);
+            // `agent_end` means the SDK run ended, but the Console keeps the only
+            // GET stream through an idle grace for agent_settled/state reconciliation
+            // (M4.4). It must not prematurely close the visible turn.
+            if (eventName === "agent_end")
+                return;
+            if (turnId === refs.activeTurnIdRef.current)
+                refs.activeTurnIdRef.current = null;
+            refs.streamingRef.current = false;
             setStreaming(false);
             setStreamingAssistantId(null);
             if (eventName === "agent_settled" &&

package/dist/worker/console/static-src/operator-chat/landing-density.js ADDED Viewed

@@ -0,0 +1,23 @@
+/** Landing density resolved from measured empty-container height. */
+/** Height thresholds in CSS px against `.oc-messages.is-empty`. */
+export const LANDING_DENSITY_THRESHOLDS = {
+    comfortableMin: 620,
+    compactMin: 480,
+};
+/**
+ * Resolve Landing visual density from empty-container block size.
+ * comfortable >=620, compact 480-619, extra-compact <480.
+ */
+export function resolveLandingDensity(heightPx) {
+    if (!Number.isFinite(heightPx) || heightPx < 0)
+        return "extra-compact";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.comfortableMin)
+        return "comfortable";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.compactMin)
+        return "compact";
+    return "extra-compact";
+}
+/** CSS class suffix for density attribute binding. */
+export function landingDensityClass(density) {
+    return `is-landing-${density}`;
+}

package/dist/worker/console/static-src/operator-chat/refs.js CHANGED Viewed

@@ -7,6 +7,9 @@ export function useChatRefs() {
     const inlineStreamSessionIdsRef = useRef(new Set());
     const assistantIdRef = useRef(null);
     const lastEventIdRef = useRef(null);
+    const sessionGenerationRef = useRef(0);
+    const eventsStreamStateRef = useRef(null);
+    const settledTurnIdsRef = useRef(new Set());
     const seenEventIdsRef = useRef(new Set());
     const turnAssistantIdsRef = useRef(new Map());
     const reconnectAbortRef = useRef(null);
@@ -24,6 +27,9 @@ export function useChatRefs() {
         inlineStreamSessionIdsRef,
         assistantIdRef,
         lastEventIdRef,
+        sessionGenerationRef,
+        eventsStreamStateRef,
+        settledTurnIdsRef,
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,
@@ -39,6 +45,9 @@ export function useChatRefs() {
         inlineStreamSessionIdsRef,
         assistantIdRef,
         lastEventIdRef,
+        sessionGenerationRef,
+        eventsStreamStateRef,
+        settledTurnIdsRef,
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,

package/dist/worker/console/static-src/operator-chat/runtime-snapshot-store.js ADDED Viewed

@@ -0,0 +1,257 @@
+/**
+ * Operator Chat — runtime snapshot store (design §2.2 / AC-04/05/06).
+ *
+ * A pure, framework-free state machine for the unified Live Runtime Snapshot.
+ * The browser treats the current Pi session as the single source of truth:
+ *
+ *   status: idle → loading → ready | error
+ *   reload: reloading (single-flight; no silent queueing) → success | failure
+ *
+ * `createRuntimeSnapshotStore` is intentionally side-effect free so it can be
+ * unit-tested in a plain Node environment; the React binding (fetch + attach)
+ * lives in `useRuntimeSnapshot.ts`.
+ */
+export const runtimeSnapshotInitialState = {
+    status: "idle",
+    snapshot: null,
+    error: null,
+    reloading: false,
+    reloadError: null,
+    mutationBusy: false,
+    mutationToken: null,
+};
+/** Parse a failed HTTP body into a structured snapshot error (never empty). */
+export function parseRuntimeSnapshotError(body) {
+    if (!body || typeof body !== "object") {
+        return { message: "runtime snapshot request failed" };
+    }
+    const record = body;
+    const err = record.error;
+    if (err && typeof err === "object") {
+        const e = err;
+        return {
+            ...(typeof e.code === "string" && e.code ? { code: e.code } : {}),
+            ...(typeof record.status === "number" ? { status: record.status } : {}),
+            message: typeof e.message === "string" && e.message
+                ? e.message
+                : "runtime snapshot request failed",
+        };
+    }
+    return {
+        ...(typeof record.status === "number" ? { status: record.status } : {}),
+        message: typeof record === "object" && "message" in record &&
+            typeof record.message === "string" &&
+            record.message
+            ? record.message
+            : "runtime snapshot request failed",
+    };
+}
+export function runtimeSnapshotReducer(state, action) {
+    switch (action.type) {
+        case "load-start":
+            // Stale replies are dropped by the fetch layer (sessionId guard); the
+            // reducer stays a deterministic state machine. The previous snapshot
+            // remains visible during a background refresh.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "loading",
+                error: null,
+            };
+        case "load-success":
+            // RF-04: monotonic revision guard — a stale (lower-revision) reply for
+            // the current session must never overwrite a newer snapshot, so a slow
+            // refresh cannot reorder-overwrite the current session selection. The
+            // fetch layer already drops replies for other sessions (sessionId guard).
+            if (state.snapshot &&
+                state.sessionId === action.sessionId &&
+                action.snapshot.revision < state.snapshot.revision) {
+                return state;
+            }
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "load-failure":
+            // AC-06: a failed load is a STRUCTURED error state — never folded
+            // into a fake empty snapshot.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "error",
+                error: action.error,
+                snapshot: null,
+            };
+        case "reload-start":
+            // Single-flight: a reload already in progress is NOT queued (AC-06).
+            if (state.reloading)
+                return state;
+            return {
+                ...state,
+                reloading: true,
+                reloadError: null,
+                ...(state.status === "error" ? { error: null } : {}),
+            };
+        case "reload-success":
+            // Atomic replacement: the new snapshot supersedes the old one and
+            // every open panel reads the same revision.
+            return {
+                ...state,
+                status: "ready",
+                snapshot: action.snapshot,
+                reloading: false,
+                reloadError: null,
+                error: null,
+                sessionId: action.snapshot.sessionId || state.sessionId,
+            };
+        case "reload-failure":
+            return {
+                ...state,
+                reloading: false,
+                reloadError: action.error,
+            };
+        case "mutation-start":
+            return {
+                ...state,
+                mutationBusy: true,
+                mutationToken: action.token,
+            };
+        case "mutation-adopt":
+            // RF2-02: atomic adoption of a mutation response snapshot. Three
+            // guards are evaluated BEFORE any write:
+            //   - mutationToken: only the LATEST mutation may adopt — a stale
+            //     out-of-order response is dropped entirely;
+            //   - sessionId: never adopt a mutation response into a state that
+            //     belongs to a different session;
+            //   - revision monotonic: equal/higher revisions adopt, lower reject
+            //     (a stale reply can never reorder-overwrite the selection).
+            // The action NEVER settles mutationBusy (mutation-settle owns that)
+            // and never passes through an intermediate stale/loading state.
+            if (state.mutationToken !== action.token)
+                return state;
+            if (state.sessionId !== undefined &&
+                state.sessionId !== action.sessionId)
+                return state;
+            if (state.snapshot &&
+                action.snapshot.revision < state.snapshot.revision)
+                return state;
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "mutation-settle":
+            // RF-04: only the LATEST request token settles the busy state; a
+            // stale (earlier) settle must not clear busy while a newer mutation
+            // is still in flight.
+            if (state.mutationToken !== action.token)
+                return state;
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "mutation-reset":
+            // RF3-02: a session switch immediately abandons the in-flight
+            // mutation lifecycle — the new session must not inherit the old
+            // session's busy state. The adopted snapshot/status stay untouched
+            // (a load-start for the new session follows); stale adopt/settle
+            // actions then become no-ops via the token + sessionId guards.
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "reset":
+            return { ...runtimeSnapshotInitialState };
+        default:
+            return state;
+    }
+}
+/**
+ * Derive the session/runtimeContext selection patch from an ADOPTED snapshot
+ * (RF3-01). The hydrate effect in `useRuntimeControls` feeds this patch into
+ * `mergeSessionRuntime` / `runtimeContext`, so derived state only ever comes
+ * from a snapshot the reducer guards accepted — the mutation success branch
+ * never writes session/runtimeContext directly. Missing fields are omitted;
+ * `auto` resolves to the Pi effective thinking level.
+ */
+export function runtimeSelectionFromSnapshot(snapshot) {
+    const selection = snapshot.selection;
+    return {
+        ...(selection.model
+            ? {
+                model: {
+                    provider: selection.model.provider,
+                    modelId: selection.model.id,
+                },
+            }
+            : {}),
+        ...(selection.thinkingSelection === "auto"
+            ? selection.effectiveThinkingLevel
+                ? { thinkingLevel: selection.effectiveThinkingLevel }
+                : {}
+            : { thinkingLevel: selection.thinkingSelection }),
+    };
+}
+/**
+ * RF4: merge an incoming `/runtime-context` response with the ADOPTED snapshot
+ * (coordination seam genuinely called by the production `useRuntimeControls`
+ * context hydration effect; tests import this same symbol — no copied logic).
+ *
+ * Content fields (systemPrompt/resources/suffix/readOnly) always come from the
+ * response. model/thinkingLevel NEVER come from the response body — the
+ * backend returns them without revision semantics, so a late reply for the
+ * same session could carry a stale selection. Selection is derived exclusively
+ * from the adopted snapshot when it matches the current session (same
+ * derivation as the snapshot hydration effect: `runtimeSelectionFromSnapshot`,
+ * `auto` resolves to the Pi effective level); otherwise the current derived
+ * values are preserved, or omitted when absent. The store is never written
+ * here, so the snapshot hydration effect never re-runs.
+ */
+export function mergeRuntimeContextWithSnapshot(current, context, snapshot, sessionId) {
+    const selection = snapshot && snapshot.sessionId === sessionId
+        ? runtimeSelectionFromSnapshot(snapshot)
+        : {};
+    const model = selection.model ?? current?.model;
+    const thinkingLevel = selection.thinkingLevel ?? current?.thinkingLevel;
+    return {
+        readOnly: context.readOnly,
+        systemPrompt: context.systemPrompt,
+        resources: context.resources,
+        suffix: context.suffix,
+        ...(model ? { model } : {}),
+        ...(thinkingLevel ? { thinkingLevel } : {}),
+    };
+}
+/** Create a fresh snapshot store (framework-free; React binding adds fetch). */
+export function createRuntimeSnapshotStore(initial = runtimeSnapshotInitialState) {
+    let state = initial;
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        dispatch: (action) => {
+            state = runtimeSnapshotReducer(state, action);
+            for (const listener of listeners)
+                listener();
+            return state;
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+/** True when the given error is the busy 409 (PI_SESSION_BUSY). */
+export function isSnapshotBusyError(error) {
+    return error?.code === "PI_SESSION_BUSY";
+}