@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

package/dist/worker/console/static-src/shell/useWorkspaces.js

@@ -4,7 +4,7 @@ import { describeMutationGateFailure, isMutationGateFailureCode, } from "../oper
 /**
  * Multi-workspace registry state (2026-08-23, AC-001/AC-003).
  *
- * Consumes the process-level GET/POST/DELETE /api/operator/v1/workspaces
+ * Consumes the process-level GET/POST/PATCH/DELETE /api/operator/v1/workspaces
  * surface. POST/DELETE pass the Console mutation-gate confirmation token.
  * The selected workspaceId is remembered in localStorage and validated
  * against the visible list. A stale local preference falls back to the first
@@ -64,6 +64,11 @@ export function createWorkspacesController(params = {}) {
     const storage = params.storage;
     const token = params.confirmationTokenFn ?? confirmationToken;
     const listeners = new Set();
+    let appliedRevision = 0;
+    let refreshQueued = false;
+    let refreshPromise = null;
+    let eventStream;
+    let disposed = false;
     let state = {
         workspaces: [],
         loading: true,
@@ -79,44 +84,90 @@ export function createWorkspacesController(params = {}) {
         state = { ...state, ...patch };
         emit();
     };
-    const refresh = async () => {
+    const refresh = () => {
+        refreshQueued = true;
+        if (refreshPromise)
+            return refreshPromise;
+        refreshPromise = (async () => {
+            while (refreshQueued && !disposed) {
+                refreshQueued = false;
+                try {
+                    const res = await fetchImpl(`${origin}/api/operator/v1/workspaces`, {
+                        credentials: "include",
+                    });
+                    if (!res.ok)
+                        continue;
+                    const body = (await res.json());
+                    const revision = Number.isSafeInteger(body.revision)
+                        ? Math.max(0, body.revision ?? 0)
+                        : undefined;
+                    // Legacy/injected responses without revision remain usable. A
+                    // revisioned response can never roll the projection backwards.
+                    if (revision !== undefined && revision < appliedRevision)
+                        continue;
+                    if (revision !== undefined)
+                        appliedRevision = revision;
+                    const list = body.workspaces ?? [];
+                    const pick = pickDefaultWorkspaceId(list, state.workspaceId);
+                    if (pick.status === "unknown-workspace") {
+                        setState({
+                            workspaces: list,
+                            unknownWorkspaceId: pick.workspaceId,
+                        });
+                        continue;
+                    }
+                    const nextId = pick.workspaceId;
+                    const previousId = state.workspaceId;
+                    setState({
+                        workspaces: list,
+                        unknownWorkspaceId: null,
+                        ...(nextId !== previousId ? { workspaceId: nextId } : {}),
+                    });
+                    if (nextId !== previousId)
+                        rememberWorkspaceId(nextId, storage);
+                }
+                catch {
+                    /* Registry unreachable: keep last known list. */
+                }
+                finally {
+                    if (state.loading)
+                        setState({ loading: false });
+                }
+            }
+        })().finally(() => {
+            refreshPromise = null;
+            // An event can arrive between the loop condition and finally.
+            if (refreshQueued && !disposed)
+                void refresh();
+        });
+        return refreshPromise;
+    };
+    const consumeRegistryEvent = (event) => {
         try {
-            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces`, {
-                credentials: "include",
-            });
-            if (!res.ok)
-                return;
-            const body = (await res.json());
-            const list = body.workspaces ?? [];
-            // A stale local preference falls back to the first server-visible
-            // Workspace. Explicit route ids are validated separately and remain
-            // fail-closed.
-            const pick = pickDefaultWorkspaceId(list, state.workspaceId);
-            if (pick.status === "unknown-workspace") {
-                setState({
-                    workspaces: list,
-                    unknownWorkspaceId: pick.workspaceId,
-                });
-                return;
+            const revision = Number(JSON.parse(event.data).revision);
+            if (Number.isSafeInteger(revision) && revision > appliedRevision) {
+                void refresh();
             }
-            const nextId = pick.workspaceId;
-            const previousId = state.workspaceId;
-            setState({
-                workspaces: list,
-                unknownWorkspaceId: null,
-                ...(nextId !== previousId ? { workspaceId: nextId } : {}),
-            });
-            if (nextId !== previousId)
-                rememberWorkspaceId(nextId, storage);
         }
         catch {
-            /* Registry unreachable: keep last known list. */
-        }
-        finally {
-            if (state.loading)
-                setState({ loading: false });
+            /* Malformed frames are ignored; reconnect baseline remains authoritative. */
         }
     };
+    const startEventStream = () => {
+        if (eventStream || disposed)
+            return;
+        const factory = params.eventSourceFactory ??
+            (typeof EventSource !== "undefined"
+                ? (url) => new EventSource(url, {
+                    withCredentials: true,
+                })
+                : undefined);
+        if (!factory)
+            return;
+        eventStream = factory(`${origin}/api/operator/v1/workspaces/events`);
+        eventStream.addEventListener("workspace_registry_ready", consumeRegistryEvent);
+        eventStream.addEventListener("workspace_registry_changed", consumeRegistryEvent);
+    };
     const addWorkspace = async (directoryPath, name) => {
         setState({ error: null });
         try {
@@ -214,12 +265,66 @@ export function createWorkspacesController(params = {}) {
             return { ok: false, error: display };
         }
     };
+    const reorderWorkspace = async (workspaceId, beforeWorkspaceId) => {
+        const previous = state.workspaces;
+        const source = previous.find((workspace) => workspace.workspaceId === workspaceId);
+        const anchor = beforeWorkspaceId
+            ? previous.find((workspace) => workspace.workspaceId === beforeWorkspaceId)
+            : undefined;
+        if (!source || (beforeWorkspaceId && !anchor)) {
+            return { ok: false, error: "工作区顺序已变化，请稍后重试。" };
+        }
+        const optimistic = previous.filter((workspace) => workspace.workspaceId !== workspaceId);
+        const insertAt = beforeWorkspaceId
+            ? optimistic.findIndex((workspace) => workspace.workspaceId === beforeWorkspaceId)
+            : optimistic.length;
+        optimistic.splice(insertAt, 0, source);
+        if (optimistic.every((workspace, index) => workspace.workspaceId === previous[index]?.workspaceId)) {
+            return { ok: true };
+        }
+        setState({ workspaces: optimistic, error: null });
+        try {
+            const res = await fetchImpl(`${origin}/api/operator/v1/workspaces/${encodeURIComponent(workspaceId)}`, {
+                method: "PATCH",
+                credentials: "include",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": token(),
+                },
+                body: JSON.stringify({ beforeWorkspaceId }),
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok) {
+                const message = isMutationGateFailureCode(body.error?.code)
+                    ? describeMutationGateFailure(body.error?.code ?? "")
+                    : (body.error?.message ?? `调整 Workspace 顺序失败（HTTP ${res.status}）`);
+                setState({ workspaces: previous, error: message });
+                void refresh();
+                return { ok: false, error: message };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            const message = `调整 Workspace 顺序失败：${error instanceof Error ? error.message : String(error)}`;
+            setState({ workspaces: previous, error: message });
+            void refresh();
+            return { ok: false, error: message };
+        }
+    };
     const selectWorkspace = (next) => {
         if (next === state.workspaceId && !state.unknownWorkspaceId)
             return;
         setState({ workspaceId: next, unknownWorkspaceId: null });
         rememberWorkspaceId(next, storage);
     };
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        eventStream?.close();
+        eventStream = undefined;
+        listeners.clear();
+    };
     void refresh();
     return {
         get workspaces() {
@@ -241,10 +346,19 @@ export function createWorkspacesController(params = {}) {
         pickWorkspaceDirectory,
         addWorkspace,
         removeWorkspace,
+        reorderWorkspace,
         selectWorkspace,
+        dispose,
         subscribe(listener) {
             listeners.add(listener);
-            return () => listeners.delete(listener);
+            startEventStream();
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    eventStream?.close();
+                    eventStream = undefined;
+                }
+            };
         },
     };
 }
@@ -294,6 +408,8 @@ export function useWorkspaces(params) {
         pickWorkspaceDirectory: controller.pickWorkspaceDirectory,
         addWorkspace: controller.addWorkspace,
         removeWorkspace: controller.removeWorkspace,
+        reorderWorkspace: controller.reorderWorkspace,
         selectWorkspace: controller.selectWorkspace,
+        dispose: controller.dispose,
     }), [state, controller]);
 }

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

@@ -12,6 +12,7 @@ export const OPERATE_TAB_IDS = [
     "night",
     "models",
     "settings",
+    "pi-plugins",
 ];
 export const LAST_OPERATE_TAB_STORAGE_KEY = "loop-console.operator-shell.last-operate-tab.v1";
 export const LAST_INSPECT_HASH_STORAGE_KEY = "loop-console.operator-shell.last-inspect-hash.v1";
@@ -44,7 +45,8 @@ function isOperateTab(value) {
         value === "recovery" ||
         value === "night" ||
         value === "models" ||
-        value === "settings");
+        value === "settings" ||
+        value === "pi-plugins");
 }
 function readParam(query, key) {
     const value = query.get(key)?.trim();

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

@@ -21,7 +21,7 @@ import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
-import { openConsoleAppData } from "./app-data.js";
+import { openConsoleAppData, } 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";
@@ -33,8 +33,14 @@ import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.
 import { ConsolePiRuntime } from "./chat/pi-runtime.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 { 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";
@@ -77,6 +83,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 () => {
@@ -107,7 +136,16 @@ export async function createWorkspaceContext(record, deps) {
         fetchImpl: deps.fetchImpl,
         getConsoleOrigin: deps.getConsoleOrigin,
     };
-    const chatStore = new ChatSessionStore(appData);
+    const chatStore = new ChatSessionStore(appData, {
+        onRecordChange: (sessionId, session) => {
+            if (session) {
+                deps.chatSessionCatalog?.upsert(session, record.workspaceId);
+            }
+            else {
+                deps.chatSessionCatalog?.remove(sessionId);
+            }
+        },
+    });
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -116,6 +154,7 @@ export async function createWorkspaceContext(record, deps) {
     const chatTurnExecutions = createChatTurnExecutionRegistry();
     const questionRegistry = new UserQuestionRegistry(path.join(appData.chats, "user-questions"));
     const todoRegistry = new TodoListRegistry();
+    const goalRegistry = new GoalRegistry(chatEvents);
     questionRegistry.subscribe((change) => {
         const question = change.question;
         chatEvents.append(question.sessionId, question.turnId ?? `${question.sessionId}:question`, {
@@ -144,21 +183,27 @@ export async function createWorkspaceContext(record, deps) {
         actionContext,
         questionRegistry,
         todoRegistry,
+        goalRegistry,
     });
-    const chatRouteDeps = {
+    let chatRouteDeps;
+    const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
+    chatRouteDeps = {
         runtime: chatRuntime,
         store: chatStore,
         events: chatEvents,
         turnExecutions: chatTurnExecutions,
         questionRegistry,
         todoRegistry,
+        goalRegistry,
+        goalRoundDriver,
         operationLinker: chatOperationLinker,
         appData,
         bootToken: deps.bootToken,
         getConsoleOrigin: deps.getConsoleOrigin,
         allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+        attachSession: (sessionId) => registry.attachSession(record.workspaceId, sessionId),
+        detachSession: (sessionId) => registry.detachSession(record.workspaceId, sessionId),
     };
-    const { recoverDeferredTurns } = await import("./chat/routes.js");
     const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
     const observeRouteContext = createObserveRouteContext(repoRoot, {
         staticDir: deps.inspectStaticDir,
@@ -191,6 +236,12 @@ export async function createWorkspaceContext(record, deps) {
             if (disposed)
                 return;
             disposed = true;
+            try {
+                goalRoundDriver.dispose();
+            }
+            catch {
+                // best-effort
+            }
             try {
                 chatOperationLinker.dispose();
             }