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

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

@@ -191,6 +191,25 @@ async function bindSessionExtensions(session) {
         return;
     await session.bindExtensions(createConsoleExtensionBindings());
 }
+export function branchForkedSessionManager(sessionManager, throughUserMessageIndex) {
+    const userEntries = (sessionManager.getBranch?.() ?? []).filter((entry) => {
+        if (!entry || typeof entry !== "object")
+            return false;
+        const candidate = entry;
+        return candidate.type === "message" && candidate.message?.role === "user";
+    });
+    const target = userEntries[throughUserMessageIndex];
+    if (!target || typeof target.id !== "string") {
+        throw new Error("FORK_MESSAGE_ENTRY_NOT_FOUND");
+    }
+    sessionManager.branch(target.id);
+    if (typeof sessionManager.appendCustomEntry !== "function") {
+        throw new Error("FORK_MESSAGE_ENTRY_PERSIST_UNSUPPORTED");
+    }
+    sessionManager.appendCustomEntry("loop-agent-fork-point", {
+        throughUserMessageIndex,
+    });
+}
 function pinOperatorChatTools(session, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
     session.setActiveToolsByName(computeChatActiveToolNames(session, sessionMode));
 }
@@ -296,6 +315,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 +467,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. */
@@ -1188,6 +1217,9 @@ export class ConsolePiRuntime {
             targetSessionDir: this.options.sessionDir,
             targetSessionId: sessionId,
         });
+        if (init.throughUserMessageIndex !== undefined) {
+            branchForkedSessionManager(sessionManager, init.throughUserMessageIndex);
+        }
         const built = await this.buildSessionWithServices({
             sessionId,
             sessionManager,
@@ -1251,11 +1283,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 +1607,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 +1630,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 +1751,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 +1875,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));
@@ -2493,6 +2714,18 @@ export function mapSdkEvent(sessionId, event, compactionId, step = 1) {
                     ? { parentToolCallId: event.parentToolCallId }
                     : {}),
             };
+        case "tool_execution_update":
+            return {
+                type: "tool_update",
+                sessionId,
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                partialResult: event.partialResult,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
+            };
         case "tool_execution_end":
             return {
                 type: "tool_result",

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

@@ -127,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)