specrails-desktop 2.29.1 → 2.29.2

package/server/dist/agent-chat-manager.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentChatManager = void 0;
 exports.sanitizeAgentTitle = sanitizeAgentTitle;
 const crypto_1 = require("crypto");
 const readline_1 = require("readline");
 const os_1 = require("os");
+const tree_kill_1 = __importDefault(require("tree-kill"));
 const providers_1 = require("./providers");
 const spawn_lifecycle_1 = require("./spawn-lifecycle");
 const cli_prompt_1 = require("./util/cli-prompt");
@@ -14,11 +18,11 @@ const agent_cwd_manager_1 = require("./agent-cwd-manager");
 const agent_operator_prompt_1 = require("./agent-operator-prompt");
 const agent_mcp_config_1 = require("./agent-mcp-config");
 const agent_tier_1 = require("./agent-tier");
+const agent_capability_1 = require("./mcp/agent-capability");
 const attachment_manager_1 = require("./attachment-manager");
 const agent_context_resolver_1 = require("./agent-context-resolver");
 const agent_store_1 = require("./agent-store");
 const explore_draft_title_1 = require("./explore-draft-title");
-const types_1 = require("./mcp/tools/types");
 class AgentChatManager {
     _broadcast;
     _db;
@@ -39,19 +43,89 @@ class AgentChatManager {
      *  shutdown() can tree-kill them instead of orphaning them. Self-removed on
      *  'close'/'error'. */
     _auxProcesses = new Set();
+    _auxReaders = new Map();
+    _terminationTimers = new Map();
+    /** Permanent lifecycle gate: the app DB may be closed immediately after
+     * shutdown, so no delayed turn/title/card callback may touch it afterwards. */
+    _disposed = false;
+    _resolveDisposed;
+    _disposedSignal = new Promise((resolve) => {
+        this._resolveDisposed = resolve;
+    });
     constructor(broadcast, db, port, registry) {
         this._broadcast = broadcast;
         this._db = db;
         this._port = port;
         this._registry = registry ?? null;
     }
+    async _awaitWhileLive(work) {
+        if (this._disposed)
+            return { disposed: true };
+        return Promise.race([
+            work.then((value) => ({ disposed: false, value })),
+            this._disposedSignal.then(() => ({ disposed: true })),
+        ]);
+    }
+    /** Own a dedicated POSIX process group so descendants remain killable after
+     * the root CLI exits. Windows tree termination is provided by taskkill /T /F. */
+    _spawnOwned(binary, args, options = {}) {
+        if (process.platform === 'win32')
+            return (0, cli_prompt_1.spawnAiCli)(binary, args, options);
+        return (0, cli_prompt_1.spawnAiCli)(binary, args, { ...options, detached: true });
+    }
+    _terminate(child) {
+        if (this._terminationTimers.has(child))
+            return;
+        try {
+            if (!child.pid) {
+                child.kill('SIGTERM');
+                return;
+            }
+            const pid = child.pid;
+            (0, tree_kill_1.default)(pid, 'SIGTERM');
+            const timer = setTimeout(() => {
+                this._terminationTimers.delete(child);
+                if (process.platform !== 'win32') {
+                    try {
+                        process.kill(-pid, 'SIGKILL');
+                    }
+                    catch { /* group already gone */ }
+                }
+                else {
+                    try {
+                        (0, tree_kill_1.default)(pid, 'SIGKILL', () => { });
+                    }
+                    catch { /* gone */ }
+                }
+            }, 2000);
+            timer.unref?.();
+            this._terminationTimers.set(child, timer);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+    _closeChildIo(child) {
+        try {
+            child.stdin?.destroy();
+        }
+        catch { /* best-effort */ }
+        try {
+            child.stdout?.destroy();
+        }
+        catch { /* best-effort */ }
+        try {
+            child.stderr?.destroy();
+        }
+        catch { /* best-effort */ }
+    }
     /** True while a turn is streaming for this conversation. */
     isStreaming(conversationId) {
-        return this._active.has(conversationId);
+        return !this._disposed && this._active.has(conversationId);
     }
     /** True while a turn is in flight (spawned or reserved) — a send now queues. */
     isBusy(conversationId) {
-        return this._active.has(conversationId) || this._reserved.has(conversationId);
+        return !this._disposed && (this._active.has(conversationId) || this._reserved.has(conversationId));
     }
     /**
      * Runs one agent turn: persists the user message, spawns the AI CLI pointed at
@@ -64,6 +138,8 @@ class AgentChatManager {
      * Queued turns drain FIFO after the current turn settles; abort discards them.
      */
     async sendMessage(conversationId, userText, options = {}) {
+        if (this._disposed)
+            return;
         const conversation = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
         if (!conversation) {
             this._emitError(conversationId, 'Unknown conversation');
@@ -91,6 +167,8 @@ class AgentChatManager {
             // Drain messages queued while we were running. Each drained turn re-reads
             // the conversation row so a mid-flight tier/provider/model change applies.
             for (;;) {
+                if (this._disposed)
+                    break;
                 const pending = this._queue.get(conversationId);
                 const next = pending?.shift();
                 if (!next)
@@ -100,6 +178,8 @@ class AgentChatManager {
                 const conv = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
                 if (!conv)
                     break; // deleted mid-drain (abort() already cleared the queue)
+                if (this._disposed)
+                    break;
                 this._broadcast({
                     type: 'agent_dequeued',
                     conversationId,
@@ -123,11 +203,15 @@ class AgentChatManager {
             await this._runTurn(conversation, userText, options);
         }
         catch (err) {
+            if (this._disposed)
+                return;
             console.error(`[agent-chat] turn failed (${conversation.id}):`, err);
             this._emitError(conversation.id, err instanceof Error ? err.message : 'The agent turn failed.');
         }
     }
     async _runTurn(conversation, userText, options) {
+        if (this._disposed)
+            return;
         const conversationId = conversation.id;
         const tierLevel = (0, agent_tier_1.normalizeLevel)(options.tierLevel ?? conversation.tier_level);
         const adapter = (0, providers_1.getAdapter)(conversation.provider);
@@ -146,10 +230,6 @@ class AgentChatManager {
         const reasoningEffort = efforts.length
             ? (storedEffort && efforts.includes(storedEffort) ? storedEffort : 'medium')
             : undefined;
-        // Make the pinned project (Cursor-style selector) the MCP active project for
-        // this turn, so project-scoped tools resolve without the agent having to call
-        // specrails_select_project. Home (null) clears it → app-global mode.
-        (0, types_1.setActiveProject)(conversation.pinned_project_id ?? null);
         // Resolve attachments (conversation-keyed) into extracted text blocks +
         // absolute image paths. Extraction failure degrades to a text-only turn.
         const attachmentIds = options.attachmentIds ?? [];
@@ -158,7 +238,10 @@ class AgentChatManager {
         let hasAttachments = false;
         if (attachmentIds.length > 0) {
             try {
-                const resolved = await attachment_manager_1.attachmentManager.getClaudeArgsAgent(conversationId, attachmentIds);
+                const attachmentResult = await this._awaitWhileLive(attachment_manager_1.attachmentManager.getClaudeArgsAgent(conversationId, attachmentIds));
+                if (attachmentResult.disposed)
+                    return;
+                const resolved = attachmentResult.value;
                 if (resolved.textBlocks.length > 0) {
                     userWithAttachments = `${userText}\n\n## Attached Resources\n\n${resolved.textBlocks.join('\n\n')}`;
                     hasAttachments = true;
@@ -166,9 +249,13 @@ class AgentChatManager {
                 imagePaths = resolved.imagePaths;
             }
             catch (err) {
+                if (this._disposed)
+                    return;
                 console.error(`[agent-chat] attachment extraction failed (${conversationId}):`, err);
             }
         }
+        if (this._disposed)
+            return;
         const contextBlock = (0, agent_context_resolver_1.buildResolvedAgentContextBlock)(options.contextRefs ?? [], {
             desktopDb: this._db,
             registry: this._registry,
@@ -202,142 +289,169 @@ class AgentChatManager {
         // Only pass native image paths to providers that can vision-load them (codex
         // `--image`); claude/gemini already have the `@path` ref folded into prompt.
         const spawnImagePaths = adapter.capabilities.supportsImageInput ? imagePaths : undefined;
-        const cwd = (0, agent_cwd_manager_1.ensureAgentCwd)();
-        let mcpArgs = [];
-        let mcpEnv = {};
+        const agentCapability = (0, agent_capability_1.mintAgentCapability)({
+            conversationId,
+            projectId: conversation.pinned_project_id,
+            tierLevel,
+        });
         try {
-            const wiring = (0, agent_mcp_config_1.prepareAgentMcp)({
-                adapterId: adapter.id,
-                conversationId,
-                cwd,
-                port: this._port,
-                tierLevel,
-                activeProjectId: conversation.pinned_project_id,
-            });
-            mcpArgs = wiring.extraArgs;
-            mcpEnv = wiring.env;
-        }
-        catch (err) {
-            // A bad conversation id or fs failure shouldn't poison the chat — run tool-less.
-            console.error('[agent-chat] failed to prepare mcp:', err);
-        }
-        const timestamp = () => new Date().toISOString();
-        const invoke = async (useResume) => {
-            const action = useResume ? 'chat-resume' : 'chat-turn';
-            const startedAt = new Date().toISOString();
-            let streamed = '';
-            let capturedSessionId = useResume ? conversation.session_id ?? null : null;
-            let capturedError = null;
-            console.log(`[agent-chat] turn start conv=${conversationId} provider=${adapter.id} binary=${adapter.binary} ` +
-                `action=${action} model=${model} cwd=${cwd} mcp=${mcpArgs.length ? 'mcp-config' : Object.keys(mcpEnv).join(',') || 'none'}`);
-            const result = await (0, spawn_lifecycle_1.runAiCliInvocation)({
-                adapter,
-                action,
-                cwd,
-                env: { ...process.env, ...mcpEnv },
-                buildOpts: {
-                    prompt,
-                    systemPrompt: adapter.capabilities.systemPromptArg ? systemPrompt : undefined,
-                    model,
-                    sessionId: useResume ? conversation.session_id ?? undefined : undefined,
-                    extraArgs: mcpArgs,
-                    imagePaths: spawnImagePaths,
-                    reasoning_effort: reasoningEffort,
-                },
-                onSpawn: (child) => {
-                    this._active.set(conversationId, child);
-                },
-                onEvent: (ev) => {
-                    switch (ev.kind) {
-                        case 'text-delta':
-                            streamed += ev.text;
-                            // A killed child (abort / conversation DELETE) keeps flushing its
-                            // buffered stdout — suppress the broadcasts once it left _active
-                            // so stragglers can't resurrect client-side streaming state.
-                            if (this._active.has(conversationId)) {
-                                this._broadcast({ type: 'agent_stream', conversationId, delta: ev.text, timestamp: timestamp() });
-                            }
-                            break;
-                        case 'tool-use':
-                            if (this._active.has(conversationId)) {
-                                this._broadcast({ type: 'agent_tool', conversationId, tool: ev.name, timestamp: timestamp() });
-                            }
-                            break;
-                        case 'session-started':
-                            if (ev.sessionId)
-                                capturedSessionId = ev.sessionId;
-                            break;
-                        case 'result': {
-                            const sid = ev.payload.session_id;
-                            if (sid)
-                                capturedSessionId = sid;
-                            break;
-                        }
-                        case 'error':
-                            capturedError = ev.message;
-                            break;
-                        case 'other':
-                            break;
-                    }
-                },
-            });
-            this._active.delete(conversationId);
-            const text = streamed.trim();
-            console.log(`[agent-chat] turn end conv=${conversationId} provider=${adapter.id} code=${result.code} ` +
-                `spawnFailed=${result.spawnFailed} chars=${text.length} err=${capturedError ?? ''}`);
-            if (result.stderrTail && (result.spawnFailed || (result.code ?? 0) !== 0 || !text)) {
-                console.error(`[agent-chat] ${adapter.id} stderr:\n${result.stderrTail}`);
-            }
-            return { text, sessionId: capturedSessionId, error: capturedError, code: result.code, spawnFailed: result.spawnFailed, stderrTail: result.stderrTail, events: result.events, startedAt };
-        };
-        // Conversation CONFIG (provider/model/tier) is owned by the PATCH route —
-        // never write turn-START snapshots back at settle, or a mid-turn provider
-        // switch would be silently reverted and a queued turn drained onto the old
-        // provider. Only the session id persists, and only while the row's provider
-        // is still the one this turn actually ran on (a foreign session id must not
-        // pollute the new provider's freshly-reset state).
-        const persistSession = (sessionId) => {
-            const fresh = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
-            if (fresh && fresh.provider === conversation.provider) {
-                (0, agent_store_1.updateAgentConversation)(this._db, conversationId, { session_id: sessionId });
+            // Gemini discovers MCP registration from project files under cwd. A
+            // shared cwd would let two concurrent conversations race on `.mcp.json`
+            // / `.gemini/settings.json` and launch with the other's capability.
+            // Claude and Codex keep their historical global cwd and explicit MCP
+            // registration mechanisms unchanged.
+            const cwd = adapter.id === 'gemini'
+                ? (0, agent_cwd_manager_1.ensureAgentConversationCwd)(conversationId)
+                : (0, agent_cwd_manager_1.ensureAgentCwd)();
+            let mcpArgs = [];
+            let mcpEnv = {};
+            try {
+                const wiring = (0, agent_mcp_config_1.prepareAgentMcp)({
+                    adapterId: adapter.id,
+                    conversationId,
+                    cwd,
+                    port: this._port,
+                    capability: agentCapability,
+                });
+                mcpArgs = wiring.extraArgs;
+                mcpEnv = wiring.env;
             }
-        };
-        const settleAborted = (r) => {
-            // Deliberate user Stop: keep any partial text (it was already streamed to
-            // the client), never auto-heal, never surface an error.
-            if (r.text && (0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
-                (0, agent_store_1.addAgentMessage)(this._db, { conversationId, role: 'assistant', content: r.text });
-                persistSession(r.sessionId);
-                this._broadcast({ type: 'agent_done', conversationId, fullText: r.text, timestamp: timestamp() });
+            catch (err) {
+                // A bad conversation id or fs failure shouldn't poison the chat — run tool-less.
+                console.error('[agent-chat] failed to prepare mcp:', err);
             }
-        };
-        // Cost accounting (HIGH-3): exactly one row per settled turn, whichever
-        // terminal branch we exit through. `pinned_project_id` is captured at turn
-        // start (NULL = Home / app-global).
-        const record = (outcome, status) => {
-            this._recordTurn(conversation, adapter, model, outcome, status);
-        };
-        const canResume = !!conversation.session_id && adapter.capabilities.nativeResume;
-        let r = await invoke(canResume);
-        // Deleted mid-turn (DELETE aborts the child and drops the row): stop here —
-        // no auto-heal respawn, no FK-violating assistant INSERT. The spawn still
-        // billed, so record it (aborted) before returning.
-        if (!(0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
-            record(r, 'aborted');
-            return;
-        }
-        if (this._abortedTurns.delete(conversationId)) {
-            settleAborted(r);
-            record(r, 'aborted');
-            return;
-        }
-        // Auto-heal a stale/foreign session: a resume that produced no text (e.g. a
-        // provider switch leaving another provider's session id, or codex
-        // "no rollout found for thread id") retries once as a fresh turn.
-        if (canResume && !r.spawnFailed && !r.text) {
-            console.log(`[agent-chat] resume produced no text — retrying fresh conv=${conversationId}`);
-            (0, agent_store_1.updateAgentConversation)(this._db, conversationId, { session_id: null });
-            r = await invoke(false);
+            const timestamp = () => new Date().toISOString();
+            const invoke = async (useResume) => {
+                const action = useResume ? 'chat-resume' : 'chat-turn';
+                const startedAt = new Date().toISOString();
+                let streamed = '';
+                let capturedSessionId = useResume ? conversation.session_id ?? null : null;
+                let capturedError = null;
+                console.log(`[agent-chat] turn start conv=${conversationId} provider=${adapter.id} binary=${adapter.binary} ` +
+                    `action=${action} model=${model} cwd=${cwd} mcp=${mcpArgs.length ? 'mcp-config' : Object.keys(mcpEnv).join(',') || 'none'}`);
+                const invocation = this._awaitWhileLive((0, spawn_lifecycle_1.runAiCliInvocation)({
+                    adapter,
+                    action,
+                    cwd,
+                    env: { ...process.env, ...mcpEnv },
+                    spawn: this._spawnOwned.bind(this),
+                    buildOpts: {
+                        prompt,
+                        systemPrompt: adapter.capabilities.systemPromptArg ? systemPrompt : undefined,
+                        model,
+                        sessionId: useResume ? conversation.session_id ?? undefined : undefined,
+                        extraArgs: mcpArgs,
+                        imagePaths: spawnImagePaths,
+                        reasoning_effort: reasoningEffort,
+                    },
+                    onSpawn: (child) => {
+                        if (this._disposed) {
+                            this._terminate(child);
+                            return;
+                        }
+                        this._active.set(conversationId, child);
+                    },
+                    onEvent: (ev) => {
+                        if (this._disposed)
+                            return;
+                        switch (ev.kind) {
+                            case 'text-delta':
+                                streamed += ev.text;
+                                // A killed child (abort / conversation DELETE) keeps flushing its
+                                // buffered stdout — suppress the broadcasts once it left _active
+                                // so stragglers can't resurrect client-side streaming state.
+                                if (this._active.has(conversationId)) {
+                                    this._broadcast({ type: 'agent_stream', conversationId, delta: ev.text, timestamp: timestamp() });
+                                }
+                                break;
+                            case 'tool-use':
+                                if (this._active.has(conversationId)) {
+                                    this._broadcast({ type: 'agent_tool', conversationId, tool: ev.name, timestamp: timestamp() });
+                                }
+                                break;
+                            case 'session-started':
+                                if (ev.sessionId)
+                                    capturedSessionId = ev.sessionId;
+                                break;
+                            case 'result': {
+                                const sid = ev.payload.session_id;
+                                if (sid)
+                                    capturedSessionId = sid;
+                                break;
+                            }
+                            case 'error':
+                                capturedError = ev.message;
+                                break;
+                            case 'other':
+                                break;
+                        }
+                    },
+                }));
+                const invocationResult = await invocation;
+                if (invocationResult.disposed) {
+                    this._active.delete(conversationId);
+                    return {
+                        disposed: true,
+                        text: '',
+                        sessionId: capturedSessionId,
+                        error: null,
+                        code: null,
+                        spawnFailed: false,
+                        stderrTail: '',
+                        events: [],
+                        startedAt,
+                    };
+                }
+                const result = invocationResult.value;
+                this._active.delete(conversationId);
+                const text = streamed.trim();
+                console.log(`[agent-chat] turn end conv=${conversationId} provider=${adapter.id} code=${result.code} ` +
+                    `spawnFailed=${result.spawnFailed} chars=${text.length} err=${capturedError ?? ''}`);
+                if (result.stderrTail && (result.spawnFailed || (result.code ?? 0) !== 0 || !text)) {
+                    console.error(`[agent-chat] ${adapter.id} stderr:\n${result.stderrTail}`);
+                }
+                return { disposed: false, text, sessionId: capturedSessionId, error: capturedError, code: result.code, spawnFailed: result.spawnFailed, stderrTail: result.stderrTail, events: result.events, startedAt };
+            };
+            // Conversation CONFIG (provider/model/tier) is owned by the PATCH route —
+            // never write turn-START snapshots back at settle, or a mid-turn provider
+            // switch would be silently reverted and a queued turn drained onto the old
+            // provider. Only the session id persists, and only while the row's provider
+            // is still the one this turn actually ran on (a foreign session id must not
+            // pollute the new provider's freshly-reset state).
+            const persistSession = (sessionId) => {
+                if (this._disposed)
+                    return;
+                const fresh = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
+                if (fresh && fresh.provider === conversation.provider) {
+                    (0, agent_store_1.updateAgentConversation)(this._db, conversationId, { session_id: sessionId });
+                }
+            };
+            const settleAborted = (r) => {
+                if (this._disposed)
+                    return;
+                // Deliberate user Stop: keep any partial text (it was already streamed to
+                // the client), never auto-heal, never surface an error.
+                if (r.text && (0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
+                    (0, agent_store_1.addAgentMessage)(this._db, { conversationId, role: 'assistant', content: r.text });
+                    persistSession(r.sessionId);
+                    this._broadcast({ type: 'agent_done', conversationId, fullText: r.text, timestamp: timestamp() });
+                }
+            };
+            // Cost accounting (HIGH-3): exactly one row per settled turn, whichever
+            // terminal branch we exit through. `pinned_project_id` is captured at turn
+            // start (NULL = Home / app-global).
+            const record = (outcome, status) => {
+                if (this._disposed || outcome.disposed)
+                    return;
+                this._recordTurn(conversation, adapter, model, outcome, status);
+            };
+            const canResume = !!conversation.session_id && adapter.capabilities.nativeResume;
+            let r = await invoke(canResume);
+            if (this._disposed || r.disposed)
+                return;
+            // Deleted mid-turn (DELETE aborts the child and drops the row): stop here —
+            // no auto-heal respawn, no FK-violating assistant INSERT. The spawn still
+            // billed, so record it (aborted) before returning.
             if (!(0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
                 record(r, 'aborted');
                 return;
@@ -347,31 +461,54 @@ class AgentChatManager {
                 record(r, 'aborted');
                 return;
             }
-        }
-        if (r.spawnFailed) {
-            this._emitError(conversationId, `Failed to launch ${adapter.binary}. Is it installed and on PATH?`);
+            // Auto-heal a stale/foreign session: a resume that produced no text (e.g. a
+            // provider switch leaving another provider's session id, or codex
+            // "no rollout found for thread id") retries once as a fresh turn.
+            if (canResume && !r.spawnFailed && !r.text) {
+                console.log(`[agent-chat] resume produced no text — retrying fresh conv=${conversationId}`);
+                (0, agent_store_1.updateAgentConversation)(this._db, conversationId, { session_id: null });
+                r = await invoke(false);
+                if (this._disposed || r.disposed)
+                    return;
+                if (!(0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
+                    record(r, 'aborted');
+                    return;
+                }
+                if (this._abortedTurns.delete(conversationId)) {
+                    settleAborted(r);
+                    record(r, 'aborted');
+                    return;
+                }
+            }
+            if (r.spawnFailed) {
+                this._emitError(conversationId, `Failed to launch ${adapter.binary}. Is it installed and on PATH?`);
+                record(r, 'failed');
+                return;
+            }
+            if (r.text) {
+                (0, agent_store_1.addAgentMessage)(this._db, { conversationId, role: 'assistant', content: r.text });
+                persistSession(r.sessionId);
+                this._broadcast({ type: 'agent_done', conversationId, fullText: r.text, timestamp: timestamp() });
+                record(r, 'success');
+                // AI title after the FIRST completed turn (industry standard — ChatGPT /
+                // Claude.ai), on the conversation's own provider. The deterministic title
+                // set at send stays the instant fallback; this upgrades it a moment later.
+                this._maybeAiTitle(conversation, userText, r.text);
+                return;
+            }
+            // Failure: reset the session so the NEXT turn starts fresh, and surface the
+            // real reason instead of silently doing nothing.
+            persistSession(null);
+            const reason = r.error ||
+                (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
+                (r.code !== 0 ? `${adapter.binary} exited with code ${r.code}` : 'The agent returned no output.');
+            this._emitError(conversationId, reason);
             record(r, 'failed');
-            return;
         }
-        if (r.text) {
-            (0, agent_store_1.addAgentMessage)(this._db, { conversationId, role: 'assistant', content: r.text });
-            persistSession(r.sessionId);
-            this._broadcast({ type: 'agent_done', conversationId, fullText: r.text, timestamp: timestamp() });
-            record(r, 'success');
-            // AI title after the FIRST completed turn (industry standard — ChatGPT /
-            // Claude.ai), on the conversation's own provider. The deterministic title
-            // set at send stays the instant fallback; this upgrades it a moment later.
-            this._maybeAiTitle(conversation, userText, r.text);
-            return;
+        finally {
+            (0, agent_capability_1.revokeAgentCapability)(agentCapability);
+            (0, agent_mcp_config_1.removeAgentCapabilityFile)(conversationId);
         }
-        // Failure: reset the session so the NEXT turn starts fresh, and surface the
-        // real reason instead of silently doing nothing.
-        persistSession(null);
-        const reason = r.error ||
-            (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
-            (r.code !== 0 ? `${adapter.binary} exited with code ${r.code}` : 'The agent returned no output.');
-        this._emitError(conversationId, reason);
-        record(r, 'failed');
     }
     /**
      * Finalise one agent-chat turn's billable accounting (COST-ACCOUNTING-AUDIT
@@ -383,6 +520,8 @@ class AgentChatManager {
      * turns carry no projectId, so no per-project dashboard to invalidate).
      */
     _recordTurn(conversation, adapter, model, outcome, status) {
+        if (this._disposed)
+            return;
         try {
             const { result, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, outcome.events, {
                 fallbackModel: model,
@@ -414,6 +553,8 @@ class AgentChatManager {
      * `agent_title` so the sidebar list updates live.
      */
     _autoTitle(conversationId, currentTitle) {
+        if (this._disposed)
+            return;
         try {
             const userMsgs = (0, agent_store_1.listAgentMessages)(this._db, conversationId).filter((m) => m.role === 'user');
             if (userMsgs.length === 0 || userMsgs.length > 2)
@@ -440,6 +581,8 @@ class AgentChatManager {
      * so the cheap spawn is skipped when it would be pointless.
      */
     _maybeAiTitle(conversation, firstUserMsg, firstResponse) {
+        if (this._disposed)
+            return;
         try {
             const conversationId = conversation.id;
             const assistantCount = (0, agent_store_1.listAgentMessages)(this._db, conversationId).filter((m) => m.role === 'assistant').length;
@@ -466,6 +609,8 @@ class AgentChatManager {
      * into the turn path — title generation failing must not surface an error.
      */
     _aiTitle(conversation, firstUserMsg, firstResponse) {
+        if (this._disposed)
+            return;
         try {
             const conversationId = conversation.id;
             const adapter = (0, providers_1.getAdapter)(conversation.provider);
@@ -474,7 +619,7 @@ class AgentChatManager {
                 'Output ONLY the title text — no quotes, no punctuation, no markdown, no preamble.\n\n' +
                 `User: ${firstUserMsg.slice(0, 240)}\nAssistant: ${firstResponse.slice(0, 320)}`;
             const args = adapter.buildArgs('auto-title', { prompt, model });
-            const child = (0, cli_prompt_1.spawnAiCli)(adapter.binary, args, {
+            const child = this._spawnOwned(adapter.binary, args, {
                 env: process.env,
                 stdio: ['ignore', 'pipe', 'pipe'],
                 cwd: (0, os_1.tmpdir)(),
@@ -484,7 +629,10 @@ class AgentChatManager {
             const events = [];
             const startedAt = new Date().toISOString();
             const reader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+            this._auxReaders.set(child, reader);
             reader.on('line', (line) => {
+                if (this._disposed)
+                    return;
                 const ev = adapter.parseStreamLine(line);
                 if (!ev)
                     return;
@@ -494,9 +642,21 @@ class AgentChatManager {
             });
             child.on('error', () => {
                 this._auxProcesses.delete(child);
+                this._auxReaders.delete(child);
+                try {
+                    reader.close();
+                }
+                catch { /* best-effort */ }
             });
             child.on('close', (code) => {
                 this._auxProcesses.delete(child);
+                this._auxReaders.delete(child);
+                try {
+                    reader.close();
+                }
+                catch { /* best-effort */ }
+                if (this._disposed)
+                    return;
                 const fresh = (0, agent_store_1.getAgentConversation)(this._db, conversationId);
                 if (!fresh)
                     return; // deleted mid-generation — FK-safe: skip record + update
@@ -529,6 +689,8 @@ class AgentChatManager {
      * NEVER throws — it runs inside rail settle paths.
      */
     postPrDecisionCard(conversationId, envelope) {
+        if (this._disposed)
+            return;
         try {
             if (!(0, agent_store_1.getAgentConversation)(this._db, conversationId)) {
                 console.log(`[agent-chat] pr-decision card skipped — conversation gone (${conversationId})`);
@@ -549,6 +711,8 @@ class AgentChatManager {
      * conversation delete/restore). NEVER throws — it runs inside decision paths.
      */
     updatePrDecisionCard(conversationId, envelope) {
+        if (this._disposed)
+            return;
         try {
             const existing = (0, agent_store_1.findAgentSystemMessage)(this._db, conversationId, (content) => {
                 try {
@@ -563,7 +727,14 @@ class AgentChatManager {
                 this.postPrDecisionCard(conversationId, envelope);
                 return;
             }
-            (0, agent_store_1.updateAgentMessageContent)(this._db, existing.id, JSON.stringify(envelope));
+            const serialized = JSON.stringify(envelope);
+            // Startup recovery may inspect historical deliveries to heal a card that
+            // missed its terminal update. Identical projection is not new activity:
+            // avoid a redundant DB write and, crucially, do not broadcast an unread
+            // event for an old card on every app launch.
+            if (existing.content === serialized)
+                return;
+            (0, agent_store_1.updateAgentMessageContent)(this._db, existing.id, serialized);
             this._broadcastPrDecision(conversationId, envelope);
         }
         catch (err) {
@@ -586,6 +757,8 @@ class AgentChatManager {
      * Success broadcasts `agent_queue_edited` so every open window updates its chip.
      */
     editQueued(conversationId, queueId, text) {
+        if (this._disposed)
+            return false;
         const pending = this._queue.get(conversationId);
         const item = pending?.find((q) => q.queueId === queueId);
         if (!item)
@@ -606,18 +779,15 @@ class AgentChatManager {
      *  and the settling turn is marked aborted so the stale-session auto-heal
      *  can never resurrect the stopped prompt as a fresh spawn. */
     abort(conversationId) {
+        if (this._disposed)
+            return false;
         this._clearQueue(conversationId);
         if (this.isBusy(conversationId))
             this._abortedTurns.add(conversationId);
         const child = this._active.get(conversationId);
         if (!child)
             return false;
-        try {
-            child.kill('SIGTERM');
-        }
-        catch {
-            /* ignore */
-        }
+        this._terminate(child);
         this._active.delete(conversationId);
         return true;
     }
@@ -630,27 +800,36 @@ class AgentChatManager {
     }
     /** Kills all active turns (graceful shutdown). */
     async shutdown() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this._resolveDisposed();
         this._queue.clear();
+        this._reserved.clear();
+        this._abortedTurns.clear();
         for (const [, child] of this._active) {
-            try {
-                child.kill('SIGTERM');
-            }
-            catch {
-                /* ignore */
-            }
+            this._terminate(child);
+            // runAiCliInvocation owns readline listeners and an unbounded event
+            // accumulator. Cut the pipes now so an uncooperative child cannot keep
+            // feeding that detached invocation during the SIGTERM grace window.
+            this._closeChildIo(child);
         }
         this._active.clear();
         for (const child of this._auxProcesses) {
+            const reader = this._auxReaders.get(child);
             try {
-                child.kill('SIGTERM');
-            }
-            catch {
-                /* ignore */
+                reader?.close();
             }
+            catch { /* best-effort */ }
+            this._terminate(child);
+            this._closeChildIo(child);
         }
+        this._auxReaders.clear();
         this._auxProcesses.clear();
     }
     _emitError(conversationId, error) {
+        if (this._disposed)
+            return;
         this._broadcast({ type: 'agent_error', conversationId, error, timestamp: new Date().toISOString() });
     }
 }