@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.10

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

@@ -48,6 +48,8 @@ import { BrowserAutomationService } from "./browser-automation.js";
 import { buildTodoContinuationContext, } from "./todos.js";
 import { buildPersistentTerminalTools } from "./terminal-tools.js";
 import { buildScmTools } from "./scm-tools.js";
+import { DbConnectionRegistry } from "./db-connections.js";
+import { buildSqlTools } from "./pi-runtime/custom-tools/sql-tools.js";
 import { buildGoalContinuationContext, } from "./goals.js";
 import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
 import { buildScheduledGoalTools } from "./pi-runtime/custom-tools/scheduled-goal-tools.js";
@@ -189,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));
 }
@@ -294,7 +315,44 @@ 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 ?? "";
+    const activeTools = input.session.getActiveToolNames()
+        .filter((name) => typeof name === "string" && name.trim())
+        .slice(0, 256);
+    const provider = input.session.model?.provider;
+    const modelId = input.session.model?.modelId ?? input.session.model?.id;
+    const sources = ["system", "conversation"];
+    if (activeTools.length > 0)
+        sources.push("tools");
+    if (input.imageCount > 0)
+        sources.push("images");
+    return {
+        type: "request_context",
+        sessionId: input.sessionId,
+        requestId: `${input.turnId}:request:1`,
+        step: 1,
+        ...(provider && modelId ? { model: { provider, modelId } } : {}),
+        ...(input.session.thinkingLevel
+            ? { thinkingLevel: input.session.thinkingLevel }
+            : {}),
+        systemPromptHash: createHash("sha256").update(systemPrompt).digest("hex"),
+        systemPromptChars: systemPrompt.length,
+        activeTools,
+        inputChars: input.text.length,
+        imageCount: input.imageCount,
+        sources,
+    };
+}
 function readSessionManagerId(manager) {
     if (!manager || typeof manager !== "object")
         return undefined;
@@ -409,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. */
@@ -418,12 +478,14 @@ export class ConsolePiRuntime {
     compactionControllers = new Map();
     siftStates = new Map();
     /** Session-less tool definition caches (no AgentSession state). */
-    operatorCustomToolsByMode = new Map();
+    operatorCustomToolsBySession = new Map();
     exploreCustomToolsPromise;
     exploreOrchestrator;
     bindings;
     browserAutomation;
     ownsBrowserAutomation;
+    dbConnections;
+    ownsDbConnections;
     constructor(options) {
         this.options = options;
         this.loader = createOperatorChatResourceLoader();
@@ -434,6 +496,12 @@ export class ConsolePiRuntime {
             downloadsDir: path.join(this.options.sessionDir, "..", "browser-downloads"),
             screenshotsDir: path.join(this.options.sessionDir, "..", "browser-screenshots"),
         });
+        // Governed DB connections are Console-global, not repository-scoped.
+        // This keeps named connections available when the user switches folders.
+        this.ownsDbConnections = options.dbConnections === undefined;
+        this.dbConnections =
+            options.dbConnections ??
+                new DbConnectionRegistry(path.join(options.globalAppDataRoot ?? path.resolve(this.options.sessionDir, ".."), "db"), undefined, undefined, path.join(this.options.sessionDir, "..", "db"));
         this.exploreOrchestrator = new ExploreOrchestrator({
             cwd: this.options.cwd,
             bindings: this.bindings,
@@ -1018,7 +1086,7 @@ export class ConsolePiRuntime {
         const loadWorkflowTools = shouldLoadWorkflowBusinessTools(sessionMode);
         const [operatorCustomTools, exploreCustomTools] = await Promise.all([
             loadWorkflowTools
-                ? this.loadOperatorCustomTools(sessionMode)
+                ? this.loadOperatorCustomTools(sessionId, sessionMode)
                 : Promise.resolve([]),
             this.loadExploreCustomTools(),
         ]);
@@ -1059,6 +1127,16 @@ export class ConsolePiRuntime {
                 return [];
             })
             : [];
+        const sqlTools = await buildSqlTools({
+            sessionId,
+            registry: this.dbConnections,
+            ...(this.options.questionRegistry
+                ? { questionRegistry: this.options.questionRegistry }
+                : {}),
+        }).catch((error) => {
+            process.stderr.write(`[console] chat sql-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            return [];
+        });
         const agentTool = await buildAgentCustomTool({
             parentSessionId: sessionId,
             orchestrator: this.exploreOrchestrator,
@@ -1092,25 +1170,28 @@ export class ConsolePiRuntime {
             ...terminalTools,
             ...scmTools,
             ...browserTools,
+            ...sqlTools,
             ...(agentTool ? [agentTool] : []),
         ];
     }
-    loadOperatorCustomTools(sessionMode) {
+    loadOperatorCustomTools(sessionId, sessionMode) {
         if (!this.options.actionContext)
             return Promise.resolve([]);
-        const cached = this.operatorCustomToolsByMode.get(sessionMode);
+        const cacheKey = `${sessionId}:${sessionMode}`;
+        const cached = this.operatorCustomToolsBySession.get(cacheKey);
         if (cached)
             return cached;
         const promise = buildCustomOperatorTools({
             actionContext: this.options.actionContext,
+            sessionId,
             sessionMode,
         }).catch((error) => {
             process.stderr.write(`[console] chat custom-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
             // Allow a later create/reopen to retry after a transient failure.
-            this.operatorCustomToolsByMode.delete(sessionMode);
+            this.operatorCustomToolsBySession.delete(cacheKey);
             return [];
         });
-        this.operatorCustomToolsByMode.set(sessionMode, promise);
+        this.operatorCustomToolsBySession.set(cacheKey, promise);
         return promise;
     }
     loadExploreCustomTools() {
@@ -1136,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,
@@ -1199,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) {
@@ -1466,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
@@ -1489,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;
@@ -1601,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).
@@ -1615,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));
@@ -1954,6 +2227,14 @@ export class ConsolePiRuntime {
             };
             emitContextUsage();
             await this.runPrePromptCompaction(sessionId, session, text, options?.images?.length ?? 0, onEvent);
+            onEvent(buildRequestContextEvent({
+                sessionId,
+                turnId: options?.turnId ?? `${sessionId}:active`,
+                session,
+                text,
+                imageCount: options?.images?.length ?? 0,
+            }));
+            let step = 0;
             let stepStartedAt;
             let firstTokenAt;
             let pendingProviderError;
@@ -1962,12 +2243,24 @@ export class ConsolePiRuntime {
             const emitPendingProviderError = () => {
                 if (!pendingProviderError)
                     return;
-                onEvent(pendingProviderError);
+                const error = pendingProviderError;
+                onEvent(error);
+                onEvent({
+                    type: "turn_error",
+                    sessionId,
+                    step: Math.max(1, step),
+                    ...(error.providerError.code === undefined
+                        ? {}
+                        : { code: String(error.providerError.code) }),
+                    message: error.message,
+                });
                 pendingProviderError = undefined;
                 providerErrorEmitted = true;
             };
             unsub = session.subscribe((event) => {
                 const observedAt = Date.now();
+                if (event.type === "turn_start")
+                    step += 1;
                 if (event.type === "message_start" && isUserSdkMessage(event.message)) {
                     if (!initialUserMessageStarted) {
                         // The first user message_start belongs to session.prompt(text), not
@@ -1998,7 +2291,7 @@ export class ConsolePiRuntime {
                 const compactionId = event.type === "compaction_start" || event.type === "compaction_end"
                     ? activeCompaction?.compactionId ?? newCompactionId(sessionId)
                     : undefined;
-                const mapped = mapSdkEvent(sessionId, event, compactionId);
+                const mapped = mapSdkEvent(sessionId, event, compactionId, Math.max(1, step));
                 if (event.type === "compaction_end")
                     activeCompaction = undefined;
                 if (mapped?.type === "error") {
@@ -2023,7 +2316,7 @@ export class ConsolePiRuntime {
                 if (mapped?.type === "agent_settled") {
                     emitPendingProviderError();
                 }
-                if (mapped?.type === "agent_start") {
+                if (mapped?.type === "step_start" || mapped?.type === "agent_start") {
                     stepStartedAt = observedAt;
                     firstTokenAt = undefined;
                 }
@@ -2051,6 +2344,13 @@ export class ConsolePiRuntime {
                                 : { outputTokens: usage.outputTokens }),
                         };
                     onEvent({ ...mapped, ...(timing ? { timing } : {}) });
+                    if (mapped.stopReason === "length") {
+                        onEvent({
+                            type: "turn_max_tokens",
+                            sessionId,
+                            step: mapped.step ?? Math.max(1, step),
+                        });
+                    }
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
                     emitContextUsage();
@@ -2232,6 +2532,36 @@ export class ConsolePiRuntime {
         const result = await session.compact(customInstructions);
         return projectCompactSnapshot(result ?? {});
     }
+    listDatabaseConnections() {
+        return this.dbConnections.list();
+    }
+    addDatabaseConnection(input) {
+        return this.dbConnections.add(input);
+    }
+    updateDatabaseConnection(currentName, input) {
+        return this.dbConnections.update(currentName, input);
+    }
+    removeDatabaseConnection(name) {
+        return this.dbConnections.remove(name);
+    }
+    exportDatabaseConnections() {
+        return this.dbConnections.exportConfig();
+    }
+    importDatabaseConnections(input, conflict) {
+        return this.dbConnections.importConfig(input, conflict);
+    }
+    testDatabaseConnection(name) {
+        return this.dbConnections.test(name);
+    }
+    listDatabaseDatabases(name) {
+        return this.dbConnections.listDatabases(name);
+    }
+    listDatabaseTables(name, database) {
+        return this.dbConnections.listTables(name, database);
+    }
+    browseDatabaseTable(name, table, page, pageSize, database) {
+        return this.dbConnections.browseTable(name, table, page, pageSize, database);
+    }
     dispose(sessionId) {
         // Mark disposed first so a late materialization never registers ready.
         this.disposedSessions.add(sessionId);
@@ -2239,6 +2569,11 @@ export class ConsolePiRuntime {
         this.sessionInit.delete(sessionId);
         this.compactionControllers.delete(sessionId);
         this.siftStates.delete(sessionId);
+        for (const key of this.operatorCustomToolsBySession.keys()) {
+            if (key.startsWith(`${sessionId}:`)) {
+                this.operatorCustomToolsBySession.delete(key);
+            }
+        }
         const session = this.sessions.get(sessionId);
         if (session) {
             try {
@@ -2269,9 +2604,11 @@ export class ConsolePiRuntime {
         void this.exploreOrchestrator.abortAll();
         if (this.ownsBrowserAutomation)
             void this.browserAutomation.dispose();
+        if (this.ownsDbConnections)
+            this.dbConnections.dispose();
     }
 }
-function mapAssistantMessageEvent(type, sessionId, message) {
+function mapAssistantMessageEvent(type, sessionId, message, step) {
     const record = message !== null && typeof message === "object"
         ? message
         : undefined;
@@ -2295,6 +2632,10 @@ function mapAssistantMessageEvent(type, sessionId, message) {
         sessionId,
         text: extractAssistantText(message),
         ...(content.length > 0 ? { content } : {}),
+        step,
+        ...(type === "message_end" && typeof record?.stopReason === "string"
+            ? { stopReason: record.stopReason }
+            : {}),
     };
 }
 function isUserSdkMessage(message) {
@@ -2302,10 +2643,12 @@ function isUserSdkMessage(message) {
         typeof message === "object" &&
         message.role === "user");
 }
-function mapSdkEvent(sessionId, event, compactionId) {
+export function mapSdkEvent(sessionId, event, compactionId, step = 1) {
     switch (event.type) {
         case "agent_start":
             return { type: "agent_start", sessionId };
+        case "turn_start":
+            return { type: "step_start", sessionId, step };
         case "agent_end":
             return {
                 type: "agent_end",
@@ -2315,15 +2658,50 @@ function mapSdkEvent(sessionId, event, compactionId) {
         case "message_update":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_update", sessionId, event.message);
+            return mapAssistantMessageEvent("message_update", sessionId, event.message, step);
         case "message_end":
             if (!isAssistantSdkMessage(event.message))
                 return undefined;
-            return mapAssistantMessageEvent("message_end", sessionId, event.message);
-        case "turn_end":
-            // Usage is emitted from message_end (see prompt subscribe). turn_end
-            // carries the same final assistant message and would double-count.
-            return undefined;
+            return mapAssistantMessageEvent("message_end", sessionId, event.message, step);
+        case "turn_end": {
+            const record = event.message && typeof event.message === "object"
+                ? event.message
+                : undefined;
+            const reason = record?.stopReason;
+            return {
+                type: "step_end",
+                sessionId,
+                step,
+                outcome: reason === "error"
+                    ? "failed"
+                    : reason === "aborted"
+                        ? "interrupted"
+                        : "completed",
+            };
+        }
+        case "auto_retry_start":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                maxAttempts: event.maxAttempts,
+                delayMs: event.delayMs,
+                errorMessage: redactRuntimeText(event.errorMessage, 600),
+                state: "scheduled",
+            };
+        case "auto_retry_end":
+            return {
+                type: "model_retry",
+                sessionId,
+                step,
+                attempt: event.attempt,
+                state: event.success ? "completed" : "failed",
+                success: event.success,
+                ...(event.finalError
+                    ? { errorMessage: redactRuntimeText(event.finalError, 600) }
+                    : {}),
+            };
         case "tool_execution_start":
             return {
                 type: "tool_call",
@@ -2331,6 +2709,22 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
                 args: event.args,
+                step,
+                ...(event.parentToolCallId
+                    ? { 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 {
@@ -2340,6 +2734,10 @@ function mapSdkEvent(sessionId, event, compactionId) {
                 toolName: event.toolName,
                 result: event.result,
                 isError: event.isError,
+                step,
+                ...(event.parentToolCallId
+                    ? { parentToolCallId: event.parentToolCallId }
+                    : {}),
             };
         case "agent_settled":
             return { type: "agent_settled", sessionId };
@@ -2386,8 +2784,19 @@ function mapSdkEvent(sessionId, event, compactionId) {
                     : {}),
             };
         }
-        default:
+        case "message_start":
+        case "queue_update":
             return undefined;
+        default:
+            {
+                const unknownEvent = event;
+                return {
+                    type: "unknown",
+                    sessionId,
+                    eventType: String(unknownEvent.type ?? "unknown"),
+                    value: unknownEvent,
+                };
+            }
     }
 }
 function newCompactionId(sessionId) {