@tea-agent/loop-agent 0.44.0-next.5 → 0.44.0-next.7

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

@@ -19,14 +19,14 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_
 import { InvalidChatSessionModeError, SESSION_MODE_ACTION_DENIED_CODE, SESSION_MODE_ACTION_DENIED_MESSAGE, SESSION_MODE_IMMUTABLE_CODE, UnknownChatSessionModeError, isWorkflowSessionMode, parseCreateSessionMode, readStoredSessionMode, shouldAcceptOperatorSnapshot, } from "./session-mode.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle, acceptedOperationIdFromResult, isBlankChatSession } from "./session-store.js";
+import { projectUserTurnOutline } from "./user-turn-outline.js";
 import { hashChatTurnPayload, projectChatToolEventPayload, projectUnknownChatEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./deferred-turn.js";
 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";
@@ -66,6 +66,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 {
@@ -224,6 +232,43 @@ function turnSummary(turn) {
         abortRequestedAt: turn.abortRequestedAt ?? null,
     };
 }
+function turnStateSummary(turn) {
+    return {
+        turnId: turn.turnId,
+        state: turn.state === "queued" ? "running" : turn.state,
+    };
+}
+function turnStatesForIds(events, sessionId, turnIds) {
+    const projected = new Map();
+    for (const turnId of turnIds) {
+        if (!turnId || projected.has(turnId))
+            continue;
+        const turn = events.getTurn(sessionId, turnId);
+        if (turn)
+            projected.set(turnId, turnStateSummary(turn));
+    }
+    return [...projected.values()];
+}
+const MAX_STATE_QUERY_TURN_IDS = 8;
+const MAX_STATE_QUERY_TURN_ID_CHARS = 240;
+function requestedStateTurnIds(req) {
+    const result = [];
+    const seen = new Set();
+    const url = new URL(req.url ?? "/", "http://localhost");
+    for (const raw of url.searchParams.getAll("turnId")) {
+        const turnId = raw.trim();
+        if (!turnId ||
+            turnId.length > MAX_STATE_QUERY_TURN_ID_CHARS ||
+            seen.has(turnId)) {
+            continue;
+        }
+        seen.add(turnId);
+        result.push(turnId);
+        if (result.length >= MAX_STATE_QUERY_TURN_IDS)
+            break;
+    }
+    return result;
+}
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
@@ -414,6 +459,20 @@ export function turnEventToStorePartial(event) {
                         : {}),
                 }),
             };
+        case "tool_update":
+            return {
+                kind: "tool_update",
+                data: projectChatToolEventPayload({
+                    kind: "tool_update",
+                    toolCallId: String(event.toolCallId ?? ""),
+                    toolName: String(event.toolName ?? ""),
+                    value: event.partialResult,
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.parentToolCallId === "string"
+                        ? { parentToolCallId: event.parentToolCallId }
+                        : {}),
+                }),
+            };
         case "tool_result": {
             // Plan A (2026-08-16): surface the accepted-operation link on the live
             // SSE frame so the frontend semantic event can resolve operation:<id>.
@@ -917,25 +976,47 @@ export async function handleForkChatSession(req, res, deps, sourceSessionId) {
         });
         return;
     }
+    let forkedHandle;
+    let forkPersisted = false;
     try {
+        const body = await readJsonBody(req);
+        const throughMessageId = typeof body.throughMessageId === "string" && body.throughMessageId.trim()
+            ? body.throughMessageId.trim()
+            : undefined;
+        const throughUserMessageIndex = throughMessageId
+            ? source.messages
+                .filter((message) => message.role === "user")
+                .findIndex((message) => message.id === throughMessageId)
+            : undefined;
+        if (throughMessageId && throughUserMessageIndex === -1) {
+            throw new Error("FORK_MESSAGE_NOT_FOUND");
+        }
         const handle = await deps.runtime.forkSession({
             sourceSessionFile: source.sessionFile ?? "",
             sessionMode: source.sessionMode,
             ...(source.modelProvider && source.modelId
                 ? { model: { provider: source.modelProvider, modelId: source.modelId } }
                 : {}),
+            ...(throughUserMessageIndex !== undefined
+                ? { throughUserMessageIndex }
+                : {}),
         });
+        forkedHandle = handle;
         await deps.store.forkFrom({
             sourceSessionId,
             targetSessionId: handle.sessionId,
             targetSessionFile: handle.sessionFile,
+            ...(throughMessageId ? { throughMessageId } : {}),
         });
+        forkPersisted = true;
         await deps.attachSession?.(handle.sessionId).catch(() => undefined);
-        const copied = deps.events.forkContextRefs({
-            sourceSessionId,
-            targetSessionId: handle.sessionId,
-            targetTurnId: `${handle.sessionId}:fork`,
-        });
+        const copied = throughMessageId
+            ? { copiedCount: 0 }
+            : deps.events.forkContextRefs({
+                sourceSessionId,
+                targetSessionId: handle.sessionId,
+                targetTurnId: `${handle.sessionId}:fork`,
+            });
         await deps.operationLinker.recoverSession(handle.sessionId);
         sendJson(res, 201, {
             ok: true,
@@ -949,6 +1030,12 @@ export async function handleForkChatSession(req, res, deps, sourceSessionId) {
         });
     }
     catch (error) {
+        if (forkedHandle && !forkPersisted) {
+            deps.runtime.dispose(forkedHandle.sessionId);
+            await deps.store
+                .discardUnownedSession(forkedHandle.sessionId, forkedHandle.sessionFile)
+                .catch(() => undefined);
+        }
         sendJson(res, 409, {
             ok: false,
             error: {
@@ -1098,12 +1185,18 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
     const sddSessionIdentity = deps.sddDataAlignment && (await deps.sddDataAlignment.isEligible())
         ? { telemetrySessionId: record.telemetrySessionId ?? null }
         : undefined;
+    const projectedMessages = projectStoredMessagesWithEventOrder(messagePage.messages, snapshot);
+    const turnStates = turnStatesForIds(deps.events, sessionId, [
+        ...projectedMessages.map((message) => message.turnId),
+        ...snapshot.map((event) => event.turnId),
+    ]);
     sendJson(res, 200, {
         ok: true,
         eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...projectBrowserChatSession(record),
-            messages: projectStoredMessagesWithEventOrder(messagePage.messages, snapshot),
+            messages: projectedMessages,
+            turnStates,
             composerDraft,
             activeTurnId: activeTurn?.turnId,
             turnPhase: activeTurn
@@ -1123,6 +1216,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
         turnTelemetry: deriveChatTurnTelemetry(snapshot),
+        userTurnOutline: projectUserTurnOutline(record.messages ?? []),
         ...(sddSessionIdentity
             ? { sddDataAlignment: sddSessionIdentity }
             : {}),
@@ -1401,7 +1495,14 @@ function emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientReques
         data: {
             ...(clientRequestId ? { clientRequestId } : {}),
             ...(steering ? { steering: true } : {}),
-            message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
+            message: {
+                id: userMessage.id,
+                text: userMessage.text,
+                at: userMessage.at,
+                ...(userMessage.attachments?.length
+                    ? { attachments: userMessage.attachments }
+                    : {}),
+            },
         },
     });
 }
@@ -1409,7 +1510,7 @@ function emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientReques
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
  *  interval / visibility / online without paying for session detail. */
-export async function handleGetChatSessionState(_req, res, deps, sessionId) {
+export async function handleGetChatSessionState(req, res, deps, sessionId) {
     const record = await deps.store.get(sessionId);
     if (!record) {
         sendJson(res, 404, {
@@ -1440,9 +1541,15 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
         : runtimeBusy
             ? "running"
             : "idle";
+    const turnStates = turnStatesForIds(deps.events, sessionId, [
+        active?.turnId,
+        latest?.turnId,
+        ...requestedStateTurnIds(req),
+    ]);
     sendJson(res, 200, {
         ok: true,
         state: {
+            turnStates,
             // Legacy flat fields retained for older clients.
             activeTurnId: active?.turnId ?? null,
             activeTurnState: active?.state ?? null,
@@ -3021,28 +3128,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 {
@@ -3146,20 +3233,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) {
@@ -3234,6 +3326,7 @@ export async function handleContextInsights(res, deps, sessionId) {
     try {
         const runtimeSnapshot = await deps.runtime.getRuntimeSnapshot(sessionId, {
             includeRaw: true,
+            workspaceProjection: workspaceProjectionFromRecord(record),
         });
         if (runtimeSnapshot) {
             systemPromptChars = runtimeSnapshot.systemPrompt.characters;
@@ -3279,16 +3372,23 @@ export async function handleContextInsights(res, deps, sessionId) {
 // 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);
@@ -3317,6 +3417,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 } });
@@ -3372,18 +3477,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 {
@@ -3629,19 +3740,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))
@@ -4464,7 +4584,14 @@ export async function handleChatMessages(res, deps, sessionId, url) {
             limit: Number.isFinite(limit) ? limit : 30,
             beforeId: url.searchParams.get("beforeId") ?? undefined,
         });
-        sendJson(res, 200, { ok: true, ...page });
+        const snapshot = deps.events.snapshot(sessionId);
+        const messages = projectStoredMessagesWithEventOrder(page.messages, snapshot);
+        sendJson(res, 200, {
+            ok: true,
+            ...page,
+            messages,
+            turnStates: turnStatesForIds(deps.events, sessionId, messages.map((message) => message.turnId)),
+        });
     }
     catch (error) {
         sendJson(res, 404, {
@@ -4476,6 +4603,23 @@ export async function handleChatMessages(res, deps, sessionId, url) {
         });
     }
 }
+export async function handleChatAttachment(res, deps, sessionId, attachmentId) {
+    const attachment = await deps.store.readAttachment(sessionId, attachmentId);
+    if (!attachment) {
+        sendJson(res, 404, {
+            ok: false,
+            error: { code: "NOT_FOUND", message: "chat attachment not found" },
+        });
+        return;
+    }
+    res.writeHead(200, {
+        "content-type": attachment.metadata.mimeType,
+        "content-length": String(attachment.bytes.length),
+        "cache-control": "private, max-age=31536000, immutable",
+        "x-content-type-options": "nosniff",
+    });
+    res.end(attachment.bytes);
+}
 /**
  * Dispatch a chat HTTP request. Returns true if handled.
  * Mounted under /api/operator/v1/chat/*.
@@ -4913,6 +5057,11 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
         await handleChatMessages(res, deps, decodeURIComponent(sessionMessages[1]), url);
         return true;
     }
+    const sessionAttachment = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/attachments\/([^/]+)$/);
+    if (method === "GET" && sessionAttachment) {
+        await handleChatAttachment(res, deps, decodeURIComponent(sessionAttachment[1]), decodeURIComponent(sessionAttachment[2]));
+        return true;
+    }
     const sessionPrompt = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/prompt$/);
     if (method === "POST" && sessionPrompt) {
         await handleChatPrompt(req, res, deps, decodeURIComponent(sessionPrompt[1]));