specrails-desktop 2.2.1 → 2.4.0

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

@@ -9,13 +9,12 @@ exports.buildFirstTurnPrompt = buildFirstTurnPrompt;
 exports.refineSessionToJson = refineSessionToJson;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const readline_1 = require("readline");
 const crypto_1 = require("crypto");
 const tree_kill_1 = __importDefault(require("tree-kill"));
-const cli_prompt_1 = require("./util/cli-prompt");
 const agent_generator_1 = require("./agent-generator");
 const ai_invocations_1 = require("./ai-invocations");
 const result_event_1 = require("./result-event");
+const spawn_lifecycle_1 = require("./spawn-lifecycle");
 const providers_1 = require("./providers");
 const agent_refine_db_1 = require("./agent-refine-db");
 const CUSTOM_PREFIX = /^custom-[a-z0-9][a-z0-9-]*$/;
@@ -219,164 +218,140 @@ class AgentRefineManager {
             sessionId: session.session_id ?? undefined,
         });
         let drafted = false;
-        const child = (0, cli_prompt_1.spawnAiCli)(this._adapter.binary, args, {
-            env: process.env,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: this._projectPath,
-        });
-        this._activeProcesses.set(refineId, child);
         this._bodyBuffers.set(refineId, '');
-        let capturedSessionId = null;
-        const adapterEvents = [];
         const turnStartedAt = new Date().toISOString();
-        const reader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
-        reader.on('line', (line) => {
-            const ev = this._adapter.parseStreamLine(line);
-            if (!ev)
-                return;
-            adapterEvents.push(ev);
-            switch (ev.kind) {
-                case 'session-started':
-                    if (!capturedSessionId)
-                        capturedSessionId = ev.sessionId;
-                    break;
-                case 'result': {
-                    const sid = ev.payload.session_id;
-                    if (sid && !capturedSessionId)
-                        capturedSessionId = sid;
-                    break;
-                }
-                case 'text-delta': {
-                    if (!drafted) {
-                        drafted = true;
-                        (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { phase: 'drafting' });
-                        this._emitPhase(refineId, 'drafting');
-                    }
-                    const prev = this._bodyBuffers.get(refineId) ?? '';
-                    const next = prev + ev.text;
-                    this._bodyBuffers.set(refineId, next);
-                    this._broadcast({
-                        type: 'agent_refine_stream',
-                        projectId: '',
-                        refineId,
-                        delta: ev.text,
-                        timestamp: new Date().toISOString(),
-                    });
-                    (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { draft_body: next });
-                    break;
-                }
-                case 'tool-use':
-                    this._broadcast({
-                        type: 'agent_refine_stream',
-                        projectId: '',
-                        refineId,
-                        delta: `<!--tool:${ev.name}-->`,
-                        timestamp: new Date().toISOString(),
-                    });
-                    break;
-                case 'other':
-                    break;
-            }
-        });
-        let stderr = '';
-        child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
-        return new Promise((resolve) => {
-            child.on('error', (err) => {
-                this._activeProcesses.delete(refineId);
-                this._bodyBuffers.delete(refineId);
-                if (this._disposed) {
-                    resolve();
-                    return;
-                } // M12: project removed mid-flight; DB closing
-                this._emitError(refineId, `Failed to launch claude: ${err.message}`);
-                (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle' });
-                resolve();
-            });
-            child.on('close', (code) => {
-                this._activeProcesses.delete(refineId);
-                const fullDraft = this._bodyBuffers.get(refineId) ?? '';
-                this._bodyBuffers.delete(refineId);
-                if (this._disposed) {
-                    resolve();
-                    return;
-                } // M12: project removed mid-flight; DB closing
-                // ai_invocations capture (surface='ai-edit'). One row per refine turn.
-                if (this._projectId) {
-                    try {
-                        const invStatus = code === 0 && fullDraft.trim() ? 'success' : 'failed';
-                        const { result: normalised, estimated } = (0, result_event_1.finaliseInvocationResult)(this._adapter, adapterEvents, { fallbackModel: refineModel });
-                        (0, ai_invocations_1.recordInvocation)(this._db, {
-                            id: (0, crypto_1.randomUUID)(),
-                            project_id: this._projectId,
-                            provider: this._adapter.id,
-                            surface: 'ai-edit',
-                            surface_ref_id: refineId,
-                            status: invStatus,
-                            started_at: turnStartedAt,
-                            finished_at: new Date().toISOString(),
-                            total_cost_usd_estimated: estimated,
-                            ...normalised,
+        const spawnState = { err: null };
+        // Spawn / stream / settlement is owned by the shared spawn-lifecycle; the
+        // refine-specific draft buffering, accounting, validation and history all
+        // stay here unchanged.
+        const run = await (0, spawn_lifecycle_1.runAiCliInvocation)({
+            adapter: this._adapter,
+            action,
+            buildOpts: { prompt, model: refineModel, sessionId: session.session_id ?? undefined },
+            cwd: this._projectPath,
+            onSpawn: (child) => this._activeProcesses.set(refineId, child),
+            onSpawnError: (err) => { spawnState.err = err; },
+            onEvent: (ev) => {
+                switch (ev.kind) {
+                    case 'text-delta': {
+                        if (!drafted) {
+                            drafted = true;
+                            (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { phase: 'drafting' });
+                            this._emitPhase(refineId, 'drafting');
+                        }
+                        const prev = this._bodyBuffers.get(refineId) ?? '';
+                        const next = prev + ev.text;
+                        this._bodyBuffers.set(refineId, next);
+                        this._broadcast({
+                            type: 'agent_refine_stream',
+                            projectId: '',
+                            refineId,
+                            delta: ev.text,
+                            timestamp: new Date().toISOString(),
                         });
-                        this._broadcast({ type: 'spending.invalidated', projectId: this._projectId });
+                        (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { draft_body: next });
+                        break;
                     }
-                    catch (err) {
-                        console.error('[agent-refine-manager] recordInvocation failed:', err);
-                    }
-                }
-                if (code !== 0 || !fullDraft.trim()) {
-                    this._emitError(refineId, code !== 0
-                        ? `claude exited with code ${code}${stderr ? `: ${stderr.slice(-300)}` : ''}`
-                        : 'claude returned empty output');
-                    (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle' });
-                    resolve();
-                    return;
-                }
-                // Validation phase.
-                (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { phase: 'validating' });
-                this._emitPhase(refineId, 'validating');
-                const stripped = stripToolMarkers(fullDraft);
-                const validation = validateAgentBody(stripped, this._adapter.id);
-                if (!validation.ok) {
-                    this._emitError(refineId, `Frontmatter invalid: ${validation.error}`);
-                    (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle', draft_body: stripped });
-                    resolve();
-                    return;
+                    case 'tool-use':
+                        this._broadcast({
+                            type: 'agent_refine_stream',
+                            projectId: '',
+                            refineId,
+                            delta: `<!--tool:${ev.name}-->`,
+                            timestamp: new Date().toISOString(),
+                        });
+                        break;
+                    default:
+                        break;
                 }
-                // Append assistant turn to history (use stripped body — markers gone).
-                this._appendHistory(refineId, {
-                    role: 'assistant',
-                    content: stripped,
-                    timestamp: Date.now(),
-                });
-                const patch = {
-                    status: 'ready',
-                    phase: 'done',
-                    draft_body: stripped,
-                    ...(capturedSessionId ? { session_id: capturedSessionId } : {}),
-                };
-                (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, patch);
-                this._broadcast({
-                    type: 'agent_refine_ready',
-                    projectId: '',
-                    refineId,
-                    draftBody: stripped,
-                    timestamp: new Date().toISOString(),
+            },
+        });
+        this._activeProcesses.delete(refineId);
+        const fullDraft = this._bodyBuffers.get(refineId) ?? '';
+        this._bodyBuffers.delete(refineId);
+        if (this._disposed)
+            return; // M12: project removed mid-flight; DB closing
+        if (run.spawnFailed) {
+            this._emitError(refineId, `Failed to launch claude: ${spawnState.err?.message ?? 'spawn error'}`);
+            (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle' });
+            return;
+        }
+        const capturedSessionId = run.sessionId;
+        const adapterEvents = run.events;
+        const code = run.code;
+        const stderr = run.stderrTail;
+        // ai_invocations capture (surface='ai-edit'). One row per refine turn.
+        if (this._projectId) {
+            try {
+                const invStatus = code === 0 && fullDraft.trim() ? 'success' : 'failed';
+                const { result: normalised, estimated } = (0, result_event_1.finaliseInvocationResult)(this._adapter, adapterEvents, { fallbackModel: refineModel });
+                (0, ai_invocations_1.recordInvocation)(this._db, {
+                    id: (0, crypto_1.randomUUID)(),
+                    project_id: this._projectId,
+                    provider: this._adapter.id,
+                    surface: 'ai-edit',
+                    surface_ref_id: refineId,
+                    status: invStatus,
+                    started_at: turnStartedAt,
+                    finished_at: new Date().toISOString(),
+                    total_cost_usd_estimated: estimated,
+                    ...normalised,
                 });
-                this._emitPhase(refineId, 'done');
-                // Smart-mode auto-test: only run if enabled, body changed since last
-                // test, and >5s elapsed. Best-effort; failures are non-fatal.
-                const session2 = (0, agent_refine_db_1.getRefineSession)(this._db, refineId);
-                if (session2 && session2.auto_test === 1) {
-                    const draftHash = sha256(stripped);
-                    const recent = session2.last_test_at !== null && Date.now() - session2.last_test_at < SMART_TEST_DEBOUNCE_MS;
-                    const sameBody = session2.last_test_hash === draftHash;
-                    if (!recent && !sameBody) {
-                        void this._runAutoTest(refineId, session2.agent_id, stripped, draftHash);
-                    }
-                }
-                resolve();
-            });
+                this._broadcast({ type: 'spending.invalidated', projectId: this._projectId });
+            }
+            catch (err) {
+                console.error('[agent-refine-manager] recordInvocation failed:', err);
+            }
+        }
+        if (code !== 0 || !fullDraft.trim()) {
+            this._emitError(refineId, code !== 0
+                ? `claude exited with code ${code}${stderr ? `: ${stderr.slice(-300)}` : ''}`
+                : 'claude returned empty output');
+            (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle' });
+            return;
+        }
+        // Validation phase.
+        (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { phase: 'validating' });
+        this._emitPhase(refineId, 'validating');
+        const stripped = stripToolMarkers(fullDraft);
+        const validation = validateAgentBody(stripped, this._adapter.id);
+        if (!validation.ok) {
+            this._emitError(refineId, `Frontmatter invalid: ${validation.error}`);
+            (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { status: 'error', phase: 'idle', draft_body: stripped });
+            return;
+        }
+        // Append assistant turn to history (use stripped body — markers gone).
+        this._appendHistory(refineId, {
+            role: 'assistant',
+            content: stripped,
+            timestamp: Date.now(),
+        });
+        const patch = {
+            status: 'ready',
+            phase: 'done',
+            draft_body: stripped,
+            ...(capturedSessionId ? { session_id: capturedSessionId } : {}),
+        };
+        (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, patch);
+        this._broadcast({
+            type: 'agent_refine_ready',
+            projectId: '',
+            refineId,
+            draftBody: stripped,
+            timestamp: new Date().toISOString(),
         });
+        this._emitPhase(refineId, 'done');
+        // Smart-mode auto-test: only run if enabled, body changed since last
+        // test, and >5s elapsed. Best-effort; failures are non-fatal.
+        const session2 = (0, agent_refine_db_1.getRefineSession)(this._db, refineId);
+        if (session2 && session2.auto_test === 1) {
+            const draftHash = sha256(stripped);
+            const recent = session2.last_test_at !== null && Date.now() - session2.last_test_at < SMART_TEST_DEBOUNCE_MS;
+            const sameBody = session2.last_test_hash === draftHash;
+            if (!recent && !sameBody) {
+                void this._runAutoTest(refineId, session2.agent_id, stripped, draftHash);
+            }
+        }
     }
     async _runAutoTest(refineId, agentId, draftBody, draftHash) {
         (0, agent_refine_db_1.updateRefineSession)(this._db, refineId, { phase: 'testing' });

package/server/dist/chat-manager.js

@@ -20,6 +20,7 @@ const providers_1 = require("./providers");
 const context_scope_1 = require("./context-scope");
 const user_mcp_config_1 = require("./user-mcp-config");
 const binary_probe_1 = require("./binary-probe");
+const explore_stdin_session_1 = require("./explore-stdin-session");
 const COMMAND_INSTRUCTION = 'When you want to suggest a SpecRails command for the user to execute, wrap it in a command block like this: ' +
     ':::command\n/specrails:implement #42\n::: ' +
     'The user will be prompted to confirm before the command runs.';
@@ -60,6 +61,9 @@ class ChatManager {
     _exploreLifecycle;
     /** FIFO queue of Explore turns waiting for a concurrency slot. */
     _exploreQueue;
+    /** Persistent-stdin Explore transport (big bet #3, flag-gated default OFF).
+     *  Holds long-lived claude children that survive between turns. */
+    _stdinSessions = new explore_stdin_session_1.ExploreStdinSessions();
     _cwd;
     _projectName;
     _adapter;
@@ -142,6 +146,9 @@ class ChatManager {
                 }
                 catch { /* best-effort */ }
             }
+            // Persistent-stdin children live OUTSIDE _activeProcesses between turns —
+            // idle-kill must reach them too (the next turn re-spawns with --resume).
+            this._stdinSessions.kill(conversationId);
         }, exports.EXPLORE_IDLE_KILL_MS);
     }
     /**
@@ -223,6 +230,8 @@ class ChatManager {
                 }
                 catch { /* best-effort */ }
             }
+            // Reclaim the slot from a persistent-stdin child parked between turns.
+            this._stdinSessions.kill(victim);
             this._clearIdleTimer(victim);
             this._exploreLifecycle.delete(victim);
             if (this._countStreamingExplore() < exports.EXPLORE_MAX_CONCURRENCY)
@@ -547,6 +556,19 @@ class ChatManager {
             // not pipeline jobs. Telemetry is scoped to QueueManager pipeline runs only.
             // spawnAiCli reroutes multi-line argv values through stdin on Windows.
             const spawnCwd = this._resolveSpawnCwd(conversation.kind, conversationScope, adapter.id);
+            // Big bet #3 fast-path: persistent-stdin multi-turn for Explore (claude
+            // only, flag-gated default OFF). Reuses a single long-lived child across
+            // turns so turns 2+ skip spawn + session rehydration. Full fallback to the
+            // legacy spawn-per-turn path below when disabled / unsupported.
+            if ((0, explore_stdin_session_1.isExplorePersistentStdinEnabled)() &&
+                conversation.kind === 'explore' &&
+                adapter.capabilities.persistentStdin === true) {
+                return await this._streamPersistentExploreTurn({
+                    conversationId, conversation, adapter, binary, model, systemPrompt,
+                    scopeFlags, spawnCwd, promptForAdapter, isFirstTurn, userText,
+                    lightweight, conversationScope,
+                });
+            }
             const child = (0, cli_prompt_1.spawnAiCli)(binary, args, {
                 env: process.env,
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -866,6 +888,223 @@ class ChatManager {
             this._reservedTurns.delete(conversationId);
         }
     }
+    /**
+     * Persistent-stdin Explore turn (big bet #3). Reuses one long-lived claude
+     * child per conversation via `--input-format stream-json`: the user turn is
+     * written to the child's stdin, and the turn ends on the `result` event
+     * (NOT process close — the child stays alive for the next turn). Mirrors the
+     * legacy close-handler's finalisation (spec-draft parse, persist, session
+     * capture, chat_done, invocation accounting, lifecycle) without crash-respawn
+     * — a dead persistent child is evicted and the next turn re-spawns with
+     * `--resume`. Only reached when the flag is on; the legacy path is untouched.
+     */
+    async _streamPersistentExploreTurn(p) {
+        const { conversationId, conversation, adapter, binary, model, systemPrompt, scopeFlags, spawnCwd, promptForAdapter, isFirstTurn, userText, lightweight, conversationScope, } = p;
+        const sessionArgs = adapter.buildArgs('chat-stream', {
+            prompt: '',
+            systemPrompt,
+            model,
+            sessionId: conversation.session_id ?? undefined,
+            extraArgs: scopeFlags,
+            loadUserEnv: adapter.id === 'claude' && !!conversationScope?.userMcp,
+        });
+        const { child } = this._stdinSessions.getOrSpawn(conversationId, {
+            binary, args: sessionArgs, cwd: spawnCwd, env: process.env,
+        });
+        this._activeProcesses.set(conversationId, child);
+        this._buffers.set(conversationId, '');
+        this._emittedProposals.set(conversationId, new Set());
+        this._streamFilters.set(conversationId, { inBlock: false, pendingTail: '' });
+        const adapterEvents = [];
+        let capturedSessionId = null;
+        let stderrBuf = '';
+        const turnStartedAt = new Date().toISOString();
+        const emitDelta = (newText) => {
+            const prev = this._buffers.get(conversationId) ?? '';
+            this._buffers.set(conversationId, prev + newText);
+            const filter = this._streamFilters.get(conversationId);
+            const visibleDelta = filter ? filterDraftBlocksLive(filter, newText) : newText;
+            if (visibleDelta) {
+                this._broadcast({
+                    type: 'chat_stream',
+                    conversationId,
+                    delta: visibleDelta,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            const proposals = extractCommandProposals(this._buffers.get(conversationId) ?? '');
+            const emitted = this._emittedProposals.get(conversationId);
+            if (emitted) {
+                for (const proposal of proposals) {
+                    if (!emitted.has(proposal)) {
+                        emitted.add(proposal);
+                        this._broadcast({
+                            type: 'chat_command_proposal',
+                            conversationId,
+                            command: proposal,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+        };
+        const recordInv = (status) => {
+            if (!this._projectId)
+                return;
+            try {
+                const { result, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, adapterEvents, {
+                    fallbackModel: model,
+                });
+                (0, ai_invocations_1.recordInvocation)(this._db, {
+                    id: (0, crypto_1.randomUUID)(),
+                    project_id: this._projectId,
+                    provider: adapter.id,
+                    surface: 'explore-spec',
+                    surface_ref_id: conversationId,
+                    conversation_id: conversationId,
+                    status,
+                    started_at: turnStartedAt,
+                    finished_at: new Date().toISOString(),
+                    total_cost_usd_estimated: estimated,
+                    ...result,
+                });
+                this._broadcast({ type: 'spending.invalidated', projectId: this._projectId });
+            }
+            catch (err) {
+                console.error('[chat-manager] recordInvocation failed:', err);
+            }
+        };
+        const cleanupTurnState = () => {
+            this._activeProcesses.delete(conversationId);
+            this._buffers.delete(conversationId);
+            this._emittedProposals.delete(conversationId);
+            this._streamFilters.delete(conversationId);
+        };
+        const markStreamingEnded = (success) => {
+            const life = this._exploreLifecycle.get(conversationId);
+            if (life) {
+                life.isStreaming = false;
+                life.lastActivityAt = Date.now();
+                if (success)
+                    life.crashCount = 0;
+                if (life.isMinimized)
+                    this._startIdleTimer(conversationId);
+            }
+            this._drainExploreQueue();
+        };
+        return new Promise((resolve) => {
+            let settled = false;
+            const finishTurn = () => {
+                if (settled)
+                    return;
+                settled = true;
+                this._stdinSessions.clearHandlers(conversationId);
+                const fullText = this._buffers.get(conversationId) ?? '';
+                const wasAborting = this._abortingConversations.has(conversationId);
+                cleanupTurnState();
+                this._abortingConversations.delete(conversationId);
+                markStreamingEnded(true);
+                recordInv(wasAborting ? 'aborted' : 'success');
+                const parsed = (0, spec_draft_parser_1.parseSpecDraftBlocks)(fullText);
+                const persistedText = parsed.blocks.length > 0 ? parsed.stripped : fullText;
+                if (parsed.blocks.length > 0) {
+                    const prevState = this._specDraftStates.get(conversationId);
+                    const nextState = (0, spec_draft_parser_1.applyBlocks)(prevState, parsed.blocks);
+                    this._specDraftStates.set(conversationId, nextState);
+                    this._broadcast({
+                        type: 'spec_draft.update',
+                        conversationId,
+                        draft: nextState.draft,
+                        ready: nextState.ready,
+                        chips: nextState.chips,
+                        changedFields: nextState.lastChangedFields,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                if (persistedText) {
+                    (0, db_1.addMessage)(this._db, { conversation_id: conversationId, role: 'assistant', content: persistedText });
+                }
+                if (capturedSessionId) {
+                    (0, db_1.updateConversation)(this._db, conversationId, { session_id: capturedSessionId });
+                }
+                this._broadcast({
+                    type: 'chat_done',
+                    conversationId,
+                    fullText: persistedText,
+                    timestamp: new Date().toISOString(),
+                });
+                if (isFirstTurn && fullText && !lightweight) {
+                    this._autoTitle(conversationId, userText, fullText);
+                }
+                resolve();
+            };
+            const onClose = (code) => {
+                // The persistent child died (crash / idle-kill / shutdown). If the turn
+                // already finished on its `result` event, ignore. No crash-respawn —
+                // the session is evicted by the transport; the next turn re-spawns with
+                // `--resume`, so no persisted state is lost.
+                if (settled)
+                    return;
+                settled = true;
+                this._stdinSessions.clearHandlers(conversationId);
+                const wasAborting = this._abortingConversations.has(conversationId);
+                cleanupTurnState();
+                this._abortingConversations.delete(conversationId);
+                markStreamingEnded(false);
+                recordInv(wasAborting ? 'aborted' : 'failed');
+                if (wasAborting) {
+                    resolve();
+                    return;
+                }
+                const stderrTail = stderrBuf.trim().slice(-500);
+                this._broadcast({
+                    type: 'chat_error',
+                    conversationId,
+                    error: stderrTail
+                        ? `${binary} exited with code ${code ?? 'unknown'}: ${stderrTail}`
+                        : `Process exited with code ${code ?? 'unknown'}`,
+                    timestamp: new Date().toISOString(),
+                });
+                resolve();
+            };
+            const onLine = (line) => {
+                const ev = adapter.parseStreamLine(line);
+                if (!ev)
+                    return;
+                adapterEvents.push(ev);
+                switch (ev.kind) {
+                    case 'text-delta':
+                        emitDelta(ev.text);
+                        break;
+                    case 'session-started':
+                        if (ev.sessionId)
+                            capturedSessionId = ev.sessionId;
+                        break;
+                    case 'result': {
+                        const sid = ev.payload.session_id;
+                        if (sid)
+                            capturedSessionId = sid;
+                        finishTurn();
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            };
+            this._stdinSessions.setHandlers(conversationId, {
+                onLine,
+                onStderr: (s) => {
+                    stderrBuf += s;
+                    console.error(`[chat-manager] ${binary} stderr (${conversationId}):`, s.trim());
+                },
+                onClose,
+            });
+            if (!this._stdinSessions.writeTurn(conversationId, promptForAdapter)) {
+                // stdin already gone (child died between spawn and write) — fail the turn.
+                onClose(null);
+            }
+        });
+    }
     abort(conversationId) {
         const child = this._activeProcesses.get(conversationId);
         if (!child || !child.pid)
@@ -893,6 +1132,7 @@ class ChatManager {
             clearTimeout(this._exploreQueue[idx].timeoutTimer);
             this._exploreQueue.splice(idx, 1);
         }
+        this._stdinSessions.kill(conversationId);
         this._exploreLifecycle.delete(conversationId);
     }
     /**
@@ -911,6 +1151,8 @@ class ChatManager {
                 catch { /* best-effort */ }
             }
         }
+        // Persistent-stdin children outlive individual turns — tear them down too.
+        this._stdinSessions.killAll();
         for (const id of this._exploreLifecycle.keys()) {
             this._clearIdleTimer(id);
         }