@tea-agent/loop-agent 0.33.6 → 0.34.0

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

@@ -33,7 +33,7 @@ import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
-import { resolveDefaultChatModel, } from "./model-resolver.js";
+import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
 /**
@@ -602,6 +602,33 @@ function readSessionManagerId(manager) {
     }
     return undefined;
 }
+function readSessionManagerFile(manager) {
+    if (!manager || typeof manager !== "object")
+        return undefined;
+    const record = manager;
+    if (typeof record.getSessionFile === "function") {
+        try {
+            const value = record.getSessionFile();
+            if (typeof value === "string" && value.trim())
+                return value;
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (typeof record.sessionFile === "string" && record.sessionFile.trim()) {
+        return record.sessionFile;
+    }
+    return undefined;
+}
+/** Structured materialization failure for dependent Chat endpoints. */
+export class PiSessionInitFailedError extends Error {
+    code = "PI_SESSION_INIT_FAILED";
+    constructor(message) {
+        super(message);
+        this.name = "PiSessionInitFailedError";
+    }
+}
 /**
  * Console Pi runtime — holds Chat sessions and drives prompt() with three-gate
  * tool enforcement. Session-per-sessionId; cross-request reuse via open().
@@ -618,9 +645,20 @@ export class ConsolePiRuntime {
     revisions = new Map();
     /** RF-01: per-session reload in-flight lock (concurrent second call → PI_SESSION_BUSY). */
     reloadInFlight = new Set();
+    /** At most one detached automatic-title task per durable Console session. */
+    titleInFlight = new Set();
     /** Composer thinking selection ("auto" = no explicit override). */
     thinkingSelections = new Map();
     mainlineLeaves = new Map();
+    /** Per-sessionId single-flight materialization (create fast-path / readiness fence). */
+    sessionInit = new Map();
+    /** Resolved model binding after materialization (create may return before this is known). */
+    sessionModels = new Map();
+    /** SessionIds disposed while materialization was still in flight. */
+    disposedSessions = new Set();
+    /** Session-less tool definition caches (no AgentSession state). */
+    operatorCustomToolsPromise;
+    exploreCustomToolsPromise;
     bindings;
     constructor(options) {
         this.options = options;
@@ -655,18 +693,20 @@ export class ConsolePiRuntime {
      * Resolve the Chat default model descriptor from harness.json
      * executors.pi.MED + the SDK available-model list. Returns undefined when
      * harness is unset or no provider surfaces the model. No hardcoded fallback.
+     *
+     * Prefer reusing an already-built modelRuntime (same services object as
+     * formal materialization) so create does not construct throwaway services.
      */
-    async resolveDefaultModel() {
+    async resolveDefaultModel(modelRuntime) {
         let available;
         try {
-            // Build a throwaway services just to read modelRuntime.snapshot. This is
-            // cheap (SDK caches); tests inject bindings that stub listAvailableModels.
-            const { services } = await this.bindings.createServices({
-                cwd: this.options.cwd,
-                agentDir: await safeGetAgentDir(this.bindings),
-            });
+            const runtime = modelRuntime ??
+                (await this.bindings.createServices({
+                    cwd: this.options.cwd,
+                    agentDir: await safeGetAgentDir(this.bindings),
+                })).services.modelRuntime;
             available = this.bindings.listAvailableModels({
-                modelRuntime: services.modelRuntime,
+                modelRuntime: runtime,
             });
         }
         catch {
@@ -680,29 +720,107 @@ export class ConsolePiRuntime {
             modelId: descriptor.modelId,
         };
     }
-    /** Create a new isolated Chat session pinned to the operator-chat tool set. */
+    /**
+     * Fast create: durable SessionManager/JSONL shell first, then single-flight
+     * AgentSession materialization in the background. 201 may report
+     * `initializing: true`; dependent routes wait on the same promise.
+     */
     async createSession(init) {
         const sessionId = `operator-chat-${randomBytes(12).toString("hex")}`;
-        const agentDir = await safeGetAgentDir(this.bindings);
-        // Resolve default model from harness.json executors.pi.MED (no hardcode).
-        // Caller may pass an explicit model; otherwise we read the repo harness and
-        // search the SDK available-model list for a credentialled provider.
-        let model = init?.model;
-        if (!model) {
-            const resolved = await this.resolveDefaultModel();
-            if (resolved)
-                model = resolved;
+        this.disposedSessions.delete(sessionId);
+        const sessionManager = await this.bindings.createSessionManager({
+            cwd: this.options.cwd,
+            sessionDir: this.options.sessionDir,
+            sessionId,
+        });
+        const sessionFile = readSessionManagerFile(sessionManager);
+        if (!sessionFile) {
+            throw new Error(`chat session shell missing sessionFile for ${sessionId}`);
         }
-        // Final fallback only when nothing resolved: let the SDK pick its default
-        // (we do NOT hardcode a provider here).
-        // Standard open resource surface (ADR 0012): the SDK DefaultResourceLoader
-        // loads user/project AGENTS.md context files, skills (~/.pi/agent/skills/
-        // + .agents/skills/ init projection) and user/project extensions. Only
-        // appendSystemPrompt carries the operator-chat system prompt.
+        this.sessionManagers.set(sessionId, sessionManager);
+        this.thinkingSelections.set(sessionId, "auto");
+        // Detached single-flight materialization; dependent routes await the same promise.
+        void this.startMaterialization(sessionId, {
+            sessionManager,
+            model: init?.model,
+            systemPromptSuffix: init?.systemPromptSuffix,
+            // Create path must resolve default model from the SAME services object
+            // used for formal materialization (no throwaway createServices).
+            resolveDefaultModel: !init?.model,
+        });
+        return {
+            sessionId,
+            sessionFile,
+            createdAt: new Date().toISOString(),
+            model: init?.model,
+            activeTools: OPERATOR_CHAT_ACTIVE_TOOL_NAMES(),
+            initializing: true,
+        };
+    }
+    /**
+     * Wait for single-flight materialization. Ready sessions resolve immediately;
+     * failed materialization throws PiSessionInitFailedError.
+     */
+    async ensureSessionReady(sessionId) {
+        const state = this.sessionInit.get(sessionId);
+        if (!state) {
+            if (this.sessions.has(sessionId))
+                return;
+            throw new Error(`chat session not found: ${sessionId}`);
+        }
+        if (state.status === "ready")
+            return;
+        if (state.status === "failed")
+            throw state.error;
+        await state.promise;
+        const next = this.sessionInit.get(sessionId);
+        if (next?.status === "failed")
+            throw next.error;
+        if (this.disposedSessions.has(sessionId) || !this.sessions.has(sessionId)) {
+            throw new Error(`chat session not found: ${sessionId}`);
+        }
+    }
+    startMaterialization(sessionId, init) {
+        const existing = this.sessionInit.get(sessionId);
+        if (existing?.status === "initializing")
+            return existing.promise;
+        if (existing?.status === "ready")
+            return Promise.resolve();
+        if (existing?.status === "failed")
+            return Promise.reject(existing.error);
+        const promise = this.materializeSession(sessionId, init)
+            .then(() => {
+            if (this.disposedSessions.has(sessionId)) {
+                // Late materialization after delete: never register ready state.
+                this.sessionInit.delete(sessionId);
+                return;
+            }
+            this.sessionInit.set(sessionId, { status: "ready" });
+        })
+            .catch((error) => {
+            const failed = new PiSessionInitFailedError(error instanceof Error ? error.message : String(error));
+            if (!this.disposedSessions.has(sessionId)) {
+                this.sessionInit.set(sessionId, { status: "failed", error: failed });
+            }
+            else {
+                this.sessionInit.delete(sessionId);
+            }
+            // Observe rejection so detached create path has no unhandled rejection.
+            process.stderr.write(`[console] chat session init failed (${sessionId}): ${failed.message}\n`);
+        });
+        this.sessionInit.set(sessionId, { status: "initializing", promise });
+        return promise;
+    }
+    async materializeSession(sessionId, init) {
+        if (this.disposedSessions.has(sessionId))
+            return;
+        const agentDir = await safeGetAgentDir(this.bindings);
         const appendSystemPrompt = [
             OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
-            ...(init?.systemPromptSuffix ? [init.systemPromptSuffix] : []),
+            ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
         ];
+        // Single services construction for formal materialization (+ optional
+        // default-model resolve from the same modelRuntime).
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
@@ -710,10 +828,13 @@ export class ConsolePiRuntime {
                 appendSystemPrompt,
             },
         });
+        if (this.disposedSessions.has(sessionId))
+            return;
         const modelRuntime = services.modelRuntime;
-        // Resolve the concrete SDK model only when we have a descriptor. When no
-        // model is resolved (harness unset + no snapshot match), we omit `model`
-        // and let the SDK session use its own default (no hardcoded fallback).
+        let model = init.model;
+        if (!model && init.resolveDefaultModel) {
+            model = await this.resolveDefaultModel(modelRuntime);
+        }
         const resolvedModel = model
             ? (this.bindings.resolveModel({
                 modelRuntime,
@@ -721,61 +842,13 @@ export class ConsolePiRuntime {
                 modelId: model.modelId,
             }) ?? undefined)
             : undefined;
-        const sessionManager = await this.bindings.createSessionManager({
-            cwd: this.options.cwd,
-            sessionDir: this.options.sessionDir,
-            sessionId,
-        });
-        // Gate 1: pin the tool set at session create. assertNoWriteTool guards
-        // that no file-WRITING coding tool slipped into the allowed list (bash
-        // is intentionally allowed since the 2026-07-25 widening).
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
-        // Build custom Pi tools that route whitelisted operator actions into
-        // the dispatcher (Gate 3 lives inside each tool's execute()).
-        let operatorCustomTools = [];
-        if (this.options.actionContext) {
-            try {
-                operatorCustomTools = await buildCustomOperatorTools({
-                    actionContext: this.options.actionContext,
-                });
-            }
-            catch (error) {
-                // If custom-tool build fails (e.g. typebox unavailable), fall back to
-                // a tool-less session — Chat still works as text-only, and the
-                // failure is surfaced via doctor / readiness diagnostics.
-                process.stderr.write(`[console] chat custom-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
-            }
-        }
-        // M0-A: also register the safe explore tools (safe-read / safe-grep /
-        // git-status / git-diff) so the model can probe the repo without bash.
-        let exploreCustomTools = [];
-        try {
-            exploreCustomTools = await buildExploreCustomTools({
-                repoRoot: this.options.cwd,
-            });
-        }
-        catch (error) {
-            process.stderr.write(`[console] chat explore-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-        const customTools = [...operatorCustomTools, ...exploreCustomTools];
-        // Tool surface (roadmap M0):
-        //   - ALL model-callable operator actions are registered as customTools.
-        //   - Safe explore tools (safe-read / safe-grep / git-status / git-diff)
-        //     are also registered as customTools (bash is GONE — M0-A removes
-        //     the write-via-redirect escape).
-        //   - Built-in find/ls are registered by passing `tools:` (Gate 1). The
-        //     default builtin read/bash/edit/write are EXCLUDED: read/bash/grep
-        //     are replaced by the safe custom versions above; edit/write stay
-        //     excluded (file-writing never activated).
-        //     by passing `tools: OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS` (Gate 1).
-        //     This is REQUIRED: the SDK's default builtin set is only
-        //     `read, bash, edit, write` (grep/find/ls are NOT default builtins —
-        //     see SDK CreateAgentSessionOptions.tools docs). Without `tools`, the
+        const customTools = await this.loadCustomTools();
+        if (this.disposedSessions.has(sessionId))
+            return;
         const { session } = await this.bindings.createSessionFromServices({
             services,
-            sessionManager,
-            // Gate 1 (ADR 0011): full Pi builtins registered; only non-Pi write
-            // channels excluded (apply_patch / full-tools / shell / coding-chat).
+            sessionManager: init.sessionManager,
             tools: [...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS],
             excludeTools: [
                 "apply_patch",
@@ -786,30 +859,82 @@ export class ConsolePiRuntime {
                 "coding_chat",
                 "shell",
             ],
-            ...(customTools && customTools.length > 0 ? { customTools } : {}),
+            ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
-        // Gate 2: re-pin active tools (defensive — some SDK paths may seed
-        // defaults). Active set = operator baseline + built-in explore tools +
-        // extension tools registered by user/project extensions (ADR 0012).
-        // Non-Pi write channels are excluded above and cannot appear here.
+        if (this.disposedSessions.has(sessionId)) {
+            try {
+                session.dispose();
+            }
+            catch {
+                // ignore late dispose cleanup
+            }
+            return;
+        }
         session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+        // Register then re-check dispose race: a concurrent dispose must win.
         this.sessions.set(sessionId, session);
-        this.sessionManagers.set(sessionId, sessionManager);
+        this.sessionManagers.set(sessionId, init.sessionManager);
         this.modelRuntimes.set(sessionId, modelRuntime);
+        this.sessionModels.set(sessionId, model);
         this.serviceScopes.set(sessionId, {
             resourceLoader: services.resourceLoader,
             settingsManager: services.settingsManager,
         });
         this.revisions.set(sessionId, 1);
-        this.thinkingSelections.set(sessionId, "auto");
-        return {
-            sessionId,
-            sessionFile: session.sessionFile,
-            createdAt: new Date().toISOString(),
-            model,
-            activeTools: session.getActiveToolNames(),
-        };
+        if (!this.thinkingSelections.has(sessionId)) {
+            this.thinkingSelections.set(sessionId, "auto");
+        }
+        if (this.disposedSessions.has(sessionId)) {
+            try {
+                session.dispose();
+            }
+            catch {
+                // ignore
+            }
+            this.sessions.delete(sessionId);
+            this.sessionManagers.delete(sessionId);
+            this.modelRuntimes.delete(sessionId);
+            this.sessionModels.delete(sessionId);
+            this.serviceScopes.delete(sessionId);
+            this.revisions.delete(sessionId);
+            this.thinkingSelections.delete(sessionId);
+        }
+    }
+    /** Cached session-less custom tool definitions (operator + explore). */
+    async loadCustomTools() {
+        const [operatorCustomTools, exploreCustomTools] = await Promise.all([
+            this.loadOperatorCustomTools(),
+            this.loadExploreCustomTools(),
+        ]);
+        return [...operatorCustomTools, ...exploreCustomTools];
+    }
+    loadOperatorCustomTools() {
+        if (!this.options.actionContext)
+            return Promise.resolve([]);
+        if (!this.operatorCustomToolsPromise) {
+            this.operatorCustomToolsPromise = buildCustomOperatorTools({
+                actionContext: this.options.actionContext,
+            }).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.operatorCustomToolsPromise = undefined;
+                return [];
+            });
+        }
+        return this.operatorCustomToolsPromise;
+    }
+    loadExploreCustomTools() {
+        if (!this.exploreCustomToolsPromise) {
+            this.exploreCustomToolsPromise = buildExploreCustomTools({
+                repoRoot: this.options.cwd,
+            }).catch((error) => {
+                process.stderr.write(`[console] chat explore-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                this.exploreCustomToolsPromise = undefined;
+                return [];
+            });
+        }
+        return this.exploreCustomToolsPromise;
     }
     async forkSession(init) {
         if (!this.bindings.forkSessionManager)
@@ -829,9 +954,11 @@ export class ConsolePiRuntime {
         this.sessions.set(sessionId, built.session);
         this.sessionManagers.set(sessionId, sessionManager);
         this.modelRuntimes.set(sessionId, built.modelRuntime);
+        this.sessionModels.set(sessionId, init.model);
         this.serviceScopes.set(sessionId, built.services);
         this.revisions.set(sessionId, 1);
         this.thinkingSelections.set(sessionId, "auto");
+        this.sessionInit.set(sessionId, { status: "ready" });
         return {
             sessionId,
             sessionFile: built.session.sessionFile,
@@ -876,12 +1003,14 @@ export class ConsolePiRuntime {
         };
     }
     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}`);
         return this.bindings.listAvailableModels({ modelRuntime });
     }
     async applyModel(sessionId, model) {
+        await this.ensureSessionReady(sessionId);
         const session = this.sessions.get(sessionId);
         const modelRuntime = this.modelRuntimes.get(sessionId);
         if (!session || !modelRuntime)
@@ -908,6 +1037,12 @@ export class ConsolePiRuntime {
      * level calls `session.setThinkingLevel`. Returns the effective value.
      */
     applyThinkingLevel(sessionId, level) {
+        const state = this.sessionInit.get(sessionId);
+        if (state?.status === "failed")
+            throw state.error;
+        if (state?.status === "initializing") {
+            throw new Error(`chat session not active: ${sessionId}`);
+        }
         const session = this.sessions.get(sessionId);
         if (!session)
             throw new Error(`chat session not active: ${sessionId}`);
@@ -927,8 +1062,9 @@ export class ConsolePiRuntime {
         const session = this.sessions.get(sessionId);
         if (!session)
             return { activeTools: [] };
-        const provider = session.model?.provider;
-        const modelId = session.model?.id ?? session.model?.modelId;
+        const stored = this.sessionModels.get(sessionId);
+        const provider = session.model?.provider ?? stored?.provider;
+        const modelId = session.model?.id ?? session.model?.modelId ?? stored?.modelId;
         return {
             ...(provider && modelId ? { model: { provider, modelId } } : {}),
             ...(session.thinkingLevel
@@ -947,6 +1083,7 @@ export class ConsolePiRuntime {
      * composed operator-chat base prompt. Never returns empty.
      */
     async getRuntimeSystemPrompt(sessionId) {
+        await this.ensureSessionReady(sessionId).catch(() => undefined);
         const session = this.sessions.get(sessionId);
         if (!session)
             return composeOperatorChatSystemPrompt({});
@@ -978,6 +1115,19 @@ export class ConsolePiRuntime {
      * duplicate reload) — never aborts, never silently queues.
      */
     async reloadSession(sessionId) {
+        try {
+            await this.ensureSessionReady(sessionId);
+        }
+        catch (error) {
+            if (error instanceof PiSessionInitFailedError) {
+                return { ok: false, code: error.code, message: error.message };
+            }
+            return {
+                ok: false,
+                code: "PI_SESSION_NOT_FOUND",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
         const session = this.sessions.get(sessionId);
         if (!session) {
             return {
@@ -1049,6 +1199,15 @@ export class ConsolePiRuntime {
      * session is not active — callers fail closed instead of fabricating data.
      */
     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 session = this.sessions.get(sessionId);
         if (!session)
             return undefined;
@@ -1316,6 +1475,24 @@ export class ConsolePiRuntime {
      */
     async reopenSession(init) {
         const sessionId = init.sessionId;
+        // Wait for in-flight create materialization rather than racing reopen.
+        const initState = this.sessionInit.get(sessionId);
+        if (initState?.status === "initializing") {
+            try {
+                await initState.promise;
+            }
+            catch {
+                // failure recorded on sessionInit
+            }
+        }
+        const failed = this.sessionInit.get(sessionId);
+        if (failed?.status === "failed") {
+            return {
+                ok: false,
+                code: "PI_SESSION_INIT_FAILED",
+                message: failed.error.message,
+            };
+        }
         // Already active in-memory: idempotent reopen is a no-op success.
         if (this.sessions.has(sessionId)) {
             return { ok: true, handle: await this.snapshotActive(sessionId) };
@@ -1386,9 +1563,11 @@ export class ConsolePiRuntime {
             this.sessions.set(sessionId, session);
             this.sessionManagers.set(sessionId, sessionManager);
             this.modelRuntimes.set(sessionId, built.modelRuntime);
+            this.sessionModels.set(sessionId, init.model);
             this.serviceScopes.set(sessionId, built.services);
             this.revisions.set(sessionId, 1);
             this.thinkingSelections.set(sessionId, "auto");
+            this.sessionInit.set(sessionId, { status: "ready" });
             return {
                 ok: true,
                 handle: {
@@ -1411,19 +1590,29 @@ export class ConsolePiRuntime {
     /** Build a handle for an already-active session (idempotent reopen path). */
     async snapshotActive(sessionId) {
         const session = this.sessions.get(sessionId);
+        const stored = this.sessionModels.get(sessionId);
+        const fromSession = session.model?.provider
+            ? {
+                provider: session.model.provider,
+                modelId: session.model.id ??
+                    session.model.modelId ??
+                    "",
+            }
+            : undefined;
+        const model = stored ??
+            (fromSession?.modelId ? fromSession : undefined);
         return {
             sessionId,
             sessionFile: session.sessionFile,
             createdAt: new Date().toISOString(),
-            model: undefined,
+            model,
             activeTools: session.getActiveToolNames(),
         };
     }
     /**
-     * Shared services + pinned-tool materialization for both createSession and
-     * reopenSession. Loads closed-surface services, resolves the model, builds
-     * the operator + safe explore customTools, and calls the SDK with the same
-     * excludeTools / tools policy (M0-A three-gate).
+     * Shared services + pinned-tool materialization for reopen/fork paths.
+     * Create uses startMaterialization instead so the durable shell can return
+     * before AgentSession is ready. Tool definitions reuse runtime-level caches.
      */
     async buildSessionWithServices(init) {
         const agentDir = await safeGetAgentDir(this.bindings);
@@ -1447,27 +1636,7 @@ export class ConsolePiRuntime {
             }) ?? undefined)
             : undefined;
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
-        let operatorCustomTools = [];
-        if (this.options.actionContext) {
-            try {
-                operatorCustomTools = await buildCustomOperatorTools({
-                    actionContext: this.options.actionContext,
-                });
-            }
-            catch (error) {
-                process.stderr.write(`[console] chat custom-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
-            }
-        }
-        let exploreCustomTools = [];
-        try {
-            exploreCustomTools = await buildExploreCustomTools({
-                repoRoot: this.options.cwd,
-            });
-        }
-        catch (error) {
-            process.stderr.write(`[console] chat explore-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-        const customTools = [...operatorCustomTools, ...exploreCustomTools];
+        const customTools = await this.loadCustomTools();
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
@@ -1481,7 +1650,7 @@ export class ConsolePiRuntime {
                 "coding_chat",
                 "shell",
             ],
-            ...(customTools && customTools.length > 0 ? { customTools } : {}),
+            ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
         return {
@@ -1506,6 +1675,8 @@ export class ConsolePiRuntime {
      * (the dispatcher is wired by the HTTP layer, see chat-session.ts).
      */
     async prompt(sessionId, text, onEvent, options) {
+        // First message while creating waits on the same materialization promise.
+        await this.ensureSessionReady(sessionId);
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new Error(`chat session not found: ${sessionId}`);
@@ -1575,6 +1746,92 @@ export class ConsolePiRuntime {
             unsub();
         }
     }
+    /** Generate exactly one title in an isolated in-memory, tool-less LOW session. */
+    async generateTitle(sessionId, firstUserText) {
+        if (this.titleInFlight.has(sessionId))
+            return undefined;
+        this.titleInFlight.add(sessionId);
+        let session;
+        let unsubscribe;
+        let timeout;
+        try {
+            const { services } = await this.bindings.createServices({
+                cwd: this.options.cwd,
+                agentDir: await safeGetAgentDir(this.bindings),
+                // The detached title worker has a closed title-only resource surface:
+                // no project/user context, extensions, skills, prompt templates, or
+                // themes. Its sole system prompt is deliberately minimal; never append
+                // the operator-chat prompt or any loaded resource text.
+                resourceLoaderOptions: {
+                    noContextFiles: true,
+                    noSkills: true,
+                    noExtensions: true,
+                    noPromptTemplates: true,
+                    noThemes: true,
+                    systemPrompt: "Generate one concise plain-text session title in the user's primary language. Return only the title.",
+                },
+            });
+            const low = await resolveLowChatModel(this.options.cwd, this.bindings.listAvailableModels({ modelRuntime: services.modelRuntime }));
+            if (!low)
+                return undefined;
+            const model = this.bindings.resolveModel({
+                modelRuntime: services.modelRuntime,
+                provider: low.provider,
+                modelId: low.modelId,
+            });
+            if (!model)
+                return undefined;
+            if (!this.bindings.createInMemorySessionManager)
+                return undefined;
+            const sessionManager = await this.bindings.createInMemorySessionManager({
+                cwd: this.options.cwd,
+            });
+            const created = await this.bindings.createSessionFromServices({
+                services,
+                sessionManager,
+                noTools: "all",
+                tools: [],
+                customTools: [],
+                model,
+            });
+            session = created.session;
+            let output = "";
+            unsubscribe = session.subscribe((event) => {
+                if (event.type === "message_end")
+                    output = extractAssistantText(event.message);
+            });
+            const controller = new AbortController();
+            timeout = setTimeout(() => controller.abort(), 10_000);
+            await Promise.race([
+                session.prompt(`User message:\n${firstUserText.slice(0, 1200)}`, { signal: controller.signal }),
+                new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(new Error("TITLE_TIMEOUT")), { once: true })),
+            ]);
+            return output;
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            unsubscribe?.();
+            try {
+                await session?.abort?.();
+            }
+            catch { /* abort converges before disposal */ }
+            try {
+                session?.dispose();
+            }
+            catch { /* isolated title cleanup is best-effort */ }
+            this.titleInFlight.delete(sessionId);
+        }
+    }
+    /** Pi session_info mirror after durable automatic-title persistence.
+     * Callers own the detached catch boundary so synchronous throws and rejected
+     * mirror Promises are both observed without affecting durable Chat state. */
+    async setSessionName(sessionId, title) {
+        await this.sessions.get(sessionId)?.setSessionName?.(title);
+    }
     async compact(sessionId, customInstructions) {
         const session = this.sessions.get(sessionId);
         if (!session)
@@ -1587,6 +1844,9 @@ export class ConsolePiRuntime {
         return projectCompactSnapshot(result ?? {});
     }
     dispose(sessionId) {
+        // Mark disposed first so a late materialization never registers ready.
+        this.disposedSessions.add(sessionId);
+        this.sessionInit.delete(sessionId);
         const session = this.sessions.get(sessionId);
         if (session) {
             try {
@@ -1595,15 +1855,16 @@ export class ConsolePiRuntime {
             catch {
                 // ignore
             }
-            this.sessions.delete(sessionId);
-            this.sessionManagers.delete(sessionId);
-            this.mainlineLeaves.delete(sessionId);
-            this.modelRuntimes.delete(sessionId);
-            this.serviceScopes.delete(sessionId);
-            this.revisions.delete(sessionId);
-            this.thinkingSelections.delete(sessionId);
-            this.reloadInFlight.delete(sessionId);
         }
+        this.sessions.delete(sessionId);
+        this.sessionManagers.delete(sessionId);
+        this.mainlineLeaves.delete(sessionId);
+        this.modelRuntimes.delete(sessionId);
+        this.sessionModels.delete(sessionId);
+        this.serviceScopes.delete(sessionId);
+        this.revisions.delete(sessionId);
+        this.thinkingSelections.delete(sessionId);
+        this.reloadInFlight.delete(sessionId);
     }
     disposeAll() {
         for (const id of [...this.sessions.keys()])
@@ -1753,6 +2014,10 @@ export function createDefaultPiSdkBindings() {
                 id: opts.sessionId,
             });
         },
+        createInMemorySessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.inMemory(opts.cwd);
+        },
         forkSessionManager: async (opts) => {
             const sdk = (await loadSdk());
             return sdk.SessionManager.forkFrom(opts.sourcePath, opts.targetCwd, opts.targetSessionDir, { id: opts.targetSessionId });