@hienlh/ppm 0.9.0-beta.3 → 0.9.0-beta.4

package/docs/system-architecture.md

@@ -205,7 +205,47 @@ interface AIProvider {
 **Implementations:**
 - **claude-agent-sdk** (Primary) — @anthropic-ai/claude-agent-sdk, streaming, tool use. Reads model/effort/maxTurns/budget/thinking from config. Settings refreshed per query. Windows CLI fallback for Bun subprocess pipe issues. .env poisoning mitigation. **Multi-account support:** Injects account API token from AccountService instead of relying on ANTHROPIC_API_KEY env var when accounts configured.
 - **mock-provider** (Testing) — Returns canned responses
-- **Note:** CLI provider removed (v2); agent SDK is sole AI provider with Windows CLI fallback
+- **cursor-cli** (CLI-based) — Spawns `cursor-agent` CLI binary with NDJSON streaming. Extends `CliProvider` base class.
+- **codex/gemini** (Planned) — Pluggable via `CliProvider` extension (~100-150 lines each)
+
+#### Multi-Provider Architecture (v0.8.61+)
+
+PPM supports multiple AI providers through a generic `AIProvider` interface and extensible base classes:
+
+**Provider Types:**
+1. **SDK-based** (claude-agent-sdk) — Uses Anthropic SDK for rich features (approvals, thinking blocks)
+2. **CLI-based** (cursor-cli, codex, gemini) — Spawns external binary with NDJSON streaming
+
+**Base Classes:**
+- `AIProvider` interface — Defines required methods (createSession, sendMessage) + optional capabilities (abortQuery, getMessages, listSessionsByDir, ensureProjectPath)
+- `CliProvider` abstract class — Shared spawn/parse/abort logic for all CLI-spawning providers
+- Provider-specific subclasses implement: `buildArgs()`, `mapEvent()`, `extractSessionId()`, `isAvailable()`
+
+**Streaming Infrastructure:**
+- `parseNdjsonLines()` utility — Async generator that buffers partial TCP packets, yields complete JSON lines
+- `ChatEvent` union type — Normalized event format across all providers (text, tool_use, thinking, approval_request, system, done, error)
+- Event mappers translate provider-specific JSON → ChatEvent (e.g., Cursor's `reasoning` type → `thinking` event)
+
+**Provider Registration & Bootstrap:**
+- `ProviderRegistry` maintains active provider instances
+- `bootstrapProviders()` async function checks `isAvailable()` on CLI providers before registering
+- Graceful fallback: if Cursor binary not found, provider skips registration (no crash, logged as info)
+- Config type `AIProviderConfig.type` union: `"agent-sdk" | "cli" | "mock"`
+
+**CLI-Provider Features:**
+- **Session capture** — Extract session ID from provider's init event, re-key process tracking
+- **Workspace trust auto-retry** — Detect trust prompts in stderr, retry once with `--trust` flag
+- **Process lifecycle** — Track active processes per session, escalate SIGTERM → SIGKILL on abort
+- **History loading** — Override `listSessions()` to read native provider history (e.g., Cursor SQLite DAG)
+- **Graceful degradation** — Missing binary → provider skipped, not fatal
+
+**New Files (v0.8.61):**
+- `src/utils/ndjson-line-parser.ts` — NDJSON streaming parser
+- `src/providers/cli-provider-base.ts` — Abstract base class for CLI providers
+- `src/providers/cursor-cli/cursor-provider.ts` — CursorCliProvider implementation
+- `src/providers/cursor-cli/cursor-event-mapper.ts` — NDJSON → ChatEvent mapping
+- `src/providers/cursor-cli/cursor-history.ts` — SQLite DAG reader for Cursor history
+- `src/web/components/chat/provider-selector.tsx` — UI component for provider selection
 
 ---
 
@@ -453,7 +493,27 @@ Returns full updated config. Validates ranges/enums before writing.
 
 ---
 
-## Chat Streaming Flow
+## Chat Streaming Flow (Persistent AsyncGenerator Sessions)
+
+### Architecture Overview (v0.8.55+)
+
+PPM uses a **persistent streaming session** model instead of per-message query execution:
+
+**Key Changes:**
+- Provider maintains **long-lived AsyncGenerator streaming input** per chat session (not per message)
+- Follow-up messages **push into the existing generator** instead of abort-and-replace
+- **Single streaming loop** per session decoupled from WebSocket message handler
+- Message priority support: `now` (interrupt current), `next` (queue first), `later` (queue at end)
+- Supports image attachments in messages
+
+**Design Benefits:**
+- Continuous context preservation — multi-turn conversations flow naturally
+- No SDK subprocess restarts between messages (faster)
+- Clean separation: BE owns Claude connection, FE disconnect doesn't abort
+- Message buffering on reconnect — clients that lose WS connection sync turn events
+- Tool approvals don't restart the query — integrated into streaming loop
+
+### Message Flow
 
 ```
 User types: "Debug this function"
@@ -462,18 +522,26 @@ MessageInput.tsx calls useChat.sendMessage()
     ↓
 useChat opens WebSocket: WS /ws/project/:name/chat/:sessionId
     ↓
-Sends: { type: "message", content: "Debug..." }
+Sends: { type: "message", content: "Debug...", priority?: "now"|"next"|"later" }
+    ↓
+WS handler in chat.ts receives message
     ↓
-Server routes to ChatService.streamMessage()
+If already streaming with different content → abort previous + wait cleanup
+If streaming, new message priority determines queue behavior:
+    • priority: "now" → abort current, restart with new content
+    • priority: "next" → push into pending queue (higher priority)
+    • priority: "later" → push to end of queue (FIFO)
+    ↓
+runStreamLoop() executes in detached async context
     ↓
 ChatService calls provider.sendMessage() (async generator)
     ↓
-Provider (Claude SDK) streams response:
-    1. Yields: { type: "text", content: "Here's what..." }
-    2. Yields: { type: "text", content: " happens..." }
-    3. Yields: { type: "tool_use", tool: "read_file", input: {...} }
+Provider (Claude SDK) yields events:
+    1. { type: "text", content: "Here's what..." }
+    2. { type: "text", content: " happens..." }
+    3. { type: "tool_use", tool: "read_file", input: {...} }
     ↓
-ChatService wraps as WebSocket messages:
+Stream loop buffers + broadcasts to all connected clients:
     { type: "text", content: "Here's what..." }
     { type: "text", content: " happens..." }
     { type: "tool_use", tool: "read_file", input: {...} }
@@ -485,15 +553,112 @@ User sees tool approval prompt, clicks "Approve"
     ↓
 Client sends: { type: "approval_response", requestId, approved: true }
     ↓
-ChatService.onToolApproval() executes tool (file_read, git commands, etc.)
+Provider continues streaming with tool result (no restart)
     ↓
-Provider continues streaming with tool result
+If multiple messages queued, next message processes after done event
     ↓
 Final response streamed, then: { type: "done", sessionId }
     ↓
-useChat closes WebSocket, saves message to store
+Phase transitions to idle, clients can send new message
+    ↓
+useChat saves message to store, displays in chat history
 ```
 
+### Session State Management
+
+**Session Entry** (BE-owned, persists across FE disconnections):
+```typescript
+interface SessionEntry {
+  providerId: string;              // Which AI provider (e.g., "claude")
+  clients: Set<ChatWsSocket>;      // Connected FE clients (may be empty)
+  abort?: AbortController;         // Current stream abort handle
+  projectPath?: string;            // Project context
+  projectName?: string;
+  pingIntervals: Map<...>;         // Per-client keepalive
+  phase: SessionPhase;             // "initializing" | "connecting" | "thinking" | "streaming" | "idle"
+  cleanupTimer?: ReturnType<...>;  // Auto-cleanup if no FE reconnects (5min)
+  pendingApprovalEvent?: {...};    // Current tool approval waiting
+  turnEvents: unknown[];           // Buffered events (for reconnect sync)
+  streamPromise?: Promise<void>;   // Track ongoing runStreamLoop
+  permissionMode?: string;         // Sticky permission mode for session
+}
+```
+
+**Client Connection States:**
+- **Active streaming + FE connected** → Events broadcast to all clients in real-time
+- **Active streaming + FE disconnected** → Events buffered in turnEvents array, BE stream continues
+- **FE reconnects** → Receive session_state + buffered turnEvents, resync with stream
+- **Idle (no query running)** → Phase is "idle", ready for next message
+- **Idle + no FE for 5min** → Cleanup timer removes session from memory
+
+### Follow-up Messages
+
+**Abort-and-Replace Pattern:**
+```typescript
+if (entry.phase !== "idle" && entry.abort) {
+  console.log(`[chat] aborting current query for new message`);
+  entry.abort.abort();
+  await entry.streamPromise;  // Wait for cleanup
+  // Re-fetch entry — may have been mutated during cleanup
+  entry = activeSessions.get(sessionId)!;
+}
+```
+
+**Multiple Message Queueing:**
+- First message: immediately starts runStreamLoop
+- Second message (while streaming): abort current, wait, start new runStreamLoop
+- Priority modes (future): could queue messages for intelligent interleaving
+
+### WebSocket Reconnection Sync
+
+```
+FE WebSocket closes (network issue, tab closes)
+    ↓
+BE keeps session alive, streaming continues
+    ↓
+FE reconnects: WS /ws/project/:name/chat/:sessionId
+    ↓
+open() handler checks activeSessions.get(sessionId)
+    ↓
+If exists (entry found):
+    1. Clear cleanup timer (FE is back)
+    2. Send session_state with current phase + pendingApproval
+    3. If phase !== "idle", send buffered turnEvents
+    4. Add WS to clients Set
+    ↓
+FE processes session_state, renders current phase
+    ↓
+FE applies buffered events to rebuild turn state
+    ↓
+FE displays: "reconnected, current phase: streaming" etc.
+```
+
+### Phase Transitions
+
+```
+idle → initializing → connecting → thinking/streaming ↔ thinking/streaming → idle
+  ^                                      ↑                                    ↓
+  └──────────────────────────────────────────────────────────────────────────┘
+```
+
+**Phase Descriptions:**
+- **idle** — No query running, ready to accept new message
+- **initializing** — Preparing (permission checks, session resume)
+- **connecting** — Waiting for first SDK event (heartbeat: "connecting" with elapsed time every 5s)
+- **thinking** — Receiving thinking content (extended thinking)
+- **streaming** — Receiving text/tool_use content (dynamic switch between thinking/streaming)
+
+### Image Attachment Support
+
+Messages can now include images:
+```typescript
+type ChatWsClientMessage =
+  | { type: "message"; content: string; images?: { id: string; data: string }[]; priority?: string }
+  | ...
+```
+
+Images are passed to provider's message context and included in tool input/output.
+
 ---
 
 ## Terminal Flow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.9.0-beta.3",
+  "version": "0.9.0-beta.4",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

package/src/providers/claude-agent-sdk.ts

@@ -10,6 +10,7 @@ import type {
   SessionInfo,
   ChatEvent,
   ChatMessage,
+  ModelOption,
 } from "./provider.interface.ts";
 import { configService } from "../services/config.service.ts";
 import { updateFromSdkEvent } from "../services/claude-usage.service.ts";
@@ -24,84 +25,6 @@ function getSdkSessionId(ppmId: string): string {
   return getSessionMapping(ppmId) ?? ppmId;
 }
 
-// ── Streaming Input: message channel for persistent query ──
-
-interface MessageController {
-  push(msg: any): void;
-  done(): void;
-}
-
-function createMessageChannel(): {
-  generator: AsyncGenerator<any, void, undefined>;
-  controller: MessageController;
-} {
-  const queue: any[] = [];
-  let resolve: ((msg: any) => void) | null = null;
-  let isDone = false;
-
-  async function* gen(): AsyncGenerator<any, void, undefined> {
-    while (!isDone) {
-      if (queue.length > 0) {
-        yield queue.shift()!;
-      } else {
-        const msg = await new Promise<any>((r) => { resolve = r; });
-        if (!isDone) yield msg;
-      }
-    }
-  }
-
-  return {
-    generator: gen(),
-    controller: {
-      push(msg: any) {
-        if (isDone) return;
-        if (resolve) {
-          const r = resolve;
-          resolve = null;
-          r(msg);
-        } else {
-          queue.push(msg);
-        }
-      },
-      done() {
-        isDone = true;
-        if (resolve) {
-          const r = resolve;
-          resolve = null;
-          r(null); // Unblock pending promise; isDone prevents yield
-        }
-      },
-    },
-  };
-}
-
-/** Build a MessageParam with optional image content blocks */
-function buildMessageParam(
-  text: string,
-  images?: Array<{ data: string; mediaType: string }>,
-): { role: 'user'; content: string | any[] } {
-  if (!images || images.length === 0) {
-    return { role: 'user' as const, content: text };
-  }
-  const blocks: any[] = [];
-  for (const img of images) {
-    blocks.push({
-      type: 'image',
-      source: { type: 'base64', media_type: img.mediaType, data: img.data },
-    });
-  }
-  if (text.trim()) {
-    blocks.push({ type: 'text', text });
-  }
-  return { role: 'user' as const, content: blocks };
-}
-
-interface StreamingSession {
-  meta: Session;
-  query: any;
-  controller: MessageController;
-}
-
 /**
  * Pending approval: canUseTool callback creates a promise,
  * yields an approval_request event, then awaits resolution from FE.
@@ -127,8 +50,6 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   private activeQueries = new Map<string, { close: () => void }>();
   /** Fork source: ppmSessionId → sourceSessionId (used on first message to fork) */
   private forkSources = new Map<string, string>();
-  /** Streaming sessions: persistent query + message channel per session */
-  private streamingSessions = new Map<string, StreamingSession>();
 
   /** Auth-related env keys for diagnostic logging */
   private readonly AUTH_ENV_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN"];
@@ -299,7 +220,6 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   }
 
   async deleteSession(sessionId: string): Promise<void> {
-    this.closeStreamingSession(sessionId);
     this.activeSessions.delete(sessionId);
     this.messageCount.delete(sessionId);
   }
@@ -320,6 +240,14 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     this.forkSources.set(sessionId, sourceSessionId);
   }
 
+  async listModels(): Promise<ModelOption[]> {
+    return [
+      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+      { value: "claude-opus-4-6", label: "Claude Opus 4.6" },
+      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5" },
+    ];
+  }
+
   /**
    * Resolve a pending approval from FE (tool approval or AskUserQuestion answer).
    * Called by WS handler when client sends approval_response.
@@ -332,63 +260,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     }
   }
 
-  /**
-   * Push a follow-up message into an existing streaming session's generator.
-   * Called by WS handler for follow-up messages (Phase 2).
-   */
-  pushMessage(sessionId: string, content: string, opts?: { priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> }): void {
-    const ss = this.streamingSessions.get(sessionId);
-    if (!ss) {
-      console.warn(`[sdk] pushMessage: no streaming session for ${sessionId}`);
-      return;
-    }
-    const msgContent = buildMessageParam(content, opts?.images);
-    ss.controller.push({
-      type: 'user',
-      message: msgContent,
-      parent_tool_use_id: null,
-      session_id: sessionId,
-      priority: opts?.priority ?? 'next',
-    });
-    console.log(`[sdk] pushMessage: session=${sessionId} priority=${opts?.priority ?? 'next'}`);
-  }
-
-  /** Close a streaming session — generator + query cleanup */
-  closeStreamingSession(sessionId: string): void {
-    const ss = this.streamingSessions.get(sessionId);
-    if (ss) {
-      ss.controller.done();
-      ss.query.close();
-      this.streamingSessions.delete(sessionId);
-      console.log(`[sdk] closeStreamingSession: session=${sessionId}`);
-    }
-  }
-
-  /** Check if a streaming session is active for a given session ID */
-  hasStreamingSession(sessionId: string): boolean {
-    return this.streamingSessions.has(sessionId);
-  }
-
   async *sendMessage(
     sessionId: string,
     message: string,
-    opts?: import("./provider.interface.ts").SendMessageOpts & { forkSession?: boolean; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> },
+    opts?: import("./provider.interface.ts").SendMessageOpts & { forkSession?: boolean },
   ): AsyncIterable<ChatEvent> {
-    // Follow-up: push into existing streaming session, yield nothing
-    const existingStream = this.streamingSessions.get(sessionId);
-    if (existingStream) {
-      const msgContent = buildMessageParam(message, opts?.images);
-      existingStream.controller.push({
-        type: 'user',
-        message: msgContent,
-        parent_tool_use_id: null,
-        session_id: sessionId,
-        priority: opts?.priority ?? 'next',
-      });
-      console.log(`[sdk] sendMessage follow-up: session=${sessionId} pushed to generator`);
-      return; // Events flow through first-message's consumer loop
-    }
-
     if (!this.activeSessions.has(sessionId)) {
       await this.resumeSession(sessionId);
     }
@@ -511,7 +387,6 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     let resultSubtype: string | undefined;
     let resultNumTurns: number | undefined;
     let resultContextWindowPct: number | undefined;
-    let yieldedDone = false;
     try {
       // Resolve SDK's actual session ID for resume (may differ from PPM's UUID)
       // For fork: use the source session's SDK id
@@ -583,25 +458,14 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         includePartialMessages: true,
       };
 
-      // Streaming input: create message channel and persistent query
-      const { generator: streamGen, controller: streamCtrl } = createMessageChannel();
-      const firstMsg = {
-        type: 'user' as const,
-        message: buildMessageParam(message),
-        parent_tool_use_id: null,
-        session_id: sessionId,
-      };
-      streamCtrl.push(firstMsg);
-
       const q = query({
-        prompt: streamGen,
+        prompt: message,
         options: {
           ...queryOptions,
           ...(permissionHooks && { hooks: permissionHooks }),
           canUseTool,
         } as any,
       });
-      this.streamingSessions.set(sessionId, { meta, query: q, controller: streamCtrl });
       this.activeQueries.set(sessionId, q);
       let eventSource: AsyncIterable<any> = q;
 
@@ -616,29 +480,22 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       let retryCount = 0;
       let authRetried = false;
 
-      let hadAnyEvents = false;
       retryLoop: while (true) {
       let sdkEventCount = 0;
       for await (const msg of eventSource) {
         sdkEventCount++;
-        hadAnyEvents = true;
         if (sdkEventCount === 1) {
           console.log(`[sdk] first event received: type=${(msg as any).type} subtype=${(msg as any).subtype ?? "none"}`);
           // Detect immediate failure: first event is a result with error + 0 turns
           if ((msg as any).type === "result" && (msg as any).subtype === "error_during_execution" && ((msg as any).num_turns ?? 0) === 0 && retryCount < MAX_RETRIES) {
             retryCount++;
             console.warn(`[sdk] transient error on first event — retrying (attempt ${retryCount}/${MAX_RETRIES})`);
-            // Close failed query and old channel, create new channel + query for retry
-            streamCtrl.done();
-            q.close();
-            const { generator: retryGen, controller: retryCtrl } = createMessageChannel();
-            retryCtrl.push(firstMsg);
+            // Re-create query for retry — don't reuse sessionId in case SDK partially created it
             const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined };
             const rq = query({
-              prompt: retryGen,
+              prompt: message,
               options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
             });
-            this.streamingSessions.set(sessionId, { meta, query: rq, controller: retryCtrl });
             this.activeQueries.set(sessionId, rq);
             eventSource = rq;
             continue retryLoop;
@@ -784,17 +641,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 const refreshedAccount = accountService.getWithTokens(account.id);
                 if (refreshedAccount) {
                   const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
-                  // Close failed query and old channel, create new channel + query with refreshed token
-                  streamCtrl.done();
-                  q.close();
-                  const { generator: authRetryGen, controller: authRetryCtrl } = createMessageChannel();
-                  authRetryCtrl.push(firstMsg);
                   const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined, env: retryEnv };
                   const rq = query({
-                    prompt: authRetryGen,
+                    prompt: message,
                     options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
                   });
-                  this.streamingSessions.set(sessionId, { meta, query: rq, controller: authRetryCtrl });
                   this.activeQueries.set(sessionId, rq);
                   eventSource = rq;
                   continue retryLoop;
@@ -866,9 +717,9 @@ export class ClaudeAgentSdkProvider implements AIProvider {
             const errCode = this.detectResultErrorCode(msg);
             if (errCode === 429) {
               accountSelector.onRateLimit(account.id);
-              // Post-stream 429 — surface error, continue waiting for next turn
+              // Post-stream 429 already has content — surface error to user
               yield { type: "error", message: "Rate limited. This account is now on cooldown. Please retry." };
-              continue;
+              break;
             } else if (errCode === 401) {
               // Try refresh once
               try {
@@ -976,26 +827,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               }
             }
           }
-
-          // Streaming input: yield done for this turn, then continue for next turn
-          yieldedDone = true;
-          yield {
-            type: "done",
-            sessionId,
-            resultSubtype: resultSubtype as any,
-            numTurns: resultNumTurns,
-            contextWindowPct: resultContextWindowPct,
-          };
-
-          // Reset per-turn state for next turn
-          lastPartialText = "";
-          pendingToolCount = 0;
-          assistantContent = "";
-          resultSubtype = undefined;
-          resultNumTurns = undefined;
-          resultContextWindowPct = undefined;
-          sdkEventCount = 0;
-          continue; // Wait for next turn from generator
+          break;
         }
       }
 
@@ -1004,7 +836,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         yield approvalEvents.shift()!;
       }
 
-      if (!hadAnyEvents) {
+      if (sdkEventCount === 0) {
         yield { type: "error", message: "Claude did not respond. Check that 'claude' CLI works in your terminal." };
       }
       break; // Exit retryLoop — normal completion
@@ -1014,47 +846,88 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       console.error(`[sdk] session=${sessionId} cwd=${meta.projectPath} error: ${msg}`);
       if (msg.includes("abort") || msg.includes("closed")) {
         // User-initiated abort or WS closed — nothing to report
-      } else if (msg.includes("exited with code")) {
-        // Subprocess crashed — session will auto-recover on next message
-        console.warn(`[sdk] session=${sessionId} subprocess crashed: ${msg}`);
-        yield { type: "error", message: `SDK subprocess crashed. Send another message to auto-recover.` };
+      } else if (!isFirstMessage && msg.includes("exited with code")) {
+        // SDK subprocess crashed during session resume — retry as fresh session
+        console.warn(`[sdk] session resume failed, retrying as fresh session`);
+        try {
+          const providerConfig = this.getProviderConfig();
+          const effectiveCwd = meta.projectPath || homedir();
+          const retryAccount = accountSelector.isEnabled() ? accountSelector.next() : null;
+          const queryEnv = this.buildQueryEnv(meta.projectPath, retryAccount);
+          const retryOptions = {
+              ...(process.platform === "win32" && { executable: "node" }),
+              cwd: effectiveCwd,
+              systemPrompt: systemPromptOpt,
+              settingSources: ["user", "project"],
+              env: queryEnv,
+              settings: { permissions: { allow: [], deny: [] } },
+              allowedTools,
+              permissionMode,
+              allowDangerouslySkipPermissions: isBypass,
+              ...(providerConfig.model && { model: providerConfig.model }),
+              maxTurns: providerConfig.max_turns ?? 100,
+              includePartialMessages: true,
+            };
+          const retryQuery = query({
+              prompt: message,
+              options: {
+                ...retryOptions,
+                ...(permissionHooks && { hooks: permissionHooks }),
+                canUseTool,
+              } as any,
+            });
+          this.activeQueries.set(sessionId, retryQuery);
+          for await (const retryMsg of retryQuery) {
+            if (retryMsg.type === "system") continue;
+            if (retryMsg.type === "result") {
+              const r = retryMsg as any;
+              if (r.subtype && r.subtype !== "success") {
+                const retryErrors = Array.isArray(r.errors) ? r.errors.join("\n") : "";
+                yield { type: "error", message: retryErrors || `Agent stopped: ${r.subtype}` };
+              }
+              resultSubtype = r.subtype;
+              resultNumTurns = r.num_turns;
+              break;
+            }
+            if ((retryMsg as any).type === "assistant") {
+              const content = (retryMsg as any).message?.content;
+              if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (block.type === "text" && typeof block.text === "string") {
+                    yield { type: "text", content: block.text };
+                  }
+                }
+              }
+            }
+          }
+        } catch (retryErr) {
+          const retryMsg = (retryErr as Error).message ?? String(retryErr);
+          console.error(`[sdk] retry also failed: ${retryMsg}`);
+          yield { type: "error", message: `SDK error: ${msg}` };
+        }
       } else {
         yield { type: "error", message: `SDK error: ${msg}` };
       }
     } finally {
       this.activeQueries.delete(sessionId);
-      this.streamingSessions.delete(sessionId);
-      console.log(`[sdk] session=${sessionId} streaming session ended`);
     }
 
-    // Final done event when query ends (crash, close, generator done)
-    // Skip if we already yielded done from the result handler (avoid duplicate)
-    if (!yieldedDone) {
-      yield {
-        type: "done",
-        sessionId,
-        resultSubtype: resultSubtype as any,
-        numTurns: resultNumTurns,
-        contextWindowPct: resultContextWindowPct,
-      };
-    }
+    yield {
+      type: "done",
+      sessionId,
+      resultSubtype: resultSubtype as any,
+      numTurns: resultNumTurns,
+      contextWindowPct: resultContextWindowPct,
+    };
   }
 
 
-  /** Interrupt the current turn — session stays alive for the next message */
+  /** Abort an active query for a session */
   abortQuery(sessionId: string): void {
-    const ss = this.streamingSessions.get(sessionId);
-    if (ss && typeof ss.query.interrupt === "function") {
-      ss.query.interrupt().catch(() => {});
-      console.log(`[sdk] abortQuery: interrupted session=${sessionId}`);
-      return;
-    }
-    // Fallback: close query entirely and clean up streaming session
     const q = this.activeQueries.get(sessionId);
     if (q) {
       q.close();
       this.activeQueries.delete(sessionId);
-      this.streamingSessions.delete(sessionId);
     }
   }