@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

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

@@ -7,7 +7,7 @@ import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
 /** 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, refs, setError } = params;
+    const { origin, sessionId, refs, setError, onUnrecoverableSession } = params;
     const [input, setInputState] = useState("");
     const [fileOptions, setFileOptions] = useState([]);
     const [pendingImages, setPendingImages] = useState([]);
@@ -28,6 +28,7 @@ export function useComposer(params) {
     }, []);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
+    const [commandCapabilities, setCommandCapabilities] = useState({ sddBingo: false });
     const [dynamicCommandsLoading, setDynamicCommandsLoading] = useState(false);
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
@@ -74,6 +75,7 @@ export function useComposer(params) {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
         setDynamicCommands([]);
+        setCommandCapabilities({ sddBingo: false });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
     }, [sessionId]);
@@ -122,6 +124,7 @@ export function useComposer(params) {
             if (!isCurrent())
                 return;
             setDynamicCommands(items);
+            setCommandCapabilities({ sddBingo: body?.capabilities?.sddBingo === true });
             // Compact server fail-soft / partial-source warning; local Operator/Web still merge.
             const warning = typeof body?.warning === "string" ? body.warning.trim() : "";
             setDynamicCommandsError(warning ? warning.slice(0, 160) : null);
@@ -131,6 +134,7 @@ export function useComposer(params) {
                 return;
             setDynamicCommandsError("动态命令加载失败");
             setDynamicCommands([]);
+            setCommandCapabilities({ sddBingo: false });
         }
         finally {
             if (isCurrent()) {
@@ -227,7 +231,7 @@ export function useComposer(params) {
         }, 400);
         return () => window.clearTimeout(timer);
     }, [origin, sessionId, input]);
-    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands), [dynamicCommands]);
+    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands, commandCapabilities), [dynamicCommands, commandCapabilities]);
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
         : [], [input, mergedCommands]);
@@ -258,8 +262,13 @@ export function useComposer(params) {
     // origin + sessionId + refs in a writable file; the snapshot store is
     // consumed by ChatComposer / panels / runtime-context popover).
     useEffect(() => {
-        attachRuntimeSnapshotController({ origin, sessionId, refs });
-    }, [origin, sessionId, refs]);
+        attachRuntimeSnapshotController({
+            origin,
+            sessionId,
+            refs,
+            onUnrecoverableSession,
+        });
+    }, [origin, sessionId, refs, onUnrecoverableSession]);
     return {
         input,
         setInput,

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

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { formatModelRef, mergeSessionRuntime, sessionRuntimeMatches, } from "../../chat/runtime-selection.js";
 import { confirmationToken } from "./format.js";
-import { mergeRuntimeContextWithSnapshot, runtimeSelectionFromSnapshot, } from "./runtime-snapshot-store.js";
+import { isLostChatSessionError, mergeRuntimeContextWithSnapshot, runtimeSelectionFromSnapshot, } from "./runtime-snapshot-store.js";
 import { buildToolCatalog } from "./tools-catalog.js";
 import { adoptMutationSnapshot, dispatchRuntimeSnapshot, getRuntimeSnapshotState, refreshRuntimeSnapshot, settleMutationLifecycle, useRuntimeSnapshot, } from "./useRuntimeSnapshot.js";
 /**
@@ -14,7 +14,7 @@ let mutationSeq = 0;
 /** Capabilities catalog, model / thinking-level switcher, runtime-context
  *  popover and the outside-click dismissal for both transient menus. */
 export function useRuntimeControls(params) {
-    const { origin, session, setSession, refs, setError } = params;
+    const { origin, session, setSession, refs, setError, onUnrecoverableSession } = params;
     const [capabilities, setCapabilities] = useState(null);
     const [models, setModels] = useState([]);
     const [modelsStatus, setModelsStatus] = useState("idle");
@@ -84,9 +84,20 @@ export function useRuntimeControls(params) {
             if (refs.sessionRef.current?.sessionId !== sessionId)
                 return;
             if (!res.ok || !body) {
+                const error = body
+                    ?.error;
+                if (isLostChatSessionError({
+                    status: res.status,
+                    code: error?.code,
+                    message: error?.message,
+                })) {
+                    setModelsStatus("idle");
+                    setModelsError(null);
+                    onUnrecoverableSession?.(sessionId);
+                    return;
+                }
                 setModelsStatus("error");
-                setModelsError(body
-                    ?.error?.message ?? `模型列表读取失败（HTTP ${res.status}）`);
+                setModelsError(error?.message ?? `模型列表读取失败（HTTP ${res.status}）`);
                 return;
             }
             setModels(body.models ?? []);
@@ -99,7 +110,7 @@ export function useRuntimeControls(params) {
             setModelsStatus("error");
             setModelsError(reason instanceof Error ? reason.message : String(reason));
         }
-    }, [origin, session, refs]);
+    }, [origin, session, refs, onUnrecoverableSession]);
     useEffect(() => {
         void loadModels();
     }, [loadModels]);
@@ -126,6 +137,18 @@ export function useRuntimeControls(params) {
             if (refs.sessionRef.current?.sessionId !== sessionId)
                 return;
             if (!body?.context) {
+                if (!r.ok &&
+                    isLostChatSessionError({
+                        status: r.status,
+                        code: body
+                            ?.error?.code,
+                        message: body
+                            ?.error?.message,
+                    })) {
+                    setRuntimeContextLoading(false);
+                    onUnrecoverableSession?.(sessionId);
+                    return;
+                }
                 if (!r.ok)
                     setRuntimeContextError("注入上下文读取失败，请重试");
                 return;
@@ -158,7 +181,7 @@ export function useRuntimeControls(params) {
                 return;
             setRuntimeContextError("注入上下文读取失败，请重试");
         });
-    }, [origin, session?.sessionId, refs]);
+    }, [origin, session?.sessionId, refs, onUnrecoverableSession]);
     // AC-01/RF3-01: hydrate the Composer from the unified snapshot — real
     // model and thinking selection; `auto` displays the Pi actual effective
     // level. Derived session/runtimeContext state ONLY comes from a snapshot

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

@@ -11,7 +11,7 @@
  */
 import { useSyncExternalStore } from "react";
 import { confirmationToken } from "./format.js";
-import { createRuntimeSnapshotStore, parseRuntimeSnapshotError, } from "./runtime-snapshot-store.js";
+import { createRuntimeSnapshotStore, isLostChatSessionError, parseRuntimeSnapshotError, } from "./runtime-snapshot-store.js";
 const store = createRuntimeSnapshotStore();
 let controller;
 function snapshotUrl(sessionId) {
@@ -49,10 +49,16 @@ async function fetchSnapshot(sessionId, origin) {
         if (controller?.sessionId !== sessionId)
             return; // stale session reply
         if (!res.ok) {
+            const error = { ...parseRuntimeSnapshotError(body), status: res.status };
+            if (isLostChatSessionError(error)) {
+                store.dispatch({ type: "reset" });
+                controller.onUnrecoverableSession?.(sessionId);
+                return;
+            }
             store.dispatch({
                 type: "load-failure",
                 sessionId,
-                error: { ...parseRuntimeSnapshotError(body), status: res.status },
+                error,
             });
             return;
         }

package/dist/worker/console/static-src/shell/console-update-reload.js

@@ -0,0 +1,52 @@
+export function isReplacementConsoleHealth(health, expectedConsoleInstanceId, previousConsoleInstanceId) {
+    if (!health || typeof health !== "object")
+        return false;
+    const instanceId = typeof health.consoleInstanceId ===
+        "string"
+        ? health.consoleInstanceId.trim()
+        : "";
+    if (!instanceId)
+        return false;
+    const expected = expectedConsoleInstanceId?.trim();
+    if (expected)
+        return instanceId === expected;
+    return previousConsoleInstanceId !== null && instanceId !== previousConsoleInstanceId;
+}
+/**
+ * Poll /api/health until the replacement Console answers, then reload. A
+ * handoff deliberately leaves the old process alive briefly, so HTTP 200 alone
+ * is insufficient: the response must carry the new instance identity.
+ */
+export async function reloadWhenConsoleReady(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const reload = options.reload ?? (() => window.location.reload());
+    const started = Date.now();
+    let previousConsoleInstanceId = null;
+    while (Date.now() - started < timeoutMs) {
+        try {
+            const res = await fetchImpl(`/api/health?ts=${Date.now()}`, {
+                cache: "no-store",
+            });
+            if (res.ok) {
+                const health = await res.json().catch(() => null);
+                if (isReplacementConsoleHealth(health, options.expectedConsoleInstanceId, previousConsoleInstanceId)) {
+                    reload();
+                    return true;
+                }
+                const healthRecord = health;
+                const instanceId = typeof healthRecord?.consoleInstanceId === "string"
+                    ? healthRecord.consoleInstanceId.trim()
+                    : "";
+                if (instanceId && previousConsoleInstanceId === null) {
+                    previousConsoleInstanceId = instanceId;
+                }
+            }
+        }
+        catch {
+            // old process gone, new one not listening yet — keep polling
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return false;
+}

package/dist/worker/console/static-src/shell/workspace-route.js

@@ -170,6 +170,17 @@ export function withWorkspaceId(href, workspaceId) {
     const qs = query.toString();
     return `/#${path}${qs ? `?${qs}` : ""}`;
 }
+/** Preserve the selected scope for a deep link emitted inside an Operate page.
+ * Components should prefer this to hand-writing `/#/inspect/...`: it reads the
+ * canonical hash at click/render time and intentionally leaves bare Chat URLs
+ * unchanged because Chat selection is client state. */
+export function withCurrentWorkspaceId(href, locationLike = typeof globalThis.location === "undefined" ? undefined : globalThis.location) {
+    const { query } = splitHash(locationLike?.hash ?? "");
+    const workspaceId = query.get("workspaceId")?.trim() ||
+        new URLSearchParams(locationLike?.search ?? "").get("workspaceId")?.trim() ||
+        undefined;
+    return withWorkspaceId(href, workspaceId);
+}
 export function buildCanonicalHref(input) {
     if (input.workspace === "chat")
         return buildChatHref(input);

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

@@ -19,9 +19,10 @@
  */
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import path from "node:path";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
-import { openConsoleAppData } from "./app-data.js";
+import { openConsoleAppData, sha256Json, writeSecureJson, } from "../../infrastructure/console/app-data.js";
 import { DagConfirmationStore } from "./dag-confirmation.js";
 import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
 import { DraftStore } from "./draft-store.js";
@@ -31,13 +32,20 @@ import { ChatSessionStore } from "./chat/session-store.js";
 import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
 import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
 import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { AimaxAuthReader, SddDataAlignmentService } from "./chat/sdd-data-alignment.js";
 import { UserQuestionRegistry } from "./chat/user-questions.js";
 import { TodoListRegistry } from "./chat/todos.js";
 import { GoalRegistry } from "./chat/goals.js";
 import { GoalRoundDriver } from "./chat/goal-round-driver.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
-import { OperationStore } from "./operation-store.js";
+import { OperationStore } from "../../infrastructure/console/operation-store.js";
+import { createFrontendSplitOperationAdapter, } from "./frontend-split-operation-adapter.js";
+import { createFrontendHumanDecisionAdapter } from "./frontend-human-decision-adapter.js";
+import { FrontendSplitTaskMaterializer, } from "../materialize/frontend-split-task-materializer.js";
+import { reconcileContextExports } from "../../infrastructure/console/context-export-store.js";
+import { reconcileArtifactRevisions } from "../../infrastructure/console/artifact-revision-store.js";
+import { recordContextTransferEvent } from "./context-transfer-diagnostics.js";
 import { probePiReadiness, } from "./pi-readiness.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
@@ -73,6 +81,106 @@ export async function createWorkspaceContext(record, deps) {
     const events = createOperationEventStore({
         persistenceDir: path.join(appData.operations, "events"),
     });
+    // Frontend split runtime is repo-scoped: materialization, durable schedule
+    // intents, and aggregate closeout must use this workspace's app-data and
+    // OperationStore rather than the process startup workspace.
+    const splitScheduleDir = path.join(appData.root, "frontend-split-schedule");
+    const splitAuditDir = path.join(appData.root, "frontend-split-audit");
+    const splitAggregateDir = path.join(appData.root, "frontend-split-aggregate");
+    const splitMaterializationBackend = {
+        async ensureTask({ taskId }) {
+            return { taskId, complete: true };
+        },
+        async ensureOperation({ taskId, operationId, payloadDigest, request }) {
+            const action = request.kind === "child"
+                ? "frontendSplitChild"
+                : "frontendSplitIntegration";
+            const { operation } = await operations.ensureSplitMaterializedOperation({
+                operationId,
+                taskId,
+                action,
+                actionParams: request,
+                payloadHash: payloadDigest,
+            });
+            return {
+                taskId: operation.taskId ?? taskId,
+                operationId: operation.operationId,
+                complete: true,
+            };
+        },
+    };
+    const materializer = new FrontendSplitTaskMaterializer(splitMaterializationBackend);
+    const schedule = async (input) => {
+        const fact = {
+            schemaVersion: 1,
+            kind: "frontend-split-schedule-intent",
+            operationId: input.operationId,
+            generation: input.generation,
+            bindingDigest: input.bindingDigest,
+            recordedAt: new Date().toISOString(),
+        };
+        const name = `${sha256Json({
+            operationId: input.operationId,
+            generation: input.generation,
+            bindingDigest: input.bindingDigest,
+        })}.json`;
+        await writeSecureJson(path.join(splitScheduleDir, name), fact);
+    };
+    const auditStale = async (input) => {
+        const fact = {
+            schemaVersion: 1,
+            kind: "frontend-split-stale-audit",
+            operationId: input.operationId,
+            reason: input.reason,
+            fact: input.fact,
+            recordedAt: new Date().toISOString(),
+        };
+        await writeSecureJson(path.join(splitAuditDir, `${sha256Json(fact)}.json`), fact);
+    };
+    const prepareAggregate = async ({ operationId, aggregate, }) => {
+        const before = await operations.get(operationId);
+        if (!before) {
+            throw new Error(`cannot prepare aggregate: parent operation not found: ${operationId}`);
+        }
+        const aggregateFile = path.join(splitAggregateDir, `${aggregate.digest}.json`);
+        let parentRecordPath = "";
+        let wroteAggregate = false;
+        let wroteParent = false;
+        return {
+            committedRef: {
+                ref: aggregateFile,
+                digest: aggregate.digest,
+                commitState: "committed",
+            },
+            async commit(input) {
+                parentRecordPath = input.parentRecordPath;
+                await writeSecureJson(aggregateFile, {
+                    schemaVersion: 1,
+                    kind: "frontend-split-aggregate-closeout",
+                    operationId,
+                    aggregate,
+                });
+                wroteAggregate = true;
+                await writeSecureJson(input.parentRecordPath, input.parentRecord);
+                wroteParent = true;
+            },
+            async rollback() {
+                if (wroteAggregate)
+                    await rm(aggregateFile, { force: true });
+                if (wroteParent && parentRecordPath) {
+                    await writeSecureJson(parentRecordPath, before);
+                }
+            },
+        };
+    };
+    const splitOrchestrator = createFrontendSplitOperationAdapter({
+        store: operations,
+        materializer,
+        schedule,
+        auditStale,
+        prepareAggregate,
+    });
+    const humanDecisionAdapter = createFrontendHumanDecisionAdapter(operations);
     const drafts = new DraftStore(appData);
     const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
     const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
@@ -80,6 +188,29 @@ export async function createWorkspaceContext(record, deps) {
     const assessments = new AssessmentStore(appData);
     if (!deps.skipReconcile) {
         await operations.reconcileOnBoot();
+        const [expiredExports, expiredRevisions] = await Promise.all([
+            reconcileContextExports({ appData }),
+            reconcileArtifactRevisions({ appData }),
+        ]);
+        // Boot-time lifecycle evidence for what reconcile reclaimed. Only
+        // 32-hex ids are real export/revision identities; uploads/ and lock/
+        // entries are blob housekeeping and get no event.
+        await Promise.all([
+            ...expiredExports.removed
+                .filter((exportId) => /^[a-f0-9]{32}$/.test(exportId))
+                .map((exportId) => recordContextTransferEvent({
+                appData,
+                event: "context_export.expired",
+                fields: { exportId },
+            }).catch(() => undefined)),
+            ...expiredRevisions
+                .filter((revisionId) => /^[a-f0-9]{32}$/.test(revisionId))
+                .map((revisionId) => recordContextTransferEvent({
+                appData,
+                event: "artifact_revision.expired",
+                fields: { revisionId },
+            }).catch(() => undefined)),
+        ]);
     }
     const getReadiness = () => readinessCache;
     const refreshReadiness = async () => {
@@ -97,6 +228,9 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,
@@ -120,6 +254,7 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     });
+    const sddDataAlignment = new SddDataAlignmentService(chatStore, new AimaxAuthReader(), deps.fetchImpl);
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -158,6 +293,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -169,6 +305,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
         goalRoundDriver,
         operationLinker: chatOperationLinker,
         appData,
@@ -192,6 +329,9 @@ export async function createWorkspaceContext(record, deps) {
         client,
         operations,
         events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
         drafts,
         confirmations,
         dagExecutionReceipts,

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

@@ -19,8 +19,8 @@ import { createHash, randomBytes } from "node:crypto";
 import { realpathSync, statSync, unwatchFile, watchFile } from "node:fs";
 import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
-import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
+import { readJsonIfExists, writeSecureJson, } from "../../infrastructure/console/app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "../../infrastructure/console/repo-fingerprint.js";
 export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 3;
 /** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
 export function workspaceIdForRealpath(normalizedRealpath) {