@tea-agent/loop-agent 0.44.0-next.4 → 0.44.0-next.6

package/dist/worker/console/chat/pi-runtime.js

@@ -296,6 +296,14 @@ export function createWizardLocalHeadersExtension(options) {
 }
 export { THINKING_LEVELS, RuntimeSnapshotUnavailableError, projectRuntimeSnapshot, };
 export { createDefaultPiSdkBindings } from "./pi-runtime/sdk-bindings.js";
+/** Catalog listing must not load skills/extensions/context — those belong to reopen. */
+const CATALOG_RESOURCE_LOADER_OPTIONS = Object.freeze({
+    noContextFiles: true,
+    noSkills: true,
+    noExtensions: true,
+    noPromptTemplates: true,
+    noThemes: true,
+});
 export { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMessage };
 export function buildRequestContextEvent(input) {
     const systemPrompt = input.session.state?.systemPrompt ?? input.session.systemPrompt ?? "";
@@ -440,6 +448,8 @@ export class ConsolePiRuntime {
     mainlineLeaves = new Map();
     /** Per-sessionId single-flight materialization (create fast-path / readiness fence). */
     sessionInit = new Map();
+    /** Concurrent reopen of the same historical JSONL shares one in-flight promise. */
+    reopenInFlight = new Map();
     /** Resolved model binding after materialization (create may return before this is known). */
     sessionModels = new Map();
     /** Durable session mode; record is the source of truth, this is the live handle cache. */
@@ -1251,11 +1261,68 @@ export class ConsolePiRuntime {
             entries: manager.getBranch?.() ?? [],
         };
     }
+    /**
+     * Workspace-scoped model catalog. A live session's ModelRuntime is reused
+     * when present; otherwise services are created without opening the Pi
+     * conversation JSONL so the picker is not blocked on cold reopen.
+     */
+    workspaceModelRuntime;
+    workspaceInspection;
+    async getWorkspaceModelRuntime() {
+        if (!this.workspaceModelRuntime) {
+            this.workspaceModelRuntime = (async () => {
+                const agentDir = await safeGetAgentDir(this.bindings);
+                const { services } = await this.bindings.createServices({
+                    cwd: this.options.cwd,
+                    agentDir,
+                    resourceLoaderOptions: { ...CATALOG_RESOURCE_LOADER_OPTIONS },
+                });
+                return services.modelRuntime;
+            })().catch((error) => {
+                this.workspaceModelRuntime = undefined;
+                throw error;
+            });
+        }
+        return this.workspaceModelRuntime;
+    }
+    /**
+     * Full OPEN-surface services for inspect UIs. No SessionManager / JSONL.
+     * Cached without sessionId so todo/goal extensions stay off the shared scope.
+     */
+    async getWorkspaceInspectionServices() {
+        if (!this.workspaceInspection) {
+            this.workspaceInspection = (async () => {
+                const agentDir = await safeGetAgentDir(this.bindings);
+                const appendSystemPrompt = composeChatSystemPromptParts({
+                    sessionMode: DEFAULT_CONSOLE_CHAT_SESSION_MODE,
+                    workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+                });
+                const { services } = await this.bindings.createServices({
+                    cwd: this.options.cwd,
+                    agentDir,
+                    resourceLoaderOptions: await this.buildResourceLoaderOptions({
+                        appendSystemPrompt,
+                    }),
+                });
+                return {
+                    modelRuntime: services.modelRuntime,
+                    resourceLoader: services
+                        .resourceLoader,
+                    settingsManager: services.settingsManager,
+                };
+            })().catch((error) => {
+                this.workspaceInspection = undefined;
+                throw error;
+            });
+        }
+        return this.workspaceInspection;
+    }
     async listModels(sessionId) {
-        await this.ensureSessionReady(sessionId);
-        const modelRuntime = this.modelRuntimes.get(sessionId);
-        if (!this.sessions.has(sessionId) || !modelRuntime)
-            throw new Error(`chat session not active: ${sessionId}`);
+        const live = this.modelRuntimes.get(sessionId);
+        if (live && this.sessions.has(sessionId)) {
+            return this.bindings.listAvailableModels({ modelRuntime: live });
+        }
+        const modelRuntime = await this.getWorkspaceModelRuntime();
         return this.bindings.listAvailableModels({ modelRuntime });
     }
     async applyModel(sessionId, model) {
@@ -1518,11 +1585,11 @@ export class ConsolePiRuntime {
         return { ok: true, revision: this.revisions.get(sessionId) ?? 0 };
     }
     /**
-     * Project the unified live runtime snapshot (design §2.2). The current Pi
-     * session is the single source of truth: real system prompt, real model /
-     * thinking selection (auto + effective), the session modelRuntime model
-     * list, and the session ResourceLoader inventories. Undefined when the
-     * session is not active — callers fail closed instead of fabricating data.
+     * Project the unified runtime snapshot (design §2.2). A live Pi session is
+     * the source of truth when present. Inspect GETs may pass
+     * `workspaceProjection` to render ResourceLoader inventories without
+     * opening the conversation JSONL. Unknown ids without that hint stay
+     * undefined so callers fail closed.
      */
     /**
      * ConsolePiRuntime.listSlashCommands
@@ -1541,18 +1608,27 @@ export class ConsolePiRuntime {
         return collectSlashCommands({ session, resourceLoader });
     }
     async getRuntimeSnapshot(sessionId, options) {
-        try {
-            await this.ensureSessionReady(sessionId);
-        }
-        catch (error) {
-            if (error instanceof PiSessionInitFailedError)
-                throw error;
-            // Inactive / unknown session: fail closed with undefined (no fabricated snapshot).
-            return undefined;
+        const initializing = this.sessionInit.get(sessionId)?.status === "initializing";
+        if (this.sessions.has(sessionId) || initializing) {
+            try {
+                await this.ensureSessionReady(sessionId);
+            }
+            catch (error) {
+                if (error instanceof PiSessionInitFailedError)
+                    throw error;
+                if (options?.workspaceProjection) {
+                    return this.projectWorkspaceRuntimeSnapshot(sessionId, options);
+                }
+                return undefined;
+            }
         }
         const session = this.sessions.get(sessionId);
-        if (!session)
+        if (!session) {
+            if (options?.workspaceProjection) {
+                return this.projectWorkspaceRuntimeSnapshot(sessionId, options);
+            }
             return undefined;
+        }
         const services = this.serviceScopes.get(sessionId);
         const modelRuntime = this.modelRuntimes.get(sessionId);
         const resourceLoader = services?.resourceLoader;
@@ -1653,6 +1729,116 @@ export class ConsolePiRuntime {
             hasBash: true,
         });
     }
+    resolveWorkspaceThinkingSelection(sessionId, stored) {
+        const live = this.thinkingSelections.get(sessionId);
+        if (live)
+            return live;
+        if (!stored || stored === "auto")
+            return "auto";
+        if (THINKING_LEVELS.includes(stored)) {
+            return stored;
+        }
+        return "auto";
+    }
+    /**
+     * Inspect projection without SessionManager.open. Used only when the Agent
+     * is not live and the caller confirmed a durable session record.
+     */
+    async projectWorkspaceRuntimeSnapshot(sessionId, options) {
+        const hint = options.workspaceProjection ?? {};
+        const sessionMode = hint.sessionMode ?? this.sessionModeOf(sessionId);
+        let inspection;
+        try {
+            inspection = await this.getWorkspaceInspectionServices();
+        }
+        catch (error) {
+            throw new RuntimeSnapshotUnavailableError(`workspace runtime projection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const resourceLoader = inspection.resourceLoader;
+        const settingsManager = inspection.settingsManager;
+        const thinkingSelection = this.resolveWorkspaceThinkingSelection(sessionId, hint.thinkingLevel);
+        const effectiveThinkingLevel = settingsManager?.getDefaultThinkingLevel?.() ??
+            (thinkingSelection === "auto" ? undefined : thinkingSelection);
+        const rawSystemPrompt = resourceLoader?.getSystemPrompt?.() ||
+            composeChatSystemPrompt({
+                sessionMode,
+                workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            });
+        if (!rawSystemPrompt) {
+            throw new RuntimeSnapshotUnavailableError("system prompt projection failed: workspace prompt was empty");
+        }
+        let models = [];
+        try {
+            models = this.bindings
+                .listAvailableModels({ modelRuntime: inspection.modelRuntime })
+                .map((entry) => ({
+                provider: entry.provider,
+                id: entry.id,
+                ...(entry.name ? { name: entry.name } : {}),
+                hasCredentials: entry.hasCredentials,
+            }));
+        }
+        catch (error) {
+            throw new RuntimeSnapshotUnavailableError(`model enumeration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const thinkingLevels = [
+            { value: "auto" },
+            ...THINKING_LEVELS.map((value) => ({ value })),
+        ];
+        let skillPrefs = { schemaVersion: 1, skills: {} };
+        let skillPrefsError;
+        if (resourceLoader) {
+            try {
+                skillPrefs = await this.loadSkillAutoInvocationPreferences();
+            }
+            catch (error) {
+                skillPrefsError = error;
+            }
+        }
+        const activeTools = chatActiveToolBaseline(sessionMode);
+        const inventories = await collectRuntimeInventories({
+            resourceLoader,
+            skillPrefs,
+            skillPrefsError,
+            agentDir: await safeGetAgentDir(this.bindings),
+            cwd: this.options.cwd,
+            tools: [],
+            activeToolNames: activeTools,
+        });
+        const storedModel = this.sessionModels.get(sessionId);
+        const provider = storedModel?.provider ?? hint.modelProvider;
+        const modelId = storedModel?.modelId ?? hint.modelId;
+        return projectRuntimeSnapshot({
+            sessionId,
+            revision: this.revisions.get(sessionId) ?? 0,
+            loadedAt: new Date().toISOString(),
+            selection: {
+                ...(provider && modelId
+                    ? { model: { provider, id: modelId } }
+                    : {}),
+                thinkingSelection,
+                ...(effectiveThinkingLevel
+                    ? { effectiveThinkingLevel: effectiveThinkingLevel }
+                    : {}),
+            },
+            models,
+            thinkingLevels,
+            systemPrompt: {
+                ...(options.includeRaw ? { raw: rawSystemPrompt } : {}),
+                text: rawSystemPrompt,
+                sha256: createHash("sha256").update(rawSystemPrompt).digest("hex"),
+                characters: rawSystemPrompt.length,
+            },
+            activeTools,
+            contextFiles: inventories.contextFiles,
+            skills: inventories.skills,
+            extensions: inventories.extensions,
+            packages: inventories.packages,
+            mcp: inventories.mcp,
+            diagnostics: inventories.diagnostics,
+            hasBash: true,
+        });
+    }
     /**
      * Re-open a previously persisted Chat session after Console restart or
      * browser refresh (roadmap M1-S04 / S05).
@@ -1667,6 +1853,19 @@ export class ConsolePiRuntime {
      * than silently creating a fresh empty session and losing prior context.
      */
     async reopenSession(init) {
+        const sessionId = init.sessionId;
+        const existing = this.reopenInFlight.get(sessionId);
+        if (existing)
+            return existing;
+        const pending = this.reopenSessionExclusive(init).finally(() => {
+            if (this.reopenInFlight.get(sessionId) === pending) {
+                this.reopenInFlight.delete(sessionId);
+            }
+        });
+        this.reopenInFlight.set(sessionId, pending);
+        return pending;
+    }
+    async reopenSessionExclusive(init) {
         await this.syncAimaxAuthToken();
         const sessionId = init.sessionId;
         const sessionMode = this.rememberSessionMode(sessionId, init.sessionMode ?? this.sessionModeOf(sessionId));

package/dist/worker/console/chat/repo-browser.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, open, readdir } from "node:fs/promises";
+import { sameFileIdentity } from "../../../shared/file-identity.js";
 import path from "node:path";
 import { guardReadPath, isSensitivePath, scrubSecrets, } from "./explore-tools.js";
 const TREE_LIMIT = 500;
@@ -126,6 +127,55 @@ export async function listRepoDirectory(repoRoot, rawPath) {
         throw error;
     }
 }
+/** Composer `@` palette keeps the first page of a directory listing scannable. */
+export const FILE_PALETTE_LIMIT = 50;
+/**
+ * Split an `@` token query into a directory listing target and basename filter.
+ * Empty or slash-free queries stay on the workspace root (M3 fuzzy is out of
+ * scope). A trailing slash lists that directory with an empty fragment.
+ */
+export function parseFilePaletteQuery(rawQuery) {
+    const query = rawQuery.replaceAll("\\", "/").replace(/^\/+/u, "");
+    const slash = query.lastIndexOf("/");
+    if (slash < 0)
+        return { directory: "", fragment: query };
+    return {
+        directory: query.slice(0, slash),
+        fragment: query.slice(slash + 1),
+    };
+}
+export function projectFilePaletteEntries(entries, fragment) {
+    const showDots = fragment.startsWith(".");
+    const needle = fragment.toLowerCase();
+    const projected = [];
+    for (const entry of entries) {
+        if (!showDots && entry.name.startsWith("."))
+            continue;
+        if (needle !== "" && !entry.name.toLowerCase().includes(needle))
+            continue;
+        const isDir = entry.kind === "directory";
+        projected.push({
+            path: isDir ? `${entry.path}/` : entry.path,
+            isDir,
+        });
+        if (projected.length >= FILE_PALETTE_LIMIT)
+            break;
+    }
+    return projected;
+}
+/** One-level `@` file palette listing. Unreadable or out-of-repo queries are empty. */
+export async function listChatFilePalette(repoRoot, rawQuery) {
+    const { directory, fragment } = parseFilePaletteQuery(rawQuery);
+    try {
+        const listed = await listRepoDirectory(repoRoot, directory);
+        return projectFilePaletteEntries(listed.entries, fragment);
+    }
+    catch (error) {
+        if (error instanceof RepoBrowserError)
+            return [];
+        throw error;
+    }
+}
 export async function readRepoPreview(repoRoot, rawPath) {
     const guard = await guardReadPath(repoRoot, rawPath);
     if (!guard.ok)
@@ -143,8 +193,7 @@ export async function readRepoPreview(repoRoot, rawPath) {
                 throw new RepoBrowserError(403, guardedCode(rechecked.code), "file path changed while it was being opened");
             const current = await lstat(rechecked.abs);
             if (current.isSymbolicLink() ||
-                current.dev !== info.dev ||
-                current.ino !== info.ino)
+                !sameFileIdentity(info, current))
                 throw new RepoBrowserError(403, "OUT_OF_REPO", "file identity changed while it was being opened");
             size = info.size;
             const readSize = Math.min(size, TEXT_PREVIEW_LIMIT);
@@ -204,8 +253,7 @@ export async function readRepoHtmlAsset(repoRoot, rawPath) {
                 throw new RepoBrowserError(403, guardedCode(rechecked.code), "file path changed while it was being opened");
             const current = await lstat(rechecked.abs);
             if (current.isSymbolicLink() ||
-                current.dev !== info.dev ||
-                current.ino !== info.ino)
+                !sameFileIdentity(info, current))
                 throw new RepoBrowserError(403, "OUT_OF_REPO", "file identity changed while it was being opened");
             return {
                 body: await handle.readFile(),

package/dist/worker/console/chat/routes.js

@@ -24,9 +24,8 @@ import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./def
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
 import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
-import { walkRepoFiles } from "./repo-walk.js";
-import { isSensitivePath, scrubSecrets } from "./explore-tools.js";
-import { listRepoDirectory, matchRepoHtmlPreviewRoute, readRepoHtmlAsset, readRepoPreview, RepoBrowserError, } from "./repo-browser.js";
+import { scrubSecrets } from "./explore-tools.js";
+import { listChatFilePalette, listRepoDirectory, matchRepoHtmlPreviewRoute, readRepoHtmlAsset, readRepoPreview, RepoBrowserError, } from "./repo-browser.js";
 import { projectRuntimeContext } from "./runtime-context.js";
 import { patchModelsConfig, readModelsConfig, readPackageInventory, } from "./pi-console-config.js";
 import { ChatInterviewAdapter, projectChatInterviewState, } from "./interview-adapter.js";
@@ -36,6 +35,7 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { makeHumanGateCard, } from "./human-gate-card.js";
 import { ContractApplyReceiptStore } from "./contract-apply-receipt-store.js";
 import { projectTaskContext } from "./context-panel.js";
+import { deriveContextInsights, estimateTokensFromText, } from "./context-insights.js";
 import { deriveChatSessionTelemetry, deriveChatTurnTelemetry } from "./session-stats.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
@@ -65,6 +65,14 @@ function reopenInitFromRecord(record) {
         sessionMode: record.sessionMode,
     };
 }
+function workspaceProjectionFromRecord(record) {
+    return {
+        sessionMode: record.sessionMode,
+        ...(record.modelProvider ? { modelProvider: record.modelProvider } : {}),
+        ...(record.modelId ? { modelId: record.modelId } : {}),
+        ...(record.thinkingLevel ? { thinkingLevel: record.thinkingLevel } : {}),
+    };
+}
 async function readChatSessionMode(deps, sessionId) {
     let record;
     try {
@@ -3020,28 +3028,8 @@ async function handlePiConfig(req, res, deps, resource) {
 async function handleChatFiles(res, deps, sessionId, query) {
     if (!(await requireChatSession(res, deps, sessionId)))
         return;
-    const q = query.trim().toLowerCase();
-    const walked = await walkRepoFiles(deps.appData.repoRoot, {
-        skipSensitive: true,
-        maxFiles: 5000,
-        includeDirs: true,
-    });
-    const entries = walked
-        .filter((entry) => !isSensitivePath(entry.repoRelative) &&
-        (!q || entry.repoRelative.toLowerCase().includes(q)))
-        .sort((a, b) => {
-        const aDir = a.repoRelative.endsWith("/");
-        const bDir = b.repoRelative.endsWith("/");
-        if (aDir !== bDir)
-            return aDir ? -1 : 1;
-        return a.repoRelative.localeCompare(b.repoRelative);
-    })
-        .slice(0, 50)
-        .map((entry) => ({
-        path: entry.repoRelative,
-        isDir: entry.repoRelative.endsWith("/"),
-    }));
-    sendJson(res, 200, { ok: true, files: entries });
+    const files = await listChatFilePalette(deps.appData.repoRoot, query);
+    sendJson(res, 200, { ok: true, files });
 }
 export async function handleChatCommands(res, deps, sessionId) {
     try {
@@ -3145,20 +3133,25 @@ async function handleSddBingo(req, res, deps, sessionId) {
     }
 }
 export async function handleRuntimeContext(res, deps, sessionId) {
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
+    const record = await deps.store.get(sessionId);
+    if (!record) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "PI_SESSION_NOT_FOUND",
+                message: `chat session not found: ${sessionId}`,
+            },
+        });
         return;
     }
-    // AC-03: system prompt comes from the REAL Pi session (agent.state.systemPrompt
-    // fallback chain); resources come from that session's ResourceLoader. The raw
-    // prompt stays server-side; the browser only ever receives the scrubbed +
-    // length-limited projection. RF-02: a critical projection failure is 503
-    // PI_RUNTIME_UNAVAILABLE — never a 500 leak or a fake-empty context.
+    // Live Agent is preferred. Cold inspect uses workspace ResourceLoader /
+    // ModelRuntime without SessionManager.open(jsonl); prompt still reopens.
+    // RF-02: a critical projection failure is 503 PI_RUNTIME_UNAVAILABLE.
     let snapshot;
     try {
         snapshot = await deps.runtime.getRuntimeSnapshot(sessionId, {
             includeRaw: true,
+            workspaceProjection: workspaceProjectionFromRecord(record),
         });
     }
     catch (error) {
@@ -3208,19 +3201,94 @@ export async function handleRuntimeContext(res, deps, sessionId) {
         }),
     });
 }
+/**
+ * GET /sessions/:id/context-insights: dsh-context parity dashboard projection.
+ * Folds the persisted event ring (works for idle/restored sessions) and, when
+ * the Pi session is live, anchors the estimate with the runtime snapshot's
+ * system-prompt size + active tool count. Read-only; never fabricates payload
+ * text beyond the bounded previews already stored on the ring.
+ */
+export async function handleContextInsights(res, deps, sessionId) {
+    const record = await deps.store.get(sessionId);
+    if (!record) {
+        sendJson(res, 404, {
+            ok: false,
+            error: { code: "NOT_FOUND", message: `chat session not found: ${sessionId}` },
+        });
+        return;
+    }
+    await deps.operationLinker.recoverSession(sessionId);
+    const snapshot = deps.events.snapshot(sessionId);
+    let systemPromptChars;
+    let systemPromptPreview;
+    let activeTools;
+    let skillInjections;
+    try {
+        const runtimeSnapshot = await deps.runtime.getRuntimeSnapshot(sessionId, {
+            includeRaw: true,
+            workspaceProjection: workspaceProjectionFromRecord(record),
+        });
+        if (runtimeSnapshot) {
+            systemPromptChars = runtimeSnapshot.systemPrompt.characters;
+            const raw = runtimeSnapshot.systemPrompt.raw ??
+                runtimeSnapshot.systemPrompt.text;
+            if (typeof raw === "string" && raw) {
+                systemPromptPreview = raw.slice(0, 120_000);
+            }
+            activeTools = runtimeSnapshot.activeTools;
+            skillInjections = runtimeSnapshot.skills
+                .slice(0, 50)
+                .map((skill) => ({
+                name: skill.name,
+                tokens: estimateTokensFromText(skill.description ?? skill.name),
+            }));
+        }
+    }
+    catch {
+        // Insights are derived from the durable ring; a live-snapshot miss only
+        // drops the anchor figures / browser static categories, never the dashboard.
+    }
+    // Tool schemas: capabilities registry projection for whitelisted operator
+    // actions, plus Pi builtins active on this session.
+    const schemaTools = buildModelCallableToolSchemas().map((tool) => ({
+        id: tool.toolId,
+        description: tool.description,
+    }));
+    const activeSet = new Set((activeTools ?? []).map((t) => t.toLowerCase()));
+    const builtinTools = (activeTools ?? [])
+        .filter((name) => !schemaTools.some((t) => t.id === name))
+        .map((name) => ({ id: name, description: "" }));
+    const insights = deriveContextInsights(snapshot, {
+        sessionId,
+        ...(systemPromptChars !== undefined ? { systemPromptChars } : {}),
+        ...(systemPromptPreview !== undefined
+            ? { systemPromptPreview }
+            : {}),
+        tools: [...schemaTools, ...builtinTools],
+        ...(skillInjections ? { skillInjections } : {}),
+    });
+    sendJson(res, 200, { ok: true, insights });
+}
 // Exported for the direct handler-boundary tests (trace binding for
 // vt-route-model-errors); router dispatch behavior is unchanged.
 export async function handleModels(req, res, deps, sessionId) {
-    // AC-01/AC-06: models (and model/thinking mutation) requests reuse the same
-    // activation path. A missing/reopen-failed runtime is a STRUCTURED error —
-    // never a fabricated empty model list.
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
-        return;
-    }
     try {
         if ((req.method ?? "GET").toUpperCase() === "GET") {
+            // Catalog is workspace-scoped (models.json / ModelRuntime). Do not wait
+            // for Pi conversation reopen and do not start it here — prompt / reload
+            // / model mutation still reopen, and concurrent reopen would stall this
+            // cheap list on the single Node thread.
+            const record = await deps.store.get(sessionId);
+            if (!record) {
+                sendJson(res, 404, {
+                    ok: false,
+                    error: {
+                        code: "PI_SESSION_NOT_FOUND",
+                        message: `chat session not found: ${sessionId}`,
+                    },
+                });
+                return;
+            }
             let models;
             try {
                 models = await deps.runtime.listModels(sessionId);
@@ -3249,6 +3317,11 @@ export async function handleModels(req, res, deps, sessionId) {
             });
             return;
         }
+        const ensured = await ensureActiveSession(deps, sessionId);
+        if (!ensured.ok) {
+            sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
+            return;
+        }
         const gate = gateMutation(req, deps);
         if (!gate.ok) {
             sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
@@ -3304,18 +3377,24 @@ async function requireChatSession(res, deps, sessionId) {
     });
     return false;
 }
-/**
- * Unified session activation (design §2.1 / AC-01): models, runtime snapshot,
- * reload and model/thinking mutation requests all flow through this path.
- *
- * - runtime already holds the session → ok;
- * - only a persisted record exists → reopen from record.sessionFile;
- * - no record / missing session file → 404 PI_SESSION_NOT_FOUND;
- * - SDK reopen failure → 503 PI_RUNTIME_UNAVAILABLE.
- *
- * Never fabricates a fresh session or an empty model list.
- */
+const ensureActiveSessionInFlight = new WeakMap();
 export async function ensureActiveSession(deps, sessionId) {
+    let bySession = ensureActiveSessionInFlight.get(deps);
+    if (!bySession) {
+        bySession = new Map();
+        ensureActiveSessionInFlight.set(deps, bySession);
+    }
+    const existing = bySession.get(sessionId);
+    if (existing)
+        return existing;
+    const pending = runEnsureActiveSession(deps, sessionId).finally(() => {
+        if (bySession.get(sessionId) === pending)
+            bySession.delete(sessionId);
+    });
+    bySession.set(sessionId, pending);
+    return pending;
+}
+async function runEnsureActiveSession(deps, sessionId) {
     // Wait for create-path materialization before treating the session as missing.
     if (typeof deps.runtime.ensureSessionReady === "function") {
         try {
@@ -3561,19 +3640,28 @@ export async function handleReloadSession(req, res, deps, sessionId) {
     });
 }
 /**
- * GET /sessions/:id/runtime-snapshot (AC-01): the unified live snapshot.
+ * GET /sessions/:id/runtime-snapshot (AC-01): live Agent when present,
+ * otherwise workspace ResourceLoader projection (no JSONL reopen).
  */
 export async function handleRuntimeSnapshot(_res, res, deps, sessionId) {
-    const ensured = await ensureActiveSession(deps, sessionId);
-    if (!ensured.ok) {
-        sendJson(res, ensured.status, { ok: false, error: { code: ensured.code, message: ensured.message } });
+    const record = await deps.store.get(sessionId);
+    if (!record) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "PI_SESSION_NOT_FOUND",
+                message: `chat session not found: ${sessionId}`,
+            },
+        });
         return;
     }
     // RF-02: a critical snapshot projection failure is 503 PI_RUNTIME_UNAVAILABLE
     // — never a 200 fake-empty snapshot.
     let snapshot;
     try {
-        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
+        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId, {
+            workspaceProjection: workspaceProjectionFromRecord(record),
+        });
     }
     catch (error) {
         if (sendRuntimeUnavailable(res, error))
@@ -4727,7 +4815,7 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
         await handleSddBingo(req, res, deps, decodeURIComponent(sddBingo[1]));
         return true;
     }
-    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload|commands)$/);
+    const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|context-insights|models|model|reload|commands)$/);
     if (m4Route) {
         const id = decodeURIComponent(m4Route[1]);
         const route = m4Route[2];
@@ -4747,6 +4835,10 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
             await handleRuntimeSnapshot(req, res, deps, id);
             return true;
         }
+        if (route === "context-insights" && method === "GET") {
+            await handleContextInsights(res, deps, id);
+            return true;
+        }
         if (route === "models" && method === "GET") {
             await handleModels(req, res, deps, id);
             return true;