@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

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

@@ -0,0 +1,337 @@
+export function resolveRouteWorkspaceSelection(workspaceId, knownWorkspaceIds) {
+    const id = workspaceId?.trim();
+    if (!id)
+        return { status: "ok", workspaceId: undefined };
+    if (knownWorkspaceIds.includes(id))
+        return { status: "ok", workspaceId: id };
+    return { status: "unknown-workspace", workspaceId: id };
+}
+export const OPERATE_TAB_IDS = [
+    "tasks",
+    "recovery",
+    "night",
+    "models",
+    "settings",
+];
+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";
+export const DEFAULT_OPERATE_TAB = "tasks";
+export const CHAT_HREF = "/#/chat";
+export const DEFAULT_INSPECT_HREF = "/#/inspect";
+export const DEFAULT_OPERATE_HREF = "/#/operate/tasks";
+const INSPECT_COLLECTION_OR_OBJECT = /^(dag|run|task|feature|batch|night|pool|failures|dags)(\/|$)/;
+export function splitHash(hashValue) {
+    const raw = String(hashValue ?? "").replace(/^#/, "");
+    const qIndex = raw.indexOf("?");
+    const pathPart = qIndex >= 0 ? raw.slice(0, qIndex) : raw;
+    const path = pathPart
+        ? pathPart.startsWith("/")
+            ? pathPart
+            : `/${pathPart}`
+        : "/";
+    const query = new URLSearchParams(qIndex >= 0 ? raw.slice(qIndex + 1) : "");
+    return { path, query };
+}
+export function stripInspectPrefix(path) {
+    if (path === "/inspect" || path === "/inspect/")
+        return "/";
+    if (path.startsWith("/inspect/"))
+        return path.slice("/inspect".length) || "/";
+    return path;
+}
+function isOperateTab(value) {
+    return (value === "tasks" ||
+        value === "recovery" ||
+        value === "night" ||
+        value === "models" ||
+        value === "settings");
+}
+function readParam(query, key) {
+    const value = query.get(key)?.trim();
+    return value || undefined;
+}
+function readWorkspaceParams(query) {
+    return {
+        ...(readParam(query, "taskId") ? { taskId: readParam(query, "taskId") } : {}),
+        ...(readParam(query, "dagRunId")
+            ? { dagRunId: readParam(query, "dagRunId") }
+            : {}),
+        ...(readParam(query, "fromNodeId")
+            ? { fromNodeId: readParam(query, "fromNodeId") }
+            : {}),
+        ...(readParam(query, "featureId")
+            ? { featureId: readParam(query, "featureId") }
+            : {}),
+        ...(readParam(query, "intent") ? { intent: readParam(query, "intent") } : {}),
+        ...(readParam(query, "workspaceId")
+            ? { workspaceId: readParam(query, "workspaceId") }
+            : {}),
+        ...(readParam(query, "sessionId")
+            ? { sessionId: readParam(query, "sessionId") }
+            : {}),
+    };
+}
+function paramsQuery(params) {
+    const query = new URLSearchParams();
+    for (const key of [
+        "taskId",
+        "dagRunId",
+        "fromNodeId",
+        "featureId",
+        "intent",
+        "workspaceId",
+        "sessionId",
+    ]) {
+        const value = params[key]?.trim();
+        if (value)
+            query.set(key, value);
+    }
+    return query.toString();
+}
+export function readLastOperateTab(storage) {
+    try {
+        const raw = storage?.getItem(LAST_OPERATE_TAB_STORAGE_KEY);
+        if (isOperateTab(raw))
+            return raw;
+    }
+    catch {
+        /* ignore */
+    }
+    return DEFAULT_OPERATE_TAB;
+}
+export function rememberOperateTab(tab, storage) {
+    try {
+        storage?.setItem(LAST_OPERATE_TAB_STORAGE_KEY, tab);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function readLastInspectHref(storage) {
+    try {
+        const raw = storage?.getItem(LAST_INSPECT_HASH_STORAGE_KEY)?.trim();
+        if (raw?.startsWith("/#/inspect"))
+            return raw;
+    }
+    catch {
+        /* ignore */
+    }
+    return DEFAULT_INSPECT_HREF;
+}
+export function rememberInspectHref(href, storage) {
+    const canonical = href.startsWith("/#/inspect")
+        ? href
+        : rewriteInspectHrefToCanonical(href);
+    if (!canonical.startsWith("/#/inspect"))
+        return;
+    try {
+        storage?.setItem(LAST_INSPECT_HASH_STORAGE_KEY, canonical);
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function buildOperateHref(tab = DEFAULT_OPERATE_TAB, params = {}) {
+    const qs = paramsQuery(params);
+    return `/#/operate/${tab}${qs ? `?${qs}` : ""}`;
+}
+export function buildInspectHref(inspectPath = "/", query) {
+    const normalized = stripInspectPrefix(inspectPath.startsWith("/") ? inspectPath : `/${inspectPath}`);
+    const path = normalized === "/" || normalized === ""
+        ? "/inspect"
+        : `/inspect${normalized}`;
+    const qs = typeof query === "string"
+        ? query.replace(/^\?/, "")
+        : query?.toString() ?? "";
+    return `/#${path}${qs ? `?${qs}` : ""}`;
+}
+export function buildChatHref(params = {}) {
+    const qs = paramsQuery(params);
+    return qs ? `${CHAT_HREF}?${qs}` : CHAT_HREF;
+}
+/** Keep the selected Workspace on any canonical Console destination without
+ * changing its page-specific path or query state. */
+export function withWorkspaceId(href, workspaceId) {
+    const canonical = href.startsWith("/#")
+        ? href
+        : href.startsWith("#")
+            ? `/${href}`
+            : rewriteInspectHrefToCanonical(href);
+    const { path, query } = splitHash(canonical.slice(2));
+    const id = workspaceId?.trim();
+    if (id)
+        query.set("workspaceId", id);
+    else
+        query.delete("workspaceId");
+    const qs = query.toString();
+    return `/#${path}${qs ? `?${qs}` : ""}`;
+}
+export function buildCanonicalHref(input) {
+    if (input.workspace === "chat")
+        return buildChatHref(input);
+    if (input.workspace === "operate") {
+        return buildOperateHref(input.operateTab ?? DEFAULT_OPERATE_TAB, input);
+    }
+    return buildInspectHref(input.inspectPath ?? "/", input.inspectQuery);
+}
+function finishInspect(inspectPath, query, replace) {
+    const qs = query.toString();
+    const canonicalHref = buildInspectHref(inspectPath, qs);
+    return {
+        workspace: "inspect",
+        operateTab: DEFAULT_OPERATE_TAB,
+        inspectPath: stripInspectPrefix(inspectPath),
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...readWorkspaceParams(query),
+    };
+}
+function finishOperate(tab, query, replace) {
+    const canonicalHref = buildOperateHref(tab, readWorkspaceParams(query));
+    return {
+        workspace: "operate",
+        operateTab: tab,
+        inspectPath: "/",
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...readWorkspaceParams(query),
+    };
+}
+function finishChat(replace, params) {
+    const effective = params ?? {};
+    const canonicalHref = buildChatHref(effective);
+    return {
+        workspace: "chat",
+        operateTab: DEFAULT_OPERATE_TAB,
+        inspectPath: "/",
+        canonicalHash: canonicalHref.slice(2),
+        canonicalHref,
+        replace,
+        ...effective,
+    };
+}
+export function parseWorkspaceRoute(location, options = {}) {
+    const pathname = String(location.pathname ?? "/").replace(/\/+$/, "") || "/";
+    const lastTab = options.lastOperateTab ?? DEFAULT_OPERATE_TAB;
+    if (pathname === "/inspect") {
+        const { path, query } = splitHash(location.hash ?? "#/");
+        return finishInspect(path, query, true);
+    }
+    const { path, query } = splitHash(location.hash ?? "");
+    if (!location.hash || path === "/")
+        return null;
+    if (path === "/inspect" || path.startsWith("/inspect/")) {
+        return finishInspect(stripInspectPrefix(path), query, false);
+    }
+    if (path === "/chat")
+        return finishChat(false, readWorkspaceParams(query));
+    if (path === "/operate") {
+        return finishOperate(lastTab, query, true);
+    }
+    if (path.startsWith("/operate/")) {
+        const tab = path.slice("/operate/".length).split("/")[0] ?? "";
+        if (isOperateTab(tab))
+            return finishOperate(tab, query, false);
+        return finishOperate(lastTab, query, true);
+    }
+    if (isOperateTab(path.replace(/^\//, "").split("/")[0] ?? "")) {
+        const tab = path.replace(/^\//, "").split("/")[0];
+        return finishOperate(tab, query, true);
+    }
+    const inspectInternal = stripInspectPrefix(path).replace(/^\//, "");
+    if (INSPECT_COLLECTION_OR_OBJECT.test(inspectInternal)) {
+        return finishInspect(path, query, true);
+    }
+    return null;
+}
+export function rewriteInspectHrefToCanonical(href, base = typeof globalThis.location?.href === "string"
+    ? globalThis.location.href
+    : "http://local.invalid/") {
+    const raw = String(href ?? "").trim();
+    if (!raw)
+        return DEFAULT_INSPECT_HREF;
+    if (raw.startsWith("/#/inspect"))
+        return raw;
+    if (raw.startsWith("#/inspect"))
+        return `/${raw}`;
+    if (raw.startsWith("/#/operate") || raw.startsWith("/#/chat"))
+        return raw;
+    if (raw.startsWith("#/operate") || raw.startsWith("#/chat"))
+        return `/${raw}`;
+    try {
+        const url = new URL(raw, base);
+        const pathname = url.pathname.replace(/\/+$/, "") || "/";
+        if (pathname === "/inspect") {
+            const { path, query } = splitHash(url.hash || "#/");
+            const merged = new URLSearchParams(url.search);
+            for (const [key, value] of query)
+                merged.set(key, value);
+            return buildInspectHref(path, merged);
+        }
+        const { path, query } = splitHash(url.hash || "");
+        if (path === "/inspect" || path.startsWith("/inspect/")) {
+            return buildInspectHref(stripInspectPrefix(path), query);
+        }
+        const internal = path.replace(/^\//, "");
+        if (INSPECT_COLLECTION_OR_OBJECT.test(internal)) {
+            return buildInspectHref(path, query);
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    if (raw.startsWith("#/") && INSPECT_COLLECTION_OR_OBJECT.test(raw.slice(2))) {
+        return buildInspectHref(raw.slice(1));
+    }
+    return DEFAULT_INSPECT_HREF;
+}
+export function isInspectDocumentHref(href, base = typeof globalThis.location?.href === "string"
+    ? globalThis.location.href
+    : "http://local.invalid/") {
+    try {
+        const url = new URL(String(href ?? ""), base);
+        const pathname = url.pathname.replace(/\/+$/, "") || "/";
+        if (pathname !== "/inspect")
+            return false;
+        return !/\.[a-z0-9]+$/i.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+export function hrefToLocationHash(href) {
+    const canonical = href.startsWith("/#")
+        ? href
+        : href.startsWith("#")
+            ? `/${href}`
+            : rewriteInspectHrefToCanonical(href);
+    return canonical.startsWith("/#") ? canonical.slice(1) : canonical;
+}
+export function applyCanonicalHref(href) {
+    const hash = hrefToLocationHash(href);
+    if (typeof window === "undefined")
+        return hash;
+    const current = window.location.hash || "";
+    const normalizedCurrent = current.startsWith("#") ? current : `#${current}`;
+    const normalizedNext = hash.startsWith("#") ? hash : `#${hash}`;
+    if (normalizedCurrent !== normalizedNext) {
+        window.location.hash = normalizedNext;
+    }
+    return normalizedNext;
+}
+export function shouldCanonicalizeInspectDocument(location) {
+    const pathname = String(location.pathname ?? "/").replace(/\/+$/, "") || "/";
+    return pathname === "/inspect";
+}
+export function canonicalConsoleInspectHref(location) {
+    const { path, query } = splitHash(location.hash ?? "#/");
+    return buildInspectHref(path, query);
+}
+export function inspectInternalHash(hashValue) {
+    const { path, query } = splitHash(hashValue);
+    const internal = stripInspectPrefix(path);
+    const qs = query.toString();
+    return `${internal}${qs ? `?${qs}` : ""}`;
+}

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

@@ -0,0 +1,344 @@
+/**
+ * Repo-scoped Workspace Context (2026-08-22 multi-workspace foundation, W1).
+ *
+ * One lazily-created ConsoleContext per workspaceId. Each context INDEPENDENTLY
+ * owns the full operator runtime for its repo root: fingerprint-isolated
+ * appData (via openConsoleAppData), operation/event stores, draft /
+ * confirmation / receipt / interview / assessment stores, Chat session store +
+ * events + deferred Turn registry + ConsolePiRuntime(cwd=repoRoot),
+ * OperatorActionContext, Observe route context, and readiness.
+ *
+ * Invariants:
+ *   - Selecting (viewing) another workspace NEVER disposes a context; running
+ *     Turns / Operations / DAGs continue in the background.
+ *   - dispose() is invoked exactly once per context by the owning server's
+ *     close().
+ *   - bootToken is shared per Console boot: it binds the startup fingerprint
+ *     and bind host, and its confirmationToken signs human-gate tokens for all
+ *     workspaces in this process (single Console security domain).
+ */
+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, sha256Json, writeSecureJson, } 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 { 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 { UserQuestionRegistry } from "./chat/user-questions.js";
+import { TodoListRegistry } from "./chat/todos.js";
+import { createOperationEventStore, } from "./operation-sse.js";
+import { OperationStore } from "./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 { probePiReadiness, } from "./pi-readiness.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { NightAuxTicker } from "./night-aux-ticker.js";
+import { createObserveRouteContext, } from "../observe/routes.js";
+import { WorkspaceRegistry } from "./workspace-registry.js";
+import { resolveConsoleDefaultTimeoutMs } from "./server.js";
+/**
+ * Lazily create the full repo-scoped Console context for a registered
+ * workspace record. Pure factory — no global registry; the caller owns
+ * lifecycle (single creation per workspaceId, dispose on server close).
+ */
+export async function createWorkspaceContext(record, deps) {
+    const repoRoot = record.repoRoot;
+    const appData = openConsoleAppData({
+        repoRoot,
+        ...(deps.appDataRoot ? { appDataRoot: deps.appDataRoot } : {}),
+    });
+    const registry = new WorkspaceRegistry(appData);
+    const readiness = await probePiReadiness({
+        override: deps.piReadinessProbe,
+        repoRoot,
+    });
+    let readinessCache = readiness;
+    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
+    const client = deps.createClient?.(artifactRoot) ??
+        new LoopAgentClient({
+            loopAgentBin: resolveSiblingLoopAgentBin(),
+            artifactRoot,
+            resolveIdentity: true,
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(deps.defaultTimeoutMs),
+        });
+    const operations = new OperationStore(appData);
+    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);
+    const interviews = new InterviewSessionStore(appData);
+    const assessments = new AssessmentStore(appData);
+    if (!deps.skipReconcile) {
+        await operations.reconcileOnBoot();
+    }
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
+    const actionContext = {
+        repoRoot,
+        appData,
+        operatorSessionId: deps.operatorSessionId,
+        client,
+        operations,
+        events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        humanGateSecret: deps.bootToken.confirmationToken,
+        interviews,
+        assessments,
+        readiness: readinessCache,
+        getReadiness,
+        refreshReadiness,
+        observeBaseUrl: deps.observeBaseUrl,
+        fetchImpl: deps.fetchImpl,
+        getConsoleOrigin: deps.getConsoleOrigin,
+    };
+    const chatStore = new ChatSessionStore(appData);
+    const chatEventEpoch = randomBytes(12).toString("hex");
+    const chatEvents = createChatEventStore({
+        appData,
+        epoch: chatEventEpoch,
+    });
+    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    const questionRegistry = new UserQuestionRegistry(path.join(appData.chats, "user-questions"));
+    const todoRegistry = new TodoListRegistry();
+    questionRegistry.subscribe((change) => {
+        const question = change.question;
+        chatEvents.append(question.sessionId, question.turnId ?? `${question.sessionId}:question`, {
+            kind: `question_${change.type}`,
+            data: { question },
+        });
+    });
+    todoRegistry.subscribe((change) => {
+        chatEvents.append(change.sessionId, change.turnId ?? `${change.sessionId}:todo`, {
+            kind: change.type === "updated" ? "todo_updated" : "todo_cleared",
+            data: {
+                todos: change.todos,
+                ...(change.toolCallId ? { toolCallId: change.toolCallId } : {}),
+            },
+        });
+    });
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
+    const chatRuntime = new ConsolePiRuntime({
+        cwd: repoRoot,
+        sessionDir: appData.chatSessions,
+        resourcePreferencesPath: appData.resourcePreferences,
+        actionContext,
+        questionRegistry,
+        todoRegistry,
+    });
+    const chatRouteDeps = {
+        runtime: chatRuntime,
+        store: chatStore,
+        events: chatEvents,
+        turnExecutions: chatTurnExecutions,
+        questionRegistry,
+        todoRegistry,
+        operationLinker: chatOperationLinker,
+        appData,
+        bootToken: deps.bootToken,
+        getConsoleOrigin: deps.getConsoleOrigin,
+        allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+    };
+    const { recoverDeferredTurns } = await import("./chat/routes.js");
+    const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: deps.inspectStaticDir,
+    });
+    let disposed = false;
+    const context = {
+        workspaceId: record.workspaceId,
+        record,
+        repoRoot,
+        appData,
+        registry,
+        client,
+        operations,
+        events,
+        splitOrchestrator,
+        humanDecisionAdapter,
+        materializer,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        interviews,
+        assessments,
+        chatRouteDeps,
+        chatOperationLinker,
+        chatRuntime,
+        nightAuxTicker,
+        actionContext,
+        observeRouteContext,
+        getReadiness,
+        refreshReadiness,
+        recoverDeferredTurns: () => recoverDeferredTurns(chatRouteDeps),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            try {
+                chatOperationLinker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                chatRuntime.disposeAll();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                nightAuxTicker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+        },
+    };
+    return context;
+}
+/** Inspect-facing readiness/capability summary for a registry record. */
+export async function summarizeWorkspaceRecord(record, deps) {
+    let state;
+    try {
+        const report = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot: record.repoRoot,
+        });
+        state = report.state;
+    }
+    catch {
+        state = "setup-required";
+    }
+    return {
+        state,
+        summary: `pi=${state}; inspect=${deps.inspectReady ? "ready" : "unavailable"}`,
+    };
+}
+void existsSync;