@tea-agent/loop-agent 0.40.0-next.4 → 0.40.0-next.5

package/dist/worker/console/server.js

@@ -4,31 +4,18 @@ import { existsSync } from "node:fs";
 import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
 import { readPackageVersion } from "../../shared/package-metadata.js";
 import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 import { openConsoleAppData } from "./app-data.js";
-import { DagConfirmationStore } from "./dag-confirmation.js";
-import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
-import { DraftStore } from "./draft-store.js";
-import { AssessmentStore } from "./interview/assessment.js";
-import { InterviewSessionStore } from "./interview/session.js";
 import { isLoopbackHost } from "./loopback.js";
-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 { handleChatRequest, recoverDeferredTurns, } from "./chat/routes.js";
-import { createOperationEventStore, } from "./operation-sse.js";
-import { OperationStore } from "./operation-store.js";
-import { probePiReadiness, } from "./pi-readiness.js";
-import { handleConsoleHealthRequest, handleConsoleOperatorRequest, sendJson, serveConsoleStatic, } from "./routes.js";
+import { handleConsoleHealthRequest, handleWorkspaceRoutes, sendJson, serveConsoleStatic, } from "./routes.js";
 import { issueBootCapabilityToken, injectConfirmationTokenScript, } from "./security.js";
-import { resolvePackageRootFromConsole, resolveSiblingLoopAgentBin, } from "./sibling-controller.js";
+import { resolvePackageRootFromConsole } from "./sibling-controller.js";
 import { isDagRerunPromptOverrideEnabled } from "../../shared/dag-prompt-override.js";
-import { NightAuxTicker } from "./night-aux-ticker.js";
+import { defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
 import { deriveObserveRouteCapabilities } from "../observe/health.js";
-import { createObserveRouteContext, defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
+import { WorkspaceRegistry, } from "./workspace-registry.js";
+import { createWorkspaceContext, } from "./workspace-context.js";
 import { createConsoleUpdateExecutor } from "./console-update-runtime.js";
 import { createConsoleHandoff } from "./console-handoff.js";
 /**
@@ -76,18 +63,20 @@ export async function createConsoleServer(options) {
     const keepAliveTimeoutMs = options.keepAliveTimeoutMs ?? 65_000;
     const staticDir = options.staticDir ?? defaultConsoleStaticDir();
     const inspectStaticDir = options.inspectStaticDir ?? defaultObserveStaticDir();
-    const observeRouteContext = createObserveRouteContext(repoRoot, {
-        staticDir: inspectStaticDir,
-    });
     const operatorSessionId = `sess_${randomBytes(16).toString("hex")}`;
     const consoleInstanceId = options.consoleInstanceId ?? `console_${randomBytes(16).toString("hex")}`;
-    const appData = openConsoleAppData({
+    // User-level registry root shares the user app-data root directory layout
+    // (workspaces.json lives at <root>/workspaces.json, per-workspace records
+    // carry fingerprint-isolated namespaces under <root>/repos/<fingerprint>/).
+    const bootstrapAppData = openConsoleAppData({
         repoRoot,
         appDataRoot: options.appDataRoot,
     });
+    const registry = new WorkspaceRegistry(bootstrapAppData);
+    const startupRecord = await registry.ensureStartupWorkspace(repoRoot);
     const instanceNonce = configuredPort === 0 ? randomBytes(16).toString("hex") : undefined;
     const bootToken = issueBootCapabilityToken({
-        repoFingerprint: appData.fingerprint,
+        repoFingerprint: startupRecord.repoFingerprint,
         bindHost: host,
         configuredPort,
         ...(instanceNonce ? { instanceNonce } : {}),
@@ -96,86 +85,67 @@ export async function createConsoleServer(options) {
     // separate cookie name + confirmation token so the read-only inspect page
     // can never replay them against the general Console mutation surface.
     const inspectBootToken = issueBootCapabilityToken({
-        repoFingerprint: appData.fingerprint,
+        repoFingerprint: startupRecord.repoFingerprint,
         bindHost: host,
         configuredPort,
         ...(instanceNonce ? { instanceNonce } : {}),
     }, { variant: "inspect" });
-    const operations = new OperationStore(appData);
-    const events = createOperationEventStore({
-        persistenceDir: path.join(appData.operations, "events"),
-    });
-    const drafts = new DraftStore(appData);
-    const confirmations = new DagConfirmationStore(appData, bootToken.confirmationToken);
-    const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
-    const interviews = new InterviewSessionStore(appData);
-    const assessments = new AssessmentStore(appData);
-    const readiness = await probePiReadiness({
-        override: options.piReadinessProbe,
-        repoRoot,
-    });
-    let readinessCache = readiness;
-    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
-    const client = options.createClient?.(artifactRoot) ??
-        new LoopAgentClient({
-            loopAgentBin: resolveSiblingLoopAgentBin(),
-            artifactRoot,
-            resolveIdentity: true,
-            // See DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS: dag execute / task advance
-            // must not inherit the 120s worker-command default.
-            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(options.defaultTimeoutMs),
-        });
-    if (!options.skipReconcile) {
-        await operations.reconcileOnBoot();
-    }
-    const getReadiness = () => readinessCache;
-    const refreshReadiness = async () => {
-        readinessCache = await probePiReadiness({
-            override: options.piReadinessProbe,
-            repoRoot,
-        });
-        actionContext.readiness = readinessCache;
-        return readinessCache;
-    };
-    const actionContext = {
-        repoRoot,
-        appData,
-        operatorSessionId,
-        client,
-        operations,
-        events,
-        drafts,
-        confirmations,
-        dagExecutionReceipts,
-        humanGateSecret: bootToken.confirmationToken,
-        interviews,
-        assessments,
-        readiness: readinessCache,
-        getReadiness,
-        refreshReadiness,
-        observeBaseUrl: options.observeBaseUrl,
-        fetchImpl: options.fetchImpl,
-        consoleUpdateExecutor: options.consoleUpdateExecutor,
-        getConsoleOrigin: () => `http://${boundHost}:${boundPort}`,
-    };
     let boundHost = host;
     let boundPort = configuredPort;
     const getConsoleOrigin = () => `http://${boundHost}:${boundPort}`;
-    // Phase 4: General Operator Chat runtime. The actionContext is forwarded so
-    // custom-tool execute() calls dispatch into the operator action layer (Gate 3).
-    // Chat session dir is dedicated (app-data/chat-sessions), NOT user default.
-    const chatStore = new ChatSessionStore(appData);
-    // M5.1: every Console boot owns a fresh event-log generation. A browser
-    // reconnecting with an old SSE cursor must reconcile from snapshot rather
-    // than silently consume a different process' event namespace.
-    const chatEventEpoch = randomBytes(12).toString("hex");
-    const chatEvents = createChatEventStore({ appData, epoch: chatEventEpoch });
-    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    // ---- Per-workspace lazily-created contexts -------------------------------
+    const workspaceContexts = new Map();
+    let sharedConsoleUpdateExecutor = options.consoleUpdateExecutor;
+    const resolveContext = async (workspaceId) => {
+        const id = workspaceId?.trim();
+        if (!id) {
+            return {
+                ok: false,
+                status: 400,
+                code: "WORKSPACE_REQUIRED",
+                message: "workspaceId is required",
+            };
+        }
+        const existing = workspaceContexts.get(id);
+        if (existing)
+            return { ok: true, context: existing };
+        const record = await registry.getVisible(id);
+        if (!record) {
+            return {
+                ok: false,
+                status: 404,
+                code: "WORKSPACE_NOT_FOUND",
+                message: `unknown workspace: ${id}`,
+            };
+        }
+        const context = await createWorkspaceContext(record, {
+            appDataRoot: options.appDataRoot,
+            staticDir,
+            inspectStaticDir,
+            bootToken,
+            operatorSessionId,
+            getConsoleOrigin,
+            allowNonLoopbackAccess: !loopbackBind,
+            observeBaseUrl: options.observeBaseUrl,
+            fetchImpl: options.fetchImpl,
+            piReadinessProbe: options.piReadinessProbe,
+            createClient: options.createClient,
+            defaultTimeoutMs: options.defaultTimeoutMs,
+            skipReconcile: options.skipReconcile,
+        });
+        if (sharedConsoleUpdateExecutor) {
+            context.actionContext.consoleUpdateExecutor = sharedConsoleUpdateExecutor;
+        }
+        workspaceContexts.set(id, context);
+        void context.recoverDeferredTurns().catch(() => undefined);
+        return { ok: true, context };
+    };
+    const startupResolution = await resolveContext(startupRecord.workspaceId);
+    if (!startupResolution.ok) {
+        throw new Error(`console serve: failed to create startup workspace context: ${startupResolution.message}`);
+    }
+    const startup = startupResolution.context;
     const requestConsoleHandoff = async (targetVersion) => {
-        // The maintenance preflight proves this running Console was loaded from
-        // the global package. npm replaces that package in place, so resolve the
-        // replacement worker from that same package root rather than trusting the
-        // ambient PATH (which could point at another installation).
         const packageRoot = resolvePackageRootFromConsole();
         const agentWorkerBin = path.join(packageRoot, "bin", "agent-worker.js");
         if (readPackageVersion(packageRoot) !== targetVersion ||
@@ -223,72 +193,26 @@ export async function createConsoleServer(options) {
             };
         }
     };
-    actionContext.consoleUpdateExecutor =
-        options.consoleUpdateExecutor ??
-            createConsoleUpdateExecutor({
-                repoRoot,
-                packageRoot: resolvePackageRootFromConsole(),
-                client,
-                operations,
-                activeChatTurnCount: () => chatTurnExecutions.size(),
-                requestHandoff: requestConsoleHandoff,
-            });
-    const chatOperationLinker = createChatOperationLinker({
-        chatEvents,
-        operations,
-        operationEvents: events,
-    });
-    const chatRuntime = new ConsolePiRuntime({
-        cwd: repoRoot,
-        sessionDir: appData.chatSessions,
-        resourcePreferencesPath: appData.resourcePreferences,
-        actionContext,
-    });
-    // chatRouteDeps is a plain object literal — it cannot throw. The previous
-    // try/catch was dead code that created a false "handled failure" impression.
-    // If a future field can throw, scope it explicitly instead of wrapping the
-    // literal.
-    const chatRouteDeps = {
-        runtime: chatRuntime,
-        store: chatStore,
-        events: chatEvents,
-        turnExecutions: chatTurnExecutions,
-        operationLinker: chatOperationLinker,
-        appData,
-        bootToken,
-        getConsoleOrigin,
-        allowNonLoopbackAccess: !loopbackBind,
-    };
-    // Durable single-slot follow-ups are server-owned. Recover them at boot even
-    // when no browser currently has the Session open.
-    void recoverDeferredTurns(chatRouteDeps).catch((error) => {
-        console.error(`[console] deferred Turn recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-    });
-    const nightAuxTicker = new NightAuxTicker({
+    sharedConsoleUpdateExecutor ??= createConsoleUpdateExecutor({
         repoRoot,
-        client,
+        packageRoot: resolvePackageRootFromConsole(),
+        client: startup.client,
+        operations: startup.operations,
+        activeChatTurnCount: () => [...workspaceContexts.values()].reduce((total, context) => total + (context.chatRouteDeps.turnExecutions?.size() ?? 0), 0),
+        requestHandoff: requestConsoleHandoff,
     });
-    const routeContext = {
-        repoRoot,
-        staticDir,
-        bootToken,
-        inspectBootToken,
-        getConsoleOrigin,
-        allowNonLoopbackAccess: !loopbackBind,
-        inspect: {
-            ready: existsSync(path.join(inspectStaticDir, "index.html")),
-            routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
-        },
-        consoleInstanceId,
-        operator: {
-            actionContext,
-            operations,
-            events,
-            getReadiness,
-            chat: chatRouteDeps,
-            nightAuxTicker,
-        },
-    };
+    for (const context of workspaceContexts.values()) {
+        context.actionContext.consoleUpdateExecutor = sharedConsoleUpdateExecutor;
+    }
+    // Legacy surface readiness: the boot readiness report of the startup
+    // workspace. Kept as a process-level report for /api/health projections.
+    const bootReadiness = startup.getReadiness();
+    // Durable follow-up recovery is per-context and runs at context creation
+    // (see resolveContext); the startup context is created eagerly below, so its
+    // recovery has already been scheduled.
+    // Readiness is shared per-context; the legacy getReadiness() helper keeps
+    // pointing at the startup context report.
+    const getReadiness = () => bootReadiness;
     return new Promise((resolve, reject) => {
         const server = createServer((req, res) => {
             const startedAt = Date.now();
@@ -336,29 +260,75 @@ export async function createConsoleServer(options) {
             }
         });
         async function dispatch(req, res) {
-            // Refresh readiness pointer on each request surface
-            actionContext.readiness = getReadiness();
             const method = (req.method ?? "GET").toUpperCase();
-            const pathname = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+            const url = new URL(req.url ?? "/", "http://localhost");
+            const pathname = decodeURIComponent(url.pathname);
             if (method === "GET" && pathname === "/api/health") {
-                await handleConsoleHealthRequest(req, res, routeContext);
+                await handleConsoleHealthRequest(req, res, {
+                    repoRoot,
+                    staticDir,
+                    bootToken,
+                    getConsoleOrigin,
+                    allowNonLoopbackAccess: !loopbackBind,
+                    inspect: {
+                        ready: existsSync(path.join(inspectStaticDir, "index.html")),
+                        routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
+                    },
+                    consoleInstanceId,
+                    registry,
+                    getStartupReadiness: getReadiness,
+                });
                 return;
             }
             if (pathname.startsWith("/api/operator/v1/") ||
                 pathname.startsWith("/api/session/")) {
-                // Phase 4: General Operator Chat routes (mounted under chat/).
+                // Workspace Registry routes are process-level (no workspaceId).
+                if (pathname === "/api/operator/v1/workspaces" ||
+                    pathname.startsWith("/api/operator/v1/workspaces/")) {
+                    await handleWorkspaceRoutes(req, res, registry, {
+                        bootToken,
+                        getConsoleOrigin,
+                        allowNonLoopbackAccess: !loopbackBind,
+                        ...(options.piReadinessProbe
+                            ? { piReadinessProbe: options.piReadinessProbe }
+                            : {}),
+                        ...(options.pickDirectory
+                            ? { pickDirectory: options.pickDirectory }
+                            : {}),
+                    }, url, pathname, method, {
+                        inspectReady: existsSync(path.join(inspectStaticDir, "index.html")),
+                    });
+                    return;
+                }
                 if (pathname.startsWith("/api/operator/v1/chat/") ||
                     pathname.startsWith("/api/operator/v1/pi/")) {
-                    await handleChatRequest(req, res, chatRouteDeps, pathname);
+                    await handleChatDispatch(req, res, pathname, url, method);
                     return;
                 }
-                await handleConsoleOperatorRequest(req, res, routeContext);
+                await handleOperatorDispatch(req, res, pathname, url, method);
                 return;
             }
             if (method === "GET" && pathname.startsWith("/api/")) {
                 const match = matchObserveGetRoute(pathname);
                 if (match) {
-                    await handleMatchedObserveRoute(req, res, match, observeRouteContext);
+                    const requestedWorkspaceId = url.searchParams.get("workspaceId")?.trim() || undefined;
+                    // Every Observe GET is workspace data. Missing, blank, and unknown
+                    // workspace ids fail closed; only /api/health remains process-level.
+                    const resolution = await resolveContext(requestedWorkspaceId);
+                    if (!resolution.ok) {
+                        sendJson(res, resolution.status, {
+                            ok: false,
+                            error: {
+                                code: resolution.code,
+                                message: resolution.message,
+                            },
+                        });
+                        return;
+                    }
+                    // Refresh readiness pointer per request surface.
+                    resolution.context.actionContext.readiness =
+                        resolution.context.getReadiness();
+                    await handleMatchedObserveRoute(req, res, match, resolution.context.observeRouteContext);
                     return;
                 }
             }
@@ -369,10 +339,8 @@ export async function createConsoleServer(options) {
                 // INSPECT_MUTATION_ALLOWED_ACTIONS — see routes.ts).
                 const htmlEnhancer = isDagRerunPromptOverrideEnabled()
                     ? (html) => ({
-                        content: injectConfirmationTokenScript(html, routeContext.inspectBootToken?.confirmationToken ??
-                            routeContext.bootToken.confirmationToken, "__INSPECT_MUTATION_TOKEN__"),
-                        setCookie: routeContext.inspectBootToken?.setCookieHeader ??
-                            routeContext.bootToken.setCookieHeader,
+                        content: injectConfirmationTokenScript(html, inspectBootToken.confirmationToken, "__INSPECT_MUTATION_TOKEN__"),
+                        setCookie: inspectBootToken.setCookieHeader,
                     })
                     : undefined;
                 await serveObserveStatic(req, res, inspectStaticDir, {
@@ -385,7 +353,280 @@ export async function createConsoleServer(options) {
                 sendJson(res, 404, { error: "Not found" });
                 return;
             }
-            await serveConsoleStatic(req, res, routeContext);
+            if (options.serveStatic) {
+                await options.serveStatic(req, res, {
+                    confirmationToken: bootToken.confirmationToken,
+                    setCookieHeader: bootToken.setCookieHeader,
+                    consoleOrigin: getConsoleOrigin(),
+                });
+                return;
+            }
+            await serveConsoleStatic(req, res, {
+                repoRoot,
+                staticDir,
+                bootToken,
+                inspectBootToken,
+                getConsoleOrigin,
+                allowNonLoopbackAccess: !loopbackBind,
+                inspect: {
+                    ready: existsSync(path.join(inspectStaticDir, "index.html")),
+                    routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
+                },
+                consoleInstanceId,
+            });
+        }
+        async function handleChatDispatch(req, res, pathname, url, method, 
+        /** Explicit owning workspaceId for POST /chat/sessions create
+         * (AC-R7-002); undefined for every other chat route. */
+        workspaceScope) {
+            // POST /api/operator/v1/chat/sessions — creation carries workspaceId in
+            // the JSON body; all other chat routes resolve via Session ownership
+            // (durable) with optional query workspaceId conflict check.
+            const { handleChatRequest: dispatchChat } = await import("./chat/routes.js");
+            if (method === "POST" && pathname === "/api/operator/v1/chat/sessions") {
+                // AC-R5-006: the mutation gate fires BEFORE body pre-read/workspace
+                // resolution — an unauthenticated mutation gets exactly 403, never a
+                // masked 400 (WORKSPACE_REQUIRED/INVALID_INPUT) that would hide the
+                // gate-order regression.
+                {
+                    const { evaluateMutationGate } = await import("./security.js");
+                    const failure = evaluateMutationGate(req, {
+                        cookieName: bootToken.cookieName,
+                        bootToken: bootToken.value,
+                        confirmationToken: bootToken.confirmationToken,
+                        consoleOrigin: getConsoleOrigin(),
+                        allowNonLoopbackAccess: !loopbackBind,
+                    });
+                    if (failure) {
+                        sendJson(res, failure.status, {
+                            ok: false,
+                            error: {
+                                code: failure.code,
+                                message: failure.message,
+                            },
+                        });
+                        return;
+                    }
+                }
+                const resolution = await resolveContextFromSessionCreateBody(req, res, resolveContext);
+                if (!resolution)
+                    return; // response already sent
+                // AC-R7-002: workspaceId travels as an EXPLICIT parameter through
+                // dispatchChat → handleCreateChatSession → store.create. No runtime
+                // store.create replacement exists anymore.
+                await dispatchChat(req, res, resolution.context.chatRouteDeps, pathname, resolution.context.workspaceId);
+                return;
+            }
+            const sessionMatch = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)(?:\/|$)/);
+            if (sessionMatch) {
+                const sessionId = decodeURIComponent(sessionMatch[1]);
+                // r4 AC-R2-001: the mutation gate fires BEFORE session ownership
+                // resolution — an unauthenticated mutation on ANY session id
+                // (existing or not) gets exactly 403, never a masked 404 that
+                // would hide a gate-order regression.
+                if (method !== "GET" && method !== "HEAD") {
+                    const { evaluateMutationGate } = await import("./security.js");
+                    const failure = evaluateMutationGate(req, {
+                        cookieName: bootToken.cookieName,
+                        bootToken: bootToken.value,
+                        confirmationToken: bootToken.confirmationToken,
+                        consoleOrigin: getConsoleOrigin(),
+                        allowNonLoopbackAccess: !loopbackBind,
+                    });
+                    if (failure) {
+                        sendJson(res, failure.status, {
+                            ok: false,
+                            error: {
+                                code: failure.code,
+                                message: failure.message,
+                            },
+                        });
+                        return;
+                    }
+                }
+                const requestedId = url.searchParams.get("workspaceId")?.trim();
+                let owner;
+                if (requestedId) {
+                    // The current UI always sends its selected workspace. Resolve that one
+                    // context directly: scanning every historical registry entry first can
+                    // fail on an old, deleted temp directory before reaching the real owner.
+                    const resolution = await resolveContext(requestedId);
+                    if (!resolution.ok) {
+                        // A session-scoped workspace hint is a conflict boundary. Unknown
+                        // workspace ids must not reveal whether the session exists elsewhere.
+                        const workspaceConflict = resolution.code === "WORKSPACE_NOT_FOUND";
+                        sendJson(res, workspaceConflict ? 403 : resolution.status, {
+                            ok: false,
+                            error: workspaceConflict
+                                ? {
+                                    code: "WORKSPACE_CONFLICT",
+                                    message: "workspaceId does not match the session's owning workspace",
+                                }
+                                : { code: resolution.code, message: resolution.message },
+                        });
+                        return;
+                    }
+                    const stored = await resolution.context.chatRouteDeps.store.get(sessionId);
+                    if (stored)
+                        owner = resolution.context;
+                    else {
+                        // Do not scan another workspace and disclose whether the id exists there.
+                        sendJson(res, 403, {
+                            ok: false,
+                            error: {
+                                code: "WORKSPACE_CONFLICT",
+                                message: "workspaceId does not match the session's owning workspace",
+                            },
+                        });
+                        return;
+                    }
+                }
+                else {
+                    // Legacy callers may omit workspaceId. Session ids live in per-workspace
+                    // namespaces, so scan visible workspaces but tolerate stale registry
+                    // records whose directories were removed outside the Console.
+                    const visible = await registry.listVisible();
+                    for (const record of visible) {
+                        try {
+                            const resolution = await resolveContext(record.workspaceId);
+                            if (!resolution.ok)
+                                continue;
+                            const stored = await resolution.context.chatRouteDeps.store.get(sessionId);
+                            if (stored) {
+                                owner = resolution.context;
+                                break;
+                            }
+                        }
+                        catch {
+                            // An unavailable historical Workspace is not evidence that the
+                            // requested session is missing from every other visible Workspace.
+                        }
+                    }
+                }
+                if (!owner) {
+                    sendJson(res, 404, {
+                        ok: false,
+                        error: {
+                            code: "NOT_FOUND",
+                            message: `chat session not found: ${sessionId}`,
+                        },
+                    });
+                    return;
+                }
+                owner.actionContext.readiness = owner.getReadiness();
+                // Session-scoped routes: ownership is durable on the record; no explicit
+                // workspace scope is needed (it lives in store record + query conflict check).
+                await dispatchChat(req, res, owner.chatRouteDeps, pathname, undefined);
+                return;
+            }
+            // Non-session chat surface (capabilities, repo browser) resolves from
+            // query workspaceId; fail closed when missing.
+            const workspaceId = url.searchParams.get("workspaceId") ?? undefined;
+            const resolution = await resolveContext(workspaceId);
+            if (!resolution.ok) {
+                sendJson(res, resolution.status, {
+                    ok: false,
+                    error: { code: resolution.code, message: resolution.message },
+                });
+                return;
+            }
+            resolution.context.actionContext.readiness =
+                resolution.context.getReadiness();
+            await dispatchChat(req, res, resolution.context.chatRouteDeps, pathname, undefined);
+        }
+        async function handleOperatorDispatch(req, res, pathname, url, method) {
+            const { handleConsoleOperatorRequest } = await import("./routes.js");
+            // POST /api/operator/v1/operations creation carries workspaceId in the
+            // JSON body. Operation reads carry ?workspaceId=. Non-workspace routes
+            // (readiness, recovery, session ping, night-aux-ticker) use the startup
+            // context for backward compatibility.
+            if (method === "POST" && pathname === "/api/operator/v1/operations") {
+                const resolution = await resolveContextFromOperationCreateBody(req, res, resolveContext);
+                if (!resolution)
+                    return; // response already sent
+                await handleConsoleOperatorRequest(req, res, operatorRouteContext(resolution.context));
+                return;
+            }
+            const opMatch = pathname.match(/^\/api\/operator\/v1\/operations\/([^/]+)(?:\/(events))?$/);
+            if ((method === "GET" && pathname === "/api/operator/v1/operations") ||
+                opMatch) {
+                const workspaceId = url.searchParams.get("workspaceId") ?? undefined;
+                const resolution = await resolveContext(workspaceId);
+                if (!resolution.ok) {
+                    sendJson(res, resolution.status, {
+                        ok: false,
+                        error: { code: resolution.code, message: resolution.message },
+                    });
+                    return;
+                }
+                resolution.context.actionContext.readiness =
+                    resolution.context.getReadiness();
+                await handleConsoleOperatorRequest(req, res, operatorRouteContext(resolution.context));
+                return;
+            }
+            // Multi-workspace read-scope (2026-08-26, AC-005): every remaining
+            // operator read route (readiness, recovery candidates, night-aux-ticker
+            // GET and the ticker POST mutation) requires an EXPLICIT workspaceId;
+            // missing/unknown ids fail closed with the shared error contract. No
+            // route silently falls back to the startup workspace anymore. Only
+            // /api/session/ping stays process-level (mutation-gate probe stub).
+            if ((method === "GET" &&
+                (pathname === "/api/operator/v1/readiness" ||
+                    pathname === "/api/operator/v1/recovery/candidates" ||
+                    pathname === "/api/operator/v1/night-aux-ticker")) ||
+                (method === "POST" &&
+                    pathname === "/api/operator/v1/night-aux-ticker")) {
+                const workspaceId = url.searchParams.get("workspaceId") ?? undefined;
+                const resolution = await resolveContext(workspaceId);
+                if (!resolution.ok) {
+                    sendJson(res, resolution.status, {
+                        ok: false,
+                        error: { code: resolution.code, message: resolution.message },
+                    });
+                    return;
+                }
+                resolution.context.actionContext.readiness =
+                    resolution.context.getReadiness();
+                await handleConsoleOperatorRequest(req, res, operatorRouteContext(resolution.context));
+                return;
+            }
+            // /api/session/ping stays process-level (mutation-gate probe stub).
+            if (pathname === "/api/session/ping") {
+                await handleConsoleOperatorRequest(req, res, operatorRouteContext(startup));
+                return;
+            }
+            // Unknown operator route: fail closed (never a startup-workspace proxy).
+            sendJson(res, 404, {
+                ok: false,
+                error: {
+                    code: "NOT_FOUND",
+                    message: `unknown operator route: ${pathname}`,
+                },
+            });
+        }
+        function operatorRouteContext(context) {
+            return {
+                repoRoot: context.repoRoot,
+                staticDir,
+                bootToken,
+                inspectBootToken,
+                getConsoleOrigin,
+                allowNonLoopbackAccess: !loopbackBind,
+                inspect: {
+                    ready: existsSync(path.join(inspectStaticDir, "index.html")),
+                    routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
+                },
+                consoleInstanceId,
+                operator: {
+                    actionContext: context.actionContext,
+                    operations: context.operations,
+                    events: context.events,
+                    getReadiness: context.getReadiness,
+                    chat: context.chatRouteDeps,
+                    nightAuxTicker: context.nightAuxTicker,
+                },
+                workspace: context,
+            };
         }
         server.on("error", reject);
         server.listen(configuredPort, host, () => {
@@ -407,31 +648,133 @@ export async function createConsoleServer(options) {
                 url,
                 host,
                 port: addr.port,
-                appData,
-                operations,
-                events,
+                appData: startup.appData,
+                operations: startup.operations,
+                events: startup.events,
                 getReadiness,
                 operatorSessionId,
+                registry,
+                getWorkspaceContext: (workspaceId) => workspaceContexts.get(workspaceId),
+                listWorkspaceContexts: () => [...workspaceContexts.values()],
                 close: () => new Promise((closeResolve, closeReject) => {
-                    // Dispose all Chat Pi sessions BEFORE closing the HTTP server so
+                    // Dispose ALL workspace contexts BEFORE closing the HTTP server so
                     // no prompt is left executing and no session/SDK state/file handle
-                    // leaks across Console restarts (regression: close() previously
-                    // only closed the socket, leaving ConsolePiRuntime sessions live).
-                    try {
-                        chatOperationLinker.dispose();
-                        chatRuntime.disposeAll();
-                        nightAuxTicker.dispose();
-                    }
-                    catch (error) {
-                        // Best-effort: surface but do not block the HTTP close.
-                        process.stderr.write(`[console] chatRuntime.disposeAll() failed during close: ${error instanceof Error ? error.message : String(error)}\n`);
+                    // leaks across Console restarts. Each context is disposed exactly
+                    // once (dispose() is idempotent).
+                    for (const context of workspaceContexts.values()) {
+                        try {
+                            context.dispose();
+                        }
+                        catch (error) {
+                            process.stderr.write(`[console] workspace context dispose failed during close: ${error instanceof Error ? error.message : String(error)}\n`);
+                        }
                     }
+                    workspaceContexts.clear();
                     server.close((err) => (err ? closeReject(err) : closeResolve()));
                 }),
             });
         });
     });
 }
+/**
+ * Resolve a workspace context for POST /chat/sessions. The workspaceId comes
+ * from the JSON body; the body is pre-read and handed to the route handler so
+ * it is not consumed twice.
+ */
+async function resolveContextFromSessionCreateBody(req, res, resolveContext) {
+    const body = await readBodyOnce(req);
+    if (!body.ok) {
+        sendJson(res, body.status, {
+            ok: false,
+            error: { code: body.code, message: body.message },
+        });
+        return undefined;
+    }
+    const record = body.value;
+    const workspaceId = typeof record.workspaceId === "string" ? record.workspaceId : undefined;
+    const resolution = await resolveContext(workspaceId);
+    if (!resolution.ok) {
+        sendJson(res, resolution.status, {
+            ok: false,
+            error: { code: resolution.code, message: resolution.message },
+        });
+        return undefined;
+    }
+    // AC-R7-002 (2026-08-23): the runtime store.create wrapper
+    // (the former per-store patch + WeakMap cache) was fully removed;
+    // workspaceId now flows as an explicit parameter from this
+    // dispatcher through handleCreateChatSession into store.create.
+    return { context: resolution.context };
+}
+/** Resolve a workspace context for POST /operations (workspaceId in body). */
+async function resolveContextFromOperationCreateBody(req, res, resolveContext) {
+    const body = await readBodyOnce(req);
+    if (!body.ok) {
+        sendJson(res, body.status, {
+            ok: false,
+            error: { code: body.code, message: body.message },
+        });
+        return undefined;
+    }
+    const record = body.value;
+    const workspaceId = typeof record.workspaceId === "string" ? record.workspaceId.trim() : "";
+    if (!workspaceId) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "WORKSPACE_REQUIRED",
+                message: "workspaceId is required",
+            },
+        });
+        return undefined;
+    }
+    const resolution = await resolveContext(workspaceId);
+    if (!resolution.ok) {
+        sendJson(res, resolution.status, {
+            ok: false,
+            error: { code: resolution.code, message: resolution.message },
+        });
+        return undefined;
+    }
+    return { context: resolution.context, preReadBody: record };
+}
+/** Read and buffer a JSON request body once (restored onto req for handlers). */
+async function readBodyOnce(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > 10 * 1024 * 1024) {
+            return {
+                ok: false,
+                status: 400,
+                code: "INVALID_INPUT",
+                message: "request body exceeds 10485760 bytes",
+            };
+        }
+        chunks.push(buf);
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim()) {
+        return { ok: true, value: {} };
+    }
+    try {
+        const value = JSON.parse(raw);
+        // Re-inject the body so downstream route handlers can read it again.
+        req.__preReadBody =
+            value;
+        return { ok: true, value };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status: 400,
+            code: "INVALID_INPUT",
+            message: `invalid JSON body: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
 function requestSource(req) {
     const forwarded = req.headers["x-forwarded-for"];
     if (typeof forwarded === "string" && forwarded.trim()) {