@sumicom/quicksave 0.5.1 → 0.6.0

package/dist/ai/claudeCodeService.js

@@ -1,7 +1,8 @@
 import { EventEmitter } from 'events';
-import { unstable_v2_createSession, unstable_v2_resumeSession, listSessions, getSessionMessages, } from '@anthropic-ai/claude-agent-sdk';
-const TOOL_RESULT_TRUNCATE_LENGTH = 500;
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
+import { resolve } from 'path';
+import { unstable_v2_createSession, unstable_v2_resumeSession, listSessions, getSessionMessages, listSubagents, getSubagentMessages, } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '@sumicom/quicksave-shared';
+import { StreamCardBuilder, buildCardsFromHistory } from './cardBuilder.js';
 /** Tools auto-approved at each permission level (no user prompt).
  *  Read/Glob/Grep are always auto-approved at SDK level (allowedTools).
  *  Tools NOT listed here go through canUseTool → permission prompt.
@@ -36,6 +37,11 @@ const AUTO_APPROVE = {
     default: new Set(['TodoWrite', 'EnterWorktree', 'ExitWorktree', 'Agent']),
     plan: new Set(),
 };
+function createDeferred() {
+    let resolve;
+    const promise = new Promise((r) => { resolve = r; });
+    return { promise, resolve };
+}
 /** Extract readable text from tool_result content (which may be a string or array of blocks). */
 function extractToolResultText(content) {
     if (typeof content === 'string')
@@ -50,11 +56,85 @@ function extractToolResultText(content) {
 }
 export class ClaudeCodeService extends EventEmitter {
     sessions = new Map();
+    sessionPermissions = new Map(); // persists across active/inactive
+    sessionConfigs = new Map(); // generic per-session config
     pendingInputRequests = new Map();
     requestCounter = 0;
+    preferences = {
+        model: DEFAULT_MODEL,
+    };
     constructor() {
         super();
     }
+    /**
+     * Initialize preferences from the most recently used session.
+     * Uses SDK listSessions + getSessionMessages to read the last assistant message's model field.
+     */
+    async initPreferences() {
+        try {
+            const sessions = await listSessions();
+            if (sessions.length === 0)
+                return;
+            // Sessions are sorted by lastModified desc by the SDK
+            const latest = sessions[0];
+            const sessionId = latest.sessionId;
+            const cwd = latest.cwd;
+            const msgs = await getSessionMessages(sessionId, { dir: cwd });
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                const model = msgs[i].message?.model;
+                if (model && msgs[i].type === 'assistant') {
+                    this.preferences.model = model;
+                    break;
+                }
+            }
+        }
+        catch { /* use defaults */ }
+    }
+    getPreferences() {
+        return { ...this.preferences };
+    }
+    /**
+     * Update preferences. Returns the applied preferences (may differ if validation fails).
+     * Emits 'preferences-updated' if any value actually changed.
+     */
+    setPreferences(prefs) {
+        const next = { ...this.preferences };
+        let changed = false;
+        if (prefs.model !== undefined && prefs.model !== this.preferences.model) {
+            next.model = prefs.model;
+            changed = true;
+        }
+        if (changed) {
+            this.preferences = next;
+            this.emit('preferences-updated', this.preferences);
+        }
+        return { ...this.preferences };
+    }
+    getSessionConfig(sessionId) {
+        return { ...this.sessionConfigs.get(sessionId) };
+    }
+    /**
+     * Set a single key on a session's config. Applies known keys immediately:
+     *   model / reasoningEffort → updates global preferences (takes effect next turn)
+     *   permissionMode          → calls setPermissionLevel (immediate)
+     */
+    setSessionConfig(sessionId, key, value) {
+        const prev = this.sessionConfigs.get(sessionId) ?? {};
+        const next = { ...prev, [key]: value };
+        this.sessionConfigs.set(sessionId, next);
+        // Apply known keys
+        if (key === 'model' && typeof value === 'string') {
+            this.setPreferences({ model: value });
+        }
+        else if (key === 'reasoningEffort' && (typeof value === 'string' || value === null)) {
+            this.setPreferences({ reasoningEffort: value });
+        }
+        else if (key === 'permissionMode' && typeof value === 'string') {
+            this.setPermissionLevel(sessionId, value);
+        }
+        this.emit('session-config-updated', { sessionId, config: next });
+        return next;
+    }
     /** Build and emit a session-updated event with current state. */
     emitSessionUpdate(sessionId) {
         const ps = this.sessions.get(sessionId);
@@ -65,6 +145,7 @@ export class ClaudeCodeService extends EventEmitter {
             isActive: !!ps,
             isStreaming: ps?.streaming ?? false,
             hasPendingInput,
+            permissionMode: ps?.permissionLevel,
         });
     }
     async listAvailableSessions(cwd) {
@@ -76,8 +157,10 @@ export class ClaudeCodeService extends EventEmitter {
             const isActive = this.sessions.has(s.sessionId);
             const isStreaming = this.sessions.get(s.sessionId)?.streaming ?? false;
             let hasPendingInput = pendingSessionIds.has(s.sessionId);
-            // If not already known as pending from memory, check JSONL tail
-            if (!hasPendingInput) {
+            // Only check JSONL for sessions NOT in memory — in-memory sessions use
+            // pendingInputRequests as the authoritative source. JSONL may have mid-flight
+            // tool_use blocks that haven't received tool_result yet (false positive).
+            if (!hasPendingInput && !isActive) {
                 hasPendingInput = await this.detectPendingFromJSONL(s.sessionId, cwd);
             }
             return {
@@ -90,6 +173,7 @@ export class ClaudeCodeService extends EventEmitter {
                 isActive,
                 isStreaming,
                 hasPendingInput,
+                permissionMode: this.sessions.get(s.sessionId)?.permissionLevel ?? this.sessionPermissions.get(s.sessionId),
             };
         }));
         // Sort: pending first, then active, then by lastModified
@@ -103,90 +187,61 @@ export class ClaudeCodeService extends EventEmitter {
         return enriched;
     }
     /**
-     * Check if a session's last message in the SDK JSONL is an unanswered tool_use.
-     * Reads only the last few messages to keep it fast.
+     * Check if a session's last message is an unanswered tool_use.
+     * Uses SDK getSessionMessages + listSubagents/getSubagentMessages.
      */
     async detectPendingFromJSONL(sessionId, cwd) {
-        try {
-            const allMessages = await getSessionMessages(sessionId, { dir: cwd });
-            if (allMessages.length === 0)
+        const hasPendingToolUse = (msgs, label = 'parent') => {
+            if (msgs.length === 0)
                 return false;
-            const last = allMessages[allMessages.length - 1];
-            // Last message is assistant with a tool_use block and no following user/tool_result
+            const last = msgs[msgs.length - 1];
             if (last.type !== 'assistant')
                 return false;
             const content = last.message?.content;
             if (!Array.isArray(content))
                 return false;
-            return content.some((block) => block.type === 'tool_use');
+            const toolUseIds = content.filter((b) => b.type === 'tool_use').map((b) => b.id);
+            if (toolUseIds.length === 0)
+                return false;
+            // Check if all tool_use blocks already have a corresponding tool_result
+            const resolvedIds = new Set(msgs
+                .filter((m) => m.type === 'user')
+                .flatMap((m) => {
+                const c = m.message?.content;
+                return Array.isArray(c)
+                    ? c.filter((b) => b.type === 'tool_result').map((b) => b.tool_use_id)
+                    : [];
+            }));
+            const unresolvedIds = toolUseIds.filter((id) => !resolvedIds.has(id));
+            if (unresolvedIds.length > 0) {
+                const toolNames = content
+                    .filter((b) => b.type === 'tool_use' && unresolvedIds.includes(b.id))
+                    .map((b) => b.name);
+                console.log(`[detectPending] ${label} session=${sessionId.slice(0, 8)}: unresolved tool_use: ${toolNames.join(', ')} (${unresolvedIds.length}/${toolUseIds.length})`);
+            }
+            return unresolvedIds.length > 0;
+        };
+        try {
+            // Check parent session
+            const allMessages = await getSessionMessages(sessionId, { dir: cwd });
+            if (hasPendingToolUse(allMessages))
+                return true;
+            // Check subagents — a subagent may be waiting for permission
+            try {
+                const agentIds = await listSubagents(sessionId, { dir: cwd });
+                for (const agentId of agentIds) {
+                    const subMsgs = await getSubagentMessages(sessionId, agentId, { dir: cwd });
+                    if (hasPendingToolUse(subMsgs, `subagent:${agentId.slice(0, 8)}`))
+                        return true;
+                }
+            }
+            catch { /* no subagents */ }
+            return false;
         }
         catch {
             return false;
         }
     }
-    async getMessages(sessionId, cwd, offset = 0, limit = 50) {
-        // Read directly from SDK JSONL — the single source of truth.
-        // SDK writes messages immediately and retains full, un-truncated data.
-        // Messages are chronological (old→new). We paginate from the tail:
-        //   offset=0  → last `limit` messages (most recent)
-        //   offset=50 → the `limit` messages before those, etc.
-        const allMessages = await getSessionMessages(sessionId, { dir: cwd });
-        const total = allMessages.length;
-        const tailStart = Math.max(0, total - offset - limit);
-        const tailEnd = Math.max(0, total - offset);
-        const sliced = allMessages.slice(tailStart, tailEnd);
-        const messages = sliced.map((msg, i) => {
-            const role = msg.type;
-            let content = '';
-            let toolName;
-            let toolInput;
-            let toolResult;
-            let truncated = false;
-            const rawMessage = msg.message;
-            if (rawMessage?.content) {
-                if (typeof rawMessage.content === 'string') {
-                    content = rawMessage.content;
-                }
-                else if (Array.isArray(rawMessage.content)) {
-                    const parts = [];
-                    for (const block of rawMessage.content) {
-                        if (block.type === 'text') {
-                            parts.push(block.text);
-                        }
-                        else if (block.type === 'tool_use') {
-                            toolName = block.name;
-                            toolInput = JSON.stringify(block.input);
-                        }
-                        else if (block.type === 'tool_result') {
-                            const resultStr = extractToolResultText(block.content);
-                            if (resultStr.length > TOOL_RESULT_TRUNCATE_LENGTH) {
-                                toolResult = resultStr.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]';
-                                truncated = true;
-                            }
-                            else {
-                                toolResult = resultStr;
-                            }
-                        }
-                    }
-                    content = parts.join('\n');
-                }
-            }
-            return {
-                index: tailStart + i,
-                role,
-                content,
-                toolName,
-                toolInput,
-                toolResult,
-                truncated,
-            };
-        });
-        return {
-            messages,
-            total,
-            hasMore: tailStart > 0,
-        };
-    }
     /**
      * Create a V2 session with the given cwd.
      * V2 SDKSessionOptions doesn't expose `cwd`, so we temporarily change
@@ -203,14 +258,42 @@ export class ClaudeCodeService extends EventEmitter {
                 model: opts.model ?? DEFAULT_MODEL,
                 allowedTools: opts.allowedTools ?? ['Read', 'Glob', 'Grep'],
                 permissionMode: 'default',
+                includePartialMessages: true,
                 settingSources: ['user', 'project', 'local'],
                 canUseTool: async (toolName, input, options) => {
-                    const resolvedSessionId = sessionId ?? 'unknown';
+                    // Resolve session ID: use mutable ref (updated when init arrives),
+                    // fall back to static closure, await deferred if still unknown.
+                    let resolvedSessionId = opts.sessionIdRef?.current ?? sessionId;
+                    if (!resolvedSessionId && opts.sessionIdRef?.promise) {
+                        resolvedSessionId = await opts.sessionIdRef.promise;
+                    }
+                    resolvedSessionId = resolvedSessionId ?? 'unknown';
                     // Check runtime permission level — auto-approve if tool is in the allow set
                     const ps = resolvedSessionId !== 'unknown' ? this.sessions.get(resolvedSessionId) : undefined;
-                    const level = ps?.permissionLevel ?? 'acceptEdits';
+                    const level = ps?.permissionLevel ?? this.sessionPermissions.get(resolvedSessionId) ?? 'acceptEdits';
                     if (AUTO_APPROVE[level].has(toolName)) {
-                        return { behavior: 'allow', updatedInput: input };
+                        // For file-writing tools, restrict auto-approval to paths inside the project cwd
+                        const FILE_WRITE_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
+                        if (FILE_WRITE_TOOLS.has(toolName)) {
+                            const filePath = (input.file_path ?? input.path);
+                            if (filePath) {
+                                const resolvedFile = resolve(filePath);
+                                const resolvedCwd = resolve(cwd);
+                                const inScope = resolvedFile === resolvedCwd || resolvedFile.startsWith(resolvedCwd + '/');
+                                if (!inScope) {
+                                    // Fall through to permission prompt below
+                                }
+                                else {
+                                    return { behavior: 'allow', updatedInput: input };
+                                }
+                            }
+                            else {
+                                return { behavior: 'allow', updatedInput: input };
+                            }
+                        }
+                        else {
+                            return { behavior: 'allow', updatedInput: input };
+                        }
                     }
                     const requestId = `perm-${++this.requestCounter}`;
                     // AskUserQuestion: forward as question type with options
@@ -229,6 +312,8 @@ export class ClaudeCodeService extends EventEmitter {
                             : (options.description ?? JSON.stringify(input).slice(0, 500)),
                         toolName,
                         toolInput: input,
+                        toolUseId: options.toolUseID,
+                        ...(options.agentID ? { agentId: options.agentID } : {}),
                         // Include structured options for question type
                         ...(isQuestion && questions ? {
                             options: questions.flatMap((q) => (q.options ?? []).map((opt) => ({
@@ -238,10 +323,30 @@ export class ClaudeCodeService extends EventEmitter {
                             }))),
                         } : {}),
                     };
+                    // Card-based: create/attach pending input on the correct card
+                    const builder = ps?.cardBuilder;
+                    if (builder) {
+                        const pendingAttachment = {
+                            sessionId: resolvedSessionId,
+                            requestId,
+                            inputType: request.inputType,
+                            title: request.title,
+                            message: request.message,
+                            options: request.options,
+                        };
+                        // Every permission gets its own ToolCallCard.
+                        // Subagent permissions are ephemeral — removed after resolution
+                        // (the tool runs in the sidechain, so no result will arrive).
+                        const ephemeral = !!options.agentID;
+                        const cardEvt = builder.toolCallFromPermission(toolName, input, options.toolUseID, pendingAttachment, ephemeral);
+                        this.emit('card-event', cardEvt);
+                    }
                     this.emit('user-input-request', request);
+                    // Register pending BEFORE emitting session-updated so hasPendingInput is true
+                    const responsePromise = this.waitForUserInput(requestId, request, options.signal);
                     this.emitSessionUpdate(resolvedSessionId);
                     // Wait for explicit user response (no timeout — user must act)
-                    const response = await this.waitForUserInput(requestId, request, options.signal);
+                    const response = await responsePromise;
                     if (response.action === 'deny') {
                         return { behavior: 'deny', message: 'User denied permission' };
                     }
@@ -287,6 +392,13 @@ export class ClaudeCodeService extends EventEmitter {
             return false;
         this.pendingInputRequests.delete(response.requestId);
         pending.resolve(response);
+        // Clear pending input on the card
+        const ps = this.sessions.get(pending.request.sessionId);
+        if (ps?.cardBuilder) {
+            const cardEvt = ps.cardBuilder.clearPendingInput(response.requestId);
+            if (cardEvt)
+                this.emit('card-event', cardEvt);
+        }
         this.emit('user-input-resolved', { requestId: response.requestId, sessionId: pending.request.sessionId });
         this.emitSessionUpdate(pending.request.sessionId);
         return true;
@@ -297,121 +409,180 @@ export class ClaudeCodeService extends EventEmitter {
     getPendingInputRequests() {
         return Array.from(this.pendingInputRequests.values()).map((p) => p.request);
     }
+    /** Debug snapshot of pending inputs and active sessions. */
+    getDebugState() {
+        const pendingInputs = Array.from(this.pendingInputRequests.values()).map((p) => ({
+            requestId: p.request.requestId,
+            sessionId: p.request.sessionId,
+            toolName: p.request.toolName,
+            agentId: p.request.agentId,
+            inputType: p.request.inputType,
+        }));
+        return { pendingInputs, activeSessions: this.getActiveSessions() };
+    }
     async startSession(opts) {
         const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan'];
         const level = validModes.includes(opts.permissionMode)
             ? opts.permissionMode : 'acceptEdits';
+        // Mutable ref so canUseTool can access the real sessionId once init arrives
+        const deferred = createDeferred();
+        const sessionIdRef = { current: null, promise: deferred.promise };
         const session = this.createSessionWithCwd(opts.cwd, null, {
             allowedTools: opts.allowedTools,
             model: opts.model,
             permissionMode: opts.permissionMode,
+            sessionIdRef,
         });
         const prompt = opts.systemPrompt
             ? `[System context: ${opts.systemPrompt}]\n\n${opts.prompt}`
             : opts.prompt;
         await session.send(prompt);
-        this.emit('stream', {
-            sessionId: '', streamId: opts.streamId,
-            eventType: 'user_message',
-            content: opts.prompt,
-        });
-        const sessionId = await new Promise((resolve) => {
-            this.consumeStream(session, opts.streamId, (id) => {
+        // Create the stream generator ONCE — reused by processTurnLoop.
+        // IMPORTANT: Do NOT use for-await+break to consume init, because break
+        // calls generator.return() which closes the generator permanently.
+        const streamGen = session.stream();
+        // Pull messages manually until we get the init message
+        let sessionId;
+        while (!sessionId) {
+            const { value: message, done } = await streamGen.next();
+            if (done)
+                throw new Error('Stream ended before init message');
+            if (message.type === 'system' && message.subtype === 'init') {
+                const id = message.session_id;
+                sessionIdRef.current = id;
+                deferred.resolve(id);
+                this.sessionPermissions.set(id, level);
                 this.sessions.set(id, {
                     session,
                     sessionId: id,
+                    sessionIdRef,
                     cwd: opts.cwd,
                     streaming: true,
-                    cancelStreaming: null,
                     permissionLevel: level,
+                    cardBuilder: null,
+                    _promptQueue: [],
+                    _cancelled: false,
+                    _loopRunning: false,
+                    _streamGenerator: streamGen,
                 });
                 this.emitSessionUpdate(id);
-                resolve(id);
-            });
-        });
+                sessionId = id;
+            }
+        }
+        // Seed the queue with the initial streamId (prompt already sent via session.send())
+        const ps = this.sessions.get(sessionId);
+        ps._promptQueue.push({ prompt: '', streamId: opts.streamId });
+        // Start the turn loop (reuses the same streamGen — picks up remaining messages)
+        this.processTurnLoop(sessionId);
         return sessionId;
     }
     async resumeSession(opts) {
         const existing = this.sessions.get(opts.sessionId);
         if (existing) {
-            console.log(`[v2] hot resume session=${opts.sessionId}`);
-            existing.streaming = true;
-            this.emitSessionUpdate(opts.sessionId);
-            this.emit('stream', {
-                sessionId: opts.sessionId, streamId: opts.streamId,
-                eventType: 'user_message',
-                content: opts.prompt,
-            });
-            await existing.session.send(opts.prompt);
-            this.consumeStream(existing.session, opts.streamId, () => {
-                // Session ID already captured
-            });
+            // Hot resume — push to queue
+            console.log(`[v2] hot resume (enqueue) session=${opts.sessionId}`);
+            existing._promptQueue.push({ prompt: opts.prompt, streamId: opts.streamId });
+            // If not looping, start the loop
+            if (!existing._loopRunning) {
+                this.processTurnLoop(opts.sessionId);
+            }
             return opts.sessionId;
         }
+        // Cold resume: create new session with resumeSessionId
         console.log(`[v2] cold resume session=${opts.sessionId}`);
+        const deferred = createDeferred();
+        const sessionIdRef = { current: opts.sessionId, promise: deferred.promise };
+        deferred.resolve(opts.sessionId); // already known for resume
+        const restoredLevel = this.sessionPermissions.get(opts.sessionId) ?? 'acceptEdits';
         const session = this.createSessionWithCwd(opts.cwd, opts.sessionId, {
             resumeSessionId: opts.sessionId,
-        });
-        this.emit('stream', {
-            sessionId: opts.sessionId, streamId: opts.streamId,
-            eventType: 'user_message',
-            content: opts.prompt,
+            sessionIdRef,
         });
         await session.send(opts.prompt);
-        const actualSessionId = await new Promise((resolve) => {
-            this.consumeStream(session, opts.streamId, (id) => {
+        // Create the stream generator ONCE — reused by processTurnLoop.
+        // Use manual .next() to avoid for-await+break closing the generator.
+        const streamGen = session.stream();
+        let actualSessionId;
+        while (!actualSessionId) {
+            const { value: message, done } = await streamGen.next();
+            if (done)
+                throw new Error('Stream ended before init message');
+            if (message.type === 'system' && message.subtype === 'init') {
+                const id = message.session_id;
                 if (id !== opts.sessionId) {
-                    this.emit('stream', {
-                        sessionId: id, streamId: opts.streamId,
-                        eventType: 'system',
-                        content: `Warning: SDK created new session ${id} instead of resuming ${opts.sessionId}`,
-                    });
+                    console.warn(`[v2] SDK created new session ${id} instead of resuming ${opts.sessionId}`);
                 }
+                sessionIdRef.current = id;
+                this.sessionPermissions.set(id, restoredLevel);
                 this.sessions.set(id, {
                     session,
                     sessionId: id,
+                    sessionIdRef,
                     cwd: opts.cwd,
                     streaming: true,
-                    cancelStreaming: null,
-                    permissionLevel: 'acceptEdits',
+                    permissionLevel: restoredLevel,
+                    cardBuilder: null,
+                    _promptQueue: [],
+                    _cancelled: false,
+                    _loopRunning: false,
+                    _streamGenerator: streamGen,
                 });
                 this.emitSessionUpdate(id);
-                resolve(id);
-            });
-        });
+                actualSessionId = id;
+            }
+        }
+        // Seed the queue (prompt already sent)
+        const ps = this.sessions.get(actualSessionId);
+        ps._promptQueue.push({ prompt: '', streamId: opts.streamId });
+        // Start the turn loop (reuses same streamGen)
+        this.processTurnLoop(actualSessionId);
         return actualSessionId;
     }
     cancelSession(sessionId) {
         const ps = this.sessions.get(sessionId);
         if (!ps)
             return false;
-        // Stop streaming but keep the session process alive
-        if (ps.cancelStreaming) {
-            ps.cancelStreaming();
-        }
+        ps._cancelled = true;
+        ps._promptQueue.length = 0; // drain queue
         ps.streaming = false;
         return true;
     }
     setPermissionLevel(sessionId, level) {
         const ps = this.sessions.get(sessionId);
-        if (!ps)
-            return false;
-        ps.permissionLevel = level;
-        this.emitSessionUpdate(sessionId);
+        if (ps) {
+            ps.permissionLevel = level;
+        }
+        // Persist across active/inactive lifecycle
+        this.sessionPermissions.set(sessionId, level);
+        // Always broadcast so all clients sync, even for inactive sessions
+        this.emit('session-updated', {
+            sessionId,
+            isActive: !!ps,
+            isStreaming: ps?.streaming ?? false,
+            hasPendingInput: ps ? Array.from(this.pendingInputRequests.values()).some((p) => p.request.sessionId === sessionId) : false,
+            permissionMode: level,
+        });
         return true;
     }
     getPermissionLevel(sessionId) {
         return this.sessions.get(sessionId)?.permissionLevel ?? 'acceptEdits';
     }
+    getActiveSessions() {
+        const pendingSessionIds = new Set(Array.from(this.pendingInputRequests.values()).map((p) => p.request.sessionId));
+        return Array.from(this.sessions.entries()).map(([id, ps]) => ({
+            sessionId: id,
+            cwd: ps.cwd,
+            isStreaming: ps.streaming,
+            hasPendingInput: pendingSessionIds.has(id),
+            permissionMode: ps.permissionLevel,
+        }));
+    }
     closeSession(sessionId) {
         const ps = this.sessions.get(sessionId);
         if (!ps)
             return false;
-        // Stop streaming if active
-        if (ps.cancelStreaming) {
-            ps.cancelStreaming();
-        }
-        // Terminate the subprocess
+        ps._cancelled = true;
+        ps._promptQueue.length = 0;
         ps.session.close();
         this.sessions.delete(sessionId);
         this.emitSessionUpdate(sessionId);
@@ -442,160 +613,256 @@ export class ClaudeCodeService extends EventEmitter {
         }
         this.sessions.clear();
     }
-    async consumeStream(session, streamId, onSessionId) {
-        let textBuffer = '';
-        let bufferTimer = null;
-        let capturedSessionId = null;
-        let cancelled = false;
-        const emitStream = (event) => {
-            this.emit('stream', { ...event, sessionId: capturedSessionId ?? '', streamId });
-        };
-        const flushText = () => {
-            if (textBuffer) {
-                emitStream({ eventType: 'assistant_text', content: textBuffer });
-                textBuffer = '';
-            }
-            if (bufferTimer) {
-                clearTimeout(bufferTimer);
-                bufferTimer = null;
-            }
-        };
-        const markStreamingDone = () => {
-            if (capturedSessionId) {
-                const ps = this.sessions.get(capturedSessionId);
-                if (ps) {
-                    ps.streaming = false;
-                    ps.cancelStreaming = null;
-                }
-                this.emitSessionUpdate(capturedSessionId);
-            }
-        };
-        const bufferText = (text) => {
-            textBuffer += text;
-            if (!bufferTimer) {
-                bufferTimer = setTimeout(flushText, 150);
-            }
-            if (textBuffer.length > 2048) {
-                flushText();
+    /** Get the CardBuilder for a session (if streaming). Used by canUseTool. */
+    getCardBuilder(sessionId) {
+        return this.sessions.get(sessionId)?.cardBuilder ?? null;
+    }
+    /** Get card-based history for a session. */
+    async getCards(sessionId, cwd, offset = 0, limit = 50) {
+        // Always use JSONL as the source of truth for history.
+        // Overlay pendingInput from in-memory state (only matters during permission prompts).
+        const result = await buildCardsFromHistory(sessionId, cwd, offset, limit);
+        // Attach pendingInput to matching tool cards
+        const pendingByToolUseId = new Map();
+        for (const [, pending] of this.pendingInputRequests) {
+            if (pending.request.sessionId === sessionId && pending.request.toolUseId) {
+                pendingByToolUseId.set(pending.request.toolUseId, {
+                    sessionId: pending.request.sessionId,
+                    requestId: pending.request.requestId,
+                    inputType: pending.request.inputType,
+                    title: pending.request.title,
+                    message: pending.request.message,
+                    options: pending.request.options,
+                });
             }
-        };
-        // Wire up cancel function for this streaming turn
-        const setCancelFn = () => {
-            if (capturedSessionId) {
-                const ps = this.sessions.get(capturedSessionId);
-                if (ps) {
-                    ps.cancelStreaming = () => { cancelled = true; };
+        }
+        if (pendingByToolUseId.size > 0) {
+            for (const card of result.cards) {
+                if (card.type === 'tool_call' && card.toolUseId) {
+                    const pending = pendingByToolUseId.get(card.toolUseId);
+                    if (pending)
+                        card.pendingInput = pending;
                 }
             }
-        };
+        }
+        return result;
+    }
+    /**
+     * Turn loop: dequeue prompt → send() → consume stream → on result, check queue → repeat.
+     * The first entry may have an empty prompt (already sent by startSession/resumeSession).
+     */
+    async processTurnLoop(sessionId) {
+        const ps = this.sessions.get(sessionId);
+        if (!ps || ps._loopRunning)
+            return;
+        ps._loopRunning = true;
+        let textBuffer = '';
+        let bufferTimer = null;
+        const emitCard = (event) => { this.emit('card-event', event); };
+        // Create cardBuilder once, reuse across turns (accumulates all cards)
+        if (!ps.cardBuilder) {
+            ps.cardBuilder = new StreamCardBuilder(sessionId, '');
+        }
         try {
-            for await (const message of session.stream()) {
-                if (cancelled)
-                    break;
-                // Capture session ID from init message
-                if (message.type === 'system' && message.subtype === 'init') {
-                    capturedSessionId = message.session_id;
-                    console.log(`[stream] init session=${message.session_id}`);
-                    onSessionId(message.session_id);
-                    setCancelFn();
-                    continue;
+            while (ps._promptQueue.length > 0) {
+                const { prompt, streamId } = ps._promptQueue.shift();
+                ps._cancelled = false;
+                ps.streaming = true;
+                const cb = ps.cardBuilder;
+                cb.startNewTurn(streamId);
+                this.emitSessionUpdate(sessionId);
+                // Reset text buffering for this turn
+                textBuffer = '';
+                if (bufferTimer) {
+                    clearTimeout(bufferTimer);
+                    bufferTimer = null;
                 }
-                // Session state changed — 'idle' means turn is over
-                if (message.type === 'system' && message.subtype === 'session_state_changed') {
-                    const state = message.state;
-                    if (state === 'idle') {
+                const flushText = () => {
+                    if (textBuffer) {
+                        console.log(`[stream] flushText len=${textBuffer.length} session=${sessionId.slice(0, 8)}`);
+                        emitCard(cb.assistantText(textBuffer));
+                        textBuffer = '';
+                    }
+                    if (bufferTimer) {
+                        clearTimeout(bufferTimer);
+                        bufferTimer = null;
+                    }
+                };
+                const bufferText = (text) => {
+                    textBuffer += text;
+                    if (!bufferTimer) {
+                        bufferTimer = setTimeout(flushText, 150);
+                    }
+                    if (textBuffer.length > 2048) {
                         flushText();
-                        console.log(`[stream] session_state_changed=idle session=${capturedSessionId}`);
-                        // Don't call onEnd here — the result message will follow
                     }
-                    continue;
+                };
+                // Send prompt if non-empty (empty means prompt was already sent before loop started)
+                if (prompt) {
+                    emitCard(cb.userMessage(prompt));
+                    await ps.session.send(prompt);
+                    // New turn = new generator (v2 API: one stream() call per send())
+                    ps._streamGenerator = ps.session.stream();
                 }
-                // Streaming partial events
-                if (message.type === 'stream_event') {
-                    const event = message.event;
-                    if (event?.type === 'content_block_delta') {
-                        const delta = event.delta;
-                        if (delta?.type === 'text_delta' && delta.text) {
-                            bufferText(delta.text);
-                        }
-                    }
-                    continue;
+                // Consume this turn's stream using manual .next() to avoid
+                // for-await+break calling generator.return() which kills the stream.
+                const gen = ps._streamGenerator;
+                if (!gen) {
+                    console.error(`[stream] no generator for session=${sessionId}`);
+                    break;
                 }
-                // Complete assistant messages
-                if (message.type === 'assistant') {
-                    flushText();
-                    const betaMessage = message.message;
-                    if (betaMessage?.content) {
-                        for (const block of betaMessage.content) {
-                            if (block.type === 'text' && block.text) {
-                                emitStream({
-                                    eventType: 'assistant_text',
-                                    content: block.text,
-                                });
+                let turnDone = false;
+                try {
+                    while (!turnDone && !ps._cancelled) {
+                        const { value: message, done } = await gen.next();
+                        if (done) {
+                            turnDone = true;
+                            break;
+                        }
+                        // Subagent lifecycle events
+                        if (message.type === 'system' && message.subtype === 'task_started') {
+                            const m = message;
+                            flushText();
+                            emitCard(cb.subagentStart(m.description ?? '', m.task_id, m.tool_use_id));
+                            continue;
+                        }
+                        if (message.type === 'system' && message.subtype === 'task_progress') {
+                            const m = message;
+                            const cardEvt = cb.subagentProgress(m.task_id, m.tool_use_id, m.usage?.tool_uses, m.last_tool_name);
+                            if (cardEvt)
+                                emitCard(cardEvt);
+                            continue;
+                        }
+                        if (message.type === 'system' && message.subtype === 'task_notification') {
+                            const m = message;
+                            const cardEvt = cb.subagentEnd(m.task_id, m.tool_use_id, m.status, m.summary);
+                            if (cardEvt)
+                                emitCard(cardEvt);
+                            continue;
+                        }
+                        // Session state changed — 'idle' means turn is over
+                        if (message.type === 'system' && message.subtype === 'session_state_changed') {
+                            const state = message.state;
+                            if (state === 'idle') {
+                                flushText();
+                                console.log(`[stream] session_state_changed=idle session=${sessionId}`);
+                            }
+                            continue;
+                        }
+                        // Streaming partial events
+                        if (message.type === 'stream_event') {
+                            const event = message.event;
+                            if (event?.type === 'content_block_delta') {
+                                const delta = event.delta;
+                                if (delta?.type === 'text_delta' && delta.text) {
+                                    bufferText(delta.text);
+                                }
                             }
-                            else if (block.type === 'tool_use') {
-                                const toolInput = JSON.stringify(block.input);
-                                emitStream({
-                                    eventType: 'tool_use',
-                                    content: '',
-                                    toolName: block.name,
-                                    toolInput,
-                                });
+                            else if (!event?.type?.includes('delta')) {
+                                console.log(`[stream] stream_event type=${event?.type} session=${sessionId.slice(0, 8)}`);
                             }
+                            continue;
                         }
-                    }
-                    continue;
-                }
-                // User messages contain tool results
-                if (message.type === 'user') {
-                    const userMsg = message.message;
-                    if (userMsg?.content && Array.isArray(userMsg.content)) {
-                        for (const block of userMsg.content) {
-                            if (block.type === 'tool_result') {
-                                const resultContent = extractToolResultText(block.content);
-                                const truncated = resultContent.length > TOOL_RESULT_TRUNCATE_LENGTH
-                                    ? resultContent.slice(0, TOOL_RESULT_TRUNCATE_LENGTH) + ' [truncated]'
-                                    : resultContent;
-                                emitStream({
-                                    eventType: 'tool_result',
-                                    content: truncated,
-                                });
+                        // Complete assistant messages — skip sidechain (subagent) messages.
+                        if (message.type === 'assistant') {
+                            if (message.agentId)
+                                continue; // sidechain message — ignore
+                            flushText();
+                            const betaMessage = message.message;
+                            const blocks = betaMessage?.content ?? [];
+                            for (const block of blocks) {
+                                if (block.type === 'thinking' && block.thinking) {
+                                    emitCard(cb.thinkingBlock(block.thinking));
+                                }
+                                else if (block.type === 'redacted_thinking') {
+                                    emitCard(cb.thinkingBlock('[Redacted thinking]'));
+                                }
+                                else if (block.type === 'text' && block.text) {
+                                    emitCard(cb.assistantText(block.text));
+                                }
+                                else if (block.type === 'tool_use') {
+                                    // Agent tool calls are represented by SubagentCards (via task_started).
+                                    if (block.name !== 'Agent') {
+                                        emitCard(cb.toolUse(block.name, block.input ?? {}, block.id));
+                                    }
+                                }
+                                else if (block.type === 'server_tool_use' || block.type === 'mcp_tool_use') {
+                                    emitCard(cb.toolUse(block.name ?? block.type, block.input ?? {}, block.id ?? ''));
+                                }
+                            }
+                            continue;
+                        }
+                        // User messages contain tool results — skip sidechain messages.
+                        if (message.type === 'user') {
+                            if (message.agentId)
+                                continue; // sidechain message — ignore
+                            const userMsg = message.message;
+                            if (userMsg?.content && Array.isArray(userMsg.content)) {
+                                for (const block of userMsg.content) {
+                                    if (block.type === 'tool_result') {
+                                        const resultContent = extractToolResultText(block.content);
+                                        const cardEvt = cb.toolResult(block.tool_use_id, resultContent, !!block.is_error);
+                                        if (cardEvt)
+                                            emitCard(cardEvt);
+                                    }
+                                    // Handle server/MCP tool results in streaming
+                                    if (block.type === 'web_search_tool_result' || block.type === 'web_fetch_tool_result' ||
+                                        block.type === 'mcp_tool_result' || block.type === 'code_execution_tool_result' ||
+                                        block.type === 'tool_search_tool_result') {
+                                        const resultContent = extractToolResultText(block.content ?? block.text ?? '');
+                                        const parentId = block.tool_use_id;
+                                        if (parentId) {
+                                            const cardEvt = cb.toolResult(parentId, resultContent, !!block.is_error);
+                                            if (cardEvt)
+                                                emitCard(cardEvt);
+                                        }
+                                    }
+                                }
+                            }
+                            continue;
+                        }
+                        // ── Result — exit this turn's stream, loop will check queue ──
+                        if (message.type === 'result') {
+                            if (message.session_id !== sessionId) {
+                                console.log(`[stream] skip subagent result session=${message.session_id?.slice(0, 8)}`);
+                                continue;
                             }
+                            flushText();
+                            const result = message;
+                            console.log(`[stream] result session=${sessionId} subtype=${result.subtype} cost=$${result.total_cost_usd?.toFixed(4) ?? '?'}`);
+                            const streamEnd = {
+                                streamId,
+                                sessionId,
+                                success: result.subtype === 'success',
+                                error: result.subtype !== 'success'
+                                    ? (result.errors?.join('; ') || `Session ended: ${result.subtype}`)
+                                    : undefined,
+                                totalCostUsd: result.total_cost_usd,
+                                tokenUsage: result.usage
+                                    ? { input: result.usage.input_tokens, output: result.usage.output_tokens }
+                                    : undefined,
+                            };
+                            this.emit('card-stream-end', streamEnd);
+                            turnDone = true; // exit this turn's stream without closing generator
                         }
                     }
-                    continue;
                 }
-                // Final result — turn is complete but session stays alive
-                if (message.type === 'result') {
+                catch (error) {
                     flushText();
-                    const result = message;
-                    console.log(`[stream] result session=${capturedSessionId} subtype=${result.subtype} cost=$${result.total_cost_usd?.toFixed(4) ?? '?'}`);
-                    markStreamingDone();
-                    this.emit('stream:end', {
-                        sessionId: capturedSessionId ?? '', streamId,
-                        success: result.subtype === 'success',
-                        error: result.subtype !== 'success'
-                            ? (result.errors?.join('; ') || `Session ended: ${result.subtype}`)
-                            : undefined,
-                        totalCostUsd: result.total_cost_usd,
-                        tokenUsage: result.usage
-                            ? { input: result.usage.input_tokens, output: result.usage.output_tokens }
-                            : undefined,
-                    });
-                    return;
+                    console.error(`[stream] error session=${sessionId}:`, error);
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    this.emit('card-stream-end', { streamId, sessionId, success: false, error: msg });
                 }
+                // Turn done — finalize text, keep cardBuilder (accumulates across turns)
+                const finalizeEvent = cb.finalizeAssistantText();
+                if (finalizeEvent)
+                    emitCard(finalizeEvent);
+                ps.streaming = false;
+                this.emitSessionUpdate(sessionId);
             }
-            flushText();
-            console.log(`[stream] ended without result session=${capturedSessionId} (cancel or unexpected)`);
-            markStreamingDone();
-            this.emit('stream:end', { sessionId: capturedSessionId ?? '', streamId, success: true });
         }
-        catch (error) {
-            flushText();
-            console.error(`[stream] error session=${capturedSessionId}:`, error);
-            markStreamingDone();
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            this.emit('stream:end', { sessionId: capturedSessionId ?? '', streamId, success: false, error: msg });
+        finally {
+            ps._loopRunning = false;
         }
     }
 }