@hienlh/ppm 0.9.0-beta.9 → 0.9.1

package/src/cli/commands/autostart.ts

@@ -10,7 +10,7 @@ export function registerAutoStartCommands(program: Command): void {
     .command("enable")
     .description("Register PPM to start automatically on boot")
     .option("-p, --port <port>", "Override port")
-    .option("-s, --share", "Enable Cloudflare tunnel on boot")
+    .option("-s, --share", "(deprecated) Tunnel is now always enabled")
     .option("-c, --config <path>", "Config file path")
     .option("--profile <name>", "DB profile name")
     .action(async (options) => {

package/src/cli/commands/ext-cmd.ts

@@ -0,0 +1,121 @@
+import { Command } from "commander";
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  dim: "\x1b[2m",
+};
+
+function printTable(headers: string[], rows: string[][]): void {
+  const colWidths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
+  );
+  const sep = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+  const headerLine = headers.map((h, i) => ` ${h.padEnd(colWidths[i]!)} `).join("|");
+  console.log(`+${sep}+`);
+  console.log(`|${C.bold}${headerLine}${C.reset}|`);
+  console.log(`+${sep}+`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => ` ${(cell ?? "").padEnd(colWidths[i]!)} `).join("|");
+    console.log(`|${line}|`);
+  }
+  console.log(`+${sep}+`);
+}
+
+export function registerExtCommands(program: Command): void {
+  const ext = program.command("ext").description("Manage PPM extensions");
+
+  ext
+    .command("install <name>")
+    .description("Install an extension from npm")
+    .action(async (name: string) => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      try {
+        console.log(`${C.dim}Installing ${name}...${C.reset}`);
+        const manifest = await extensionService.install(name);
+        console.log(`${C.green}✓${C.reset} Installed ${C.bold}${manifest.id}${C.reset}@${manifest.version}`);
+      } catch (e) {
+        console.error(`${C.red}✗${C.reset} ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    });
+
+  ext
+    .command("remove <name>")
+    .description("Remove an installed extension")
+    .action(async (name: string) => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      try {
+        await extensionService.remove(name);
+        console.log(`${C.green}✓${C.reset} Removed ${C.bold}${name}${C.reset}`);
+      } catch (e) {
+        console.error(`${C.red}✗${C.reset} ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    });
+
+  ext
+    .command("list")
+    .description("List installed extensions")
+    .action(async () => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      const extensions = extensionService.list();
+      if (extensions.length === 0) {
+        console.log(`${C.dim}No extensions installed.${C.reset}`);
+        return;
+      }
+      const rows = extensions.map((e) => [
+        e.id,
+        e.version,
+        e.enabled ? `${C.green}enabled${C.reset}` : `${C.dim}disabled${C.reset}`,
+        e.activated ? `${C.green}active${C.reset}` : `${C.dim}inactive${C.reset}`,
+      ]);
+      printTable(["ID", "Version", "Enabled", "Status"], rows);
+    });
+
+  ext
+    .command("enable <name>")
+    .description("Enable an extension")
+    .action(async (name: string) => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      try {
+        await extensionService.setEnabled(name, true);
+        console.log(`${C.green}✓${C.reset} Enabled ${C.bold}${name}${C.reset}`);
+      } catch (e) {
+        console.error(`${C.red}✗${C.reset} ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    });
+
+  ext
+    .command("disable <name>")
+    .description("Disable an extension")
+    .action(async (name: string) => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      try {
+        await extensionService.setEnabled(name, false);
+        console.log(`${C.green}✓${C.reset} Disabled ${C.bold}${name}${C.reset}`);
+      } catch (e) {
+        console.error(`${C.red}✗${C.reset} ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    });
+
+  ext
+    .command("dev <path>")
+    .description("Symlink a local extension for development")
+    .action(async (localPath: string) => {
+      const { extensionService } = await import("../../services/extension.service.ts");
+      try {
+        const manifest = await extensionService.devLink(localPath);
+        console.log(`${C.green}✓${C.reset} Dev-linked ${C.bold}${manifest.id}${C.reset} → ${localPath}`);
+      } catch (e) {
+        console.error(`${C.red}✗${C.reset} ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/restart.ts

@@ -9,7 +9,7 @@ const RESTARTING_FLAG = resolve(PPM_DIR, ".restarting");
 const RESTART_RESULT = resolve(PPM_DIR, ".restart-result");
 
 /** Restart only the server process, keeping the tunnel alive */
-export async function restartServer(options: { config?: string }) {
+export async function restartServer(options: { config?: string; force?: boolean }) {
   // Ignore SIGHUP so this process survives when PPM terminal dies
   process.on("SIGHUP", () => {});
 
@@ -34,6 +34,14 @@ export async function restartServer(options: { config?: string }) {
       process.exit(1);
     }
 
+    // Check if supervisor is paused — require --force to resume
+    const state = status.state as string | undefined;
+    if (state === "paused" && !options.force) {
+      console.log("\n  Server is paused (crashed too many times).");
+      console.log("  Use 'ppm restart --force' to resume.\n");
+      process.exit(1);
+    }
+
     const oldServerPid = status.pid as number | undefined;
     console.log("\n  Restarting PPM server via supervisor...");
     console.log("  If you're using PPM terminal, wait a few seconds for auto-reconnect.\n");

package/src/cli/commands/status.ts

@@ -15,6 +15,10 @@ interface DaemonStatus {
   tunnelAlive: boolean;
   supervisorPid: number | null;
   supervisorAlive: boolean;
+  state: string | null;
+  pausedAt: string | null;
+  pauseReason: string | null;
+  lastCrashError: string | null;
 }
 
 function isAlive(pid: number): boolean {
@@ -26,6 +30,7 @@ function getDaemonStatus(): DaemonStatus {
     running: false, pid: null, port: null, host: null,
     shareUrl: null, tunnelPid: null, tunnelAlive: false,
     supervisorPid: null, supervisorAlive: false,
+    state: null, pausedAt: null, pauseReason: null, lastCrashError: null,
   };
 
   if (existsSync(STATUS_FILE)) {
@@ -46,6 +51,10 @@ function getDaemonStatus(): DaemonStatus {
         tunnelAlive,
         supervisorPid,
         supervisorAlive,
+        state: (data.state as string) ?? null,
+        pausedAt: (data.pausedAt as string) ?? null,
+        pauseReason: (data.pauseReason as string) ?? null,
+        lastCrashError: (data.lastCrashError as string) ?? null,
       };
     } catch { return dead; }
   }
@@ -161,6 +170,16 @@ export async function showStatus(options: { json?: boolean; all?: boolean }) {
   if (status.supervisorPid) {
     console.log(`  Supervisor: ${status.supervisorAlive ? "running" : "stopped"} (PID: ${status.supervisorPid})`);
   }
+  // Show state info
+  const state = status.state ?? (status.running ? "running" : "stopped");
+  if (state === "paused") {
+    console.log(`  State:   PAUSED — ${status.pauseReason ?? "unknown reason"}`);
+    if (status.pausedAt) console.log(`  Paused:  ${status.pausedAt}`);
+    if (status.lastCrashError) console.log(`  Error:   ${status.lastCrashError}`);
+    console.log(`\n  Resume:  ppm restart --force`);
+  } else if (state === "upgrading") {
+    console.log(`  State:   UPGRADING`);
+  }
   console.log(`  Server:  ${status.running ? "running" : "stopped"} (PID: ${status.pid})`);
   if (status.port) console.log(`  Local:   http://localhost:${status.port}/`);
   if (status.tunnelPid) {

package/src/index.ts

@@ -16,9 +16,7 @@ program
   .command("start")
   .description("Start the PPM server (background by default)")
   .option("-p, --port <port>", "Port to listen on")
-  .option("-f, --foreground", "Run in foreground (default: background daemon)")
-  .option("-d, --daemon", "Run as background daemon (default, kept for compat)")
-  .option("-s, --share", "Share via public URL (Cloudflare tunnel)")
+  .option("-s, --share", "(deprecated) Tunnel is now always enabled")
   .option("-c, --config <path>", "Path to config file (YAML import into DB)")
   .option("--profile <name>", "DB profile name (e.g. 'dev' → ppm.dev.db)")
   .action(async (options) => {
@@ -51,6 +49,7 @@ program
   .command("restart")
   .description("Restart the server (keeps tunnel alive)")
   .option("-c, --config <path>", "Path to config file")
+  .option("--force", "Force resume from paused state")
   .action(async (options) => {
     const { restartServer } = await import("./cli/commands/restart.ts");
     await restartServer(options);
@@ -136,4 +135,7 @@ registerAutoStartCommands(program);
 const { registerCloudCommands } = await import("./cli/commands/cloud.ts");
 registerCloudCommands(program);
 
+const { registerExtCommands } = await import("./cli/commands/ext-cmd.ts");
+registerExtCommands(program);
+
 program.parse();

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

@@ -15,13 +15,15 @@ import type {
 import { configService } from "../services/config.service.ts";
 import { mcpConfigService } from "../services/mcp-config.service.ts";
 import { updateFromSdkEvent } from "../services/claude-usage.service.ts";
-import { getSessionMapping, setSessionMapping, getSessionTitles } from "../services/db.service.ts";
+import { getSessionMapping, getSessionProjectPath, setSessionMapping, getSessionTitles } from "../services/db.service.ts";
 import { accountSelector } from "../services/account-selector.service.ts";
 import { accountService } from "../services/account.service.ts";
 import { resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 
+const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
+
 function getSdkSessionId(ppmId: string): string {
   return getSessionMapping(ppmId) ?? ppmId;
 }
@@ -213,6 +215,16 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     return null;
   }
 
+  /** Extract text content from an SDK assistant message */
+  private extractAssistantText(msg: unknown): string {
+    const content = (msg as any)?.message?.content;
+    if (!Array.isArray(content)) return "";
+    return content
+      .filter((b: any) => b.type === "text" && typeof b.text === "string")
+      .map((b: any) => b.text)
+      .join("");
+  }
+
   /** Read current provider config from yaml (fresh each call) */
   private getProviderConfig(): Partial<import("../types/config.ts").AIProviderConfig> {
     const ai = configService.get("ai");
@@ -232,6 +244,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     };
     this.activeSessions.set(id, meta);
     this.messageCount.set(id, 0);
+    // Pre-persist mapping so project_path survives server restarts
+    setSessionMapping(id, id, config.projectName, config.projectPath);
     return meta;
   }
 
@@ -241,6 +255,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
     // Check if we have a mapped SDK session ID (from a previous query)
     const mappedSdkId = getSdkSessionId(sessionId);
+    // Restore project_path from DB so resumed sessions can find JSONL
+    const dbProjectPath = getSessionProjectPath(sessionId) ?? undefined;
 
     try {
       const sdkSessions = await sdkListSessions({ limit: 100 });
@@ -252,6 +268,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           id: sessionId,
           providerId: this.id,
           title: found.customTitle ?? found.summary ?? "Resumed Chat",
+          projectPath: dbProjectPath,
           createdAt: new Date(found.lastModified).toISOString(),
         };
         this.activeSessions.set(sessionId, meta);
@@ -268,6 +285,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       id: sessionId,
       providerId: this.id,
       title: "Resumed Chat",
+      projectPath: dbProjectPath,
       createdAt: new Date().toISOString(),
     };
     this.activeSessions.set(sessionId, meta);
@@ -307,6 +325,21 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     this.closeStreamingSession(sessionId);
     this.activeSessions.delete(sessionId);
     this.messageCount.delete(sessionId);
+    this.pendingApprovals.delete(sessionId);
+    this.forkSources.delete(sessionId);
+
+    // Best-effort: delete JSONL from ~/.claude/projects/
+    const sdkId = getSessionMapping(sessionId) ?? sessionId;
+    try {
+      if (existsSync(CLAUDE_PROJECTS_DIR)) {
+        const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+        for (const dir of projectDirs) {
+          if (dir.includes("..") || dir.includes("/")) continue; // safety
+          const jsonlPath = resolve(CLAUDE_PROJECTS_DIR, dir, `${sdkId}.jsonl`);
+          if (existsSync(jsonlPath)) { unlinkSync(jsonlPath); break; }
+        }
+      }
+    } catch { /* best-effort */ }
   }
 
   /**
@@ -325,6 +358,29 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     this.forkSources.set(sessionId, sourceSessionId);
   }
 
+  /** Fork a session at a specific message using SDK forkSession() */
+  async forkAtMessage(
+    sessionId: string,
+    messageId: string,
+    opts?: { title?: string; dir?: string },
+  ): Promise<{ sessionId: string }> {
+    const sdkId = getSessionMapping(sessionId) ?? sessionId;
+    // Dynamic import: Bun's ESM linker fails to resolve forkSession as a static named export
+    // in certain test configurations. Lazy import avoids the module linking issue.
+    const { forkSession } = await import("@anthropic-ai/claude-agent-sdk");
+    const result = await forkSession(sdkId, {
+      upToMessageId: messageId,
+      title: opts?.title,
+      dir: opts?.dir,
+    });
+    return { sessionId: result.sessionId };
+  }
+
+  /** Mark session as resumed so next sendMessage uses resume path */
+  markAsResumed(sessionId: string): void {
+    this.messageCount.set(sessionId, 1);
+  }
+
   async listModels(): Promise<ModelOption[]> {
     return [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
@@ -594,7 +650,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         allowDangerouslySkipPermissions: isBypass,
         ...(providerConfig.model && { model: providerConfig.model }),
         ...(providerConfig.effort && { effort: providerConfig.effort }),
-        maxTurns: providerConfig.max_turns ?? 100,
+        maxTurns: providerConfig.max_turns ?? 1000,
         ...(providerConfig.max_budget_usd && { maxBudgetUsd: providerConfig.max_budget_usd }),
         ...(providerConfig.thinking_budget_tokens != null && {
           thinkingBudgetTokens: providerConfig.thinking_budget_tokens,
@@ -632,7 +688,10 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // it's a transient subprocess failure — retry once before surfacing the error.
       // Also handles authentication_failed by refreshing OAuth token and retrying.
       const MAX_RETRIES = 1;
+      const MAX_RATE_LIMIT_RETRIES = 3;
+      const RATE_LIMIT_BACKOFF_MS = [15_000, 30_000, 60_000]; // 15s, 30s, 60s
       let retryCount = 0;
+      let rateLimitRetryCount = 0;
       let authRetried = false;
 
       let hadAnyEvents = false;
@@ -680,7 +739,17 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           if (subtype === "init") {
             const initMsg = msg as any;
             if (initMsg.session_id && initMsg.session_id !== sessionId) {
-              setSessionMapping(sessionId, initMsg.session_id);
+              // Only update sdk_id mapping for brand-new sessions (first message).
+              // For resumed sessions the SDK may create a new session_id, but the
+              // old JSONL (keyed by the original sdk_id) still holds the full
+              // conversation history.  Overwriting the mapping would orphan it.
+              const existingSdkId = getSessionMapping(sessionId);
+              const isFirstMessage = existingSdkId === null || existingSdkId === sessionId;
+              if (isFirstMessage) {
+                setSessionMapping(sessionId, initMsg.session_id, meta.projectName, meta.projectPath);
+              } else {
+                console.log(`[sdk] session=${sessionId} ignoring new sdk_id=${initMsg.session_id} to preserve existing mapping → ${existingSdkId}`);
+              }
               const oldMeta = this.activeSessions.get(sessionId);
               if (oldMeta) {
                 this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
@@ -688,6 +757,24 @@ export class ClaudeAgentSdkProvider implements AIProvider {
             }
           }
 
+          // Detect compacting status
+          if (subtype === "status") {
+            const status = (msg as any).status;
+            if (status === "compacting") {
+              console.log(`[sdk] session=${sessionId} COMPACTING`);
+              yield { type: "system" as const, subtype: "compacting" } as ChatEvent;
+              continue;
+            }
+          }
+
+          // Detect compact boundary (compact finished, messages replaced in JSONL)
+          if (subtype === "compact_boundary") {
+            const meta = (msg as any).compact_metadata;
+            console.log(`[sdk] session=${sessionId} COMPACT_BOUNDARY trigger=${meta?.trigger} pre_tokens=${meta?.pre_tokens}`);
+            yield { type: "system" as const, subtype: "compact_done" } as ChatEvent;
+            continue;
+          }
+
           // Yield system events so streaming loop can transition phases
           // (e.g. connecting → thinking when hooks/init arrive)
           yield { type: "system" as any, subtype } as any;
@@ -787,7 +874,18 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         // Full assistant message
         if (msg.type === "assistant") {
           // SDK assistant messages can carry an error field for auth/billing/rate-limit failures
-          const assistantError = (msg as any).error as string | undefined;
+          let assistantError = (msg as any).error as string | undefined;
+
+          // SDK sometimes returns auth errors as text content without setting error field.
+          // Detect 401 pattern in text: "Failed to authenticate. API Error: 401 ..."
+          if (!assistantError) {
+            const textContent = this.extractAssistantText(msg);
+            if (textContent && /API Error:\s*401\b.*authentication_error/i.test(textContent)) {
+              assistantError = "authentication_failed";
+              console.warn(`[sdk] session=${sessionId} detected 401 in assistant text content — treating as auth error`);
+            }
+          }
+
           if (assistantError) {
             // Dump full SDK message for debugging
             console.error(`[sdk] session=${sessionId} cwd=${effectiveCwd} assistant error: ${assistantError} (isFirst=${isFirstMessage} retry=${retryCount})`);
@@ -798,10 +896,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               authRetried = true;
               try {
                 await accountService.refreshAccessToken(account.id, false);
-                console.log(`[sdk] session=${sessionId} OAuth token refreshed for ${account.id} — retrying`);
-                // Re-build env with refreshed token
                 const refreshedAccount = accountService.getWithTokens(account.id);
                 if (refreshedAccount) {
+                  const label = refreshedAccount.label ?? refreshedAccount.email ?? "Unknown";
+                  console.log(`[sdk] session=${sessionId} OAuth token refreshed for ${account.id} (${label}) — retrying`);
+                  yield { type: "account_retry" as const, reason: "Token refreshed", accountId: refreshedAccount.id, accountLabel: label };
                   const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
                   // Close failed query and old channel, create new channel + query with refreshed token
                   streamCtrl.done();
@@ -824,16 +923,65 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               }
             }
 
+            // Auth failed permanently after retry — cooldown account and break loop.
+            // SDK doesn't send a result event after auth errors in streaming mode,
+            // so the streaming session would stay alive with broken credentials forever.
+            // Breaking here lets the finally block tear down the session, so the next
+            // user message creates a fresh session with a different account.
+            if (assistantError === "authentication_failed" && account && authRetried) {
+              accountSelector.onAuthError(account.id);
+              console.warn(`[sdk] session=${sessionId} auth permanently failed — tearing down streaming session`);
+              yield { type: "error", message: "API authentication failed. Check your account credentials in Settings → Accounts." };
+              break;
+            }
+
+            // Rate limit — auto-retry with exponential backoff, switching account if possible
+            if ((assistantError === "rate_limit" || assistantError === "server_error") && rateLimitRetryCount < MAX_RATE_LIMIT_RETRIES) {
+              const backoff = RATE_LIMIT_BACKOFF_MS[rateLimitRetryCount] ?? 60_000;
+              rateLimitRetryCount++;
+              if (account) accountSelector.onRateLimit(account.id);
+
+              // Try to switch to a different account
+              const nextAccount = accountSelector.next();
+              if (nextAccount && account && nextAccount.id !== account.id) {
+                account = nextAccount;
+                const label = nextAccount.label ?? nextAccount.email ?? "Unknown";
+                console.warn(`[sdk] session=${sessionId} rate limited — switching to account ${nextAccount.id} (${label}), retrying in ${backoff / 1000}s (attempt ${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})`);
+                yield { type: "account_retry" as const, reason: `Rate limited — switching account`, accountId: nextAccount.id, accountLabel: label };
+              } else {
+                console.warn(`[sdk] session=${sessionId} rate limited — retrying in ${backoff / 1000}s (attempt ${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})`);
+              }
+              yield { type: "error", message: `Rate limited. Auto-retrying in ${backoff / 1000}s... (${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})` };
+              await new Promise((r) => setTimeout(r, backoff));
+              // Close failed query and recreate with (potentially new) account env
+              streamCtrl.done();
+              q.close();
+              const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
+              const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
+              rlRetryCtrl.push(firstMsg);
+              const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined, env: rlRetryEnv };
+              const rq = query({
+                prompt: rlRetryGen,
+                options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
+              });
+              this.streamingSessions.set(sessionId, { meta, query: rq, controller: rlRetryCtrl });
+              this.activeQueries.set(sessionId, rq);
+              eventSource = rq;
+              continue retryLoop;
+            }
+
             const errorHints: Record<string, string> = {
               authentication_failed: "API authentication failed. Check your account credentials in Settings → Accounts.",
               billing_error: "Billing error on this account. Check your subscription status.",
-              rate_limit: "Rate limited by the API. Please wait and try again.",
+              rate_limit: `Rate limited by the API. Retried ${MAX_RATE_LIMIT_RETRIES} times without success.`,
               invalid_request: "Invalid request sent to the API.",
-              server_error: "Anthropic API server error. Try again shortly.",
+              server_error: `Anthropic API server error. Retried ${MAX_RATE_LIMIT_RETRIES} times without success.`,
               unknown: `API error in project "${effectiveCwd}". Debug:\n1. Run: \`cd ${effectiveCwd} && claude -p "hi"\`\n2. Check env: \`echo $ANTHROPIC_API_KEY $ANTHROPIC_BASE_URL\` — stale/invalid keys cause this\n3. Try: \`ANTHROPIC_API_KEY="" ANTHROPIC_BASE_URL="" claude -p "hi"\`\n4. Refresh auth: \`claude login\``,
             };
             const hint = errorHints[assistantError] ?? `API error: ${assistantError}`;
             yield { type: "error", message: hint };
+            // Skip emitting the raw 401 error as text content — already shown as error event
+            continue;
           }
           const content = (msg as any).message?.content;
           if (Array.isArray(content)) {
@@ -885,15 +1033,65 @@ 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
-              yield { type: "error", message: "Rate limited. This account is now on cooldown. Please retry." };
+              // Auto-retry with backoff for result-level 429, switching account if possible
+              if (rateLimitRetryCount < MAX_RATE_LIMIT_RETRIES) {
+                const backoff = RATE_LIMIT_BACKOFF_MS[rateLimitRetryCount] ?? 60_000;
+                rateLimitRetryCount++;
+
+                // Try to switch to a different account
+                const nextAccount = accountSelector.next();
+                if (nextAccount && nextAccount.id !== account.id) {
+                  account = nextAccount;
+                  const label = nextAccount.label ?? nextAccount.email ?? "Unknown";
+                  console.warn(`[sdk] session=${sessionId} result 429 — switching to account ${nextAccount.id} (${label}), retrying in ${backoff / 1000}s (attempt ${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})`);
+                  yield { type: "account_retry" as const, reason: `Rate limited — switching account`, accountId: nextAccount.id, accountLabel: label };
+                } else {
+                  console.warn(`[sdk] session=${sessionId} result 429 — retrying in ${backoff / 1000}s (attempt ${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})`);
+                }
+                yield { type: "error", message: `Rate limited. Auto-retrying in ${backoff / 1000}s... (${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})` };
+                await new Promise((r) => setTimeout(r, backoff));
+                streamCtrl.done();
+                q.close();
+                const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
+                const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
+                rlRetryCtrl.push(firstMsg);
+                const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined, env: rlRetryEnv };
+                const rq = query({
+                  prompt: rlRetryGen,
+                  options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
+                });
+                this.streamingSessions.set(sessionId, { meta, query: rq, controller: rlRetryCtrl });
+                this.activeQueries.set(sessionId, rq);
+                eventSource = rq;
+                continue retryLoop;
+              }
+              yield { type: "error", message: `Rate limited. Retried ${MAX_RATE_LIMIT_RETRIES} times without success.` };
               continue;
             } else if (errCode === 401) {
-              // Try refresh once
-              try {
-                await accountService.refreshAccessToken(account.id, false);
-                console.log(`[sdk] 401 on account ${account.id} — token refreshed`);
-              } catch {
+              // Refresh token and retry with fresh session (same logic as assistant-level auth retry)
+              if (!authRetried) {
+                authRetried = true;
+                try {
+                  await accountService.refreshAccessToken(account.id, false);
+                  const refreshedAccount = accountService.getWithTokens(account.id);
+                  if (refreshedAccount) {
+                    const label = refreshedAccount.label ?? refreshedAccount.email ?? "Unknown";
+                    console.log(`[sdk] 401 in result on account ${account.id} (${label}) — token refreshed, retrying`);
+                    yield { type: "account_retry" as const, reason: "Token refreshed", accountId: refreshedAccount.id, accountLabel: label };
+                    const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
+                    const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined, env: retryEnv };
+                    const rq = query({
+                      prompt: message,
+                      options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
+                    });
+                    this.activeQueries.set(sessionId, rq);
+                    eventSource = rq;
+                    continue retryLoop;
+                  }
+                } catch {
+                  accountSelector.onAuthError(account.id);
+                }
+              } else {
                 accountSelector.onAuthError(account.id);
               }
             } else {
@@ -1051,7 +1249,13 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       }
     } finally {
       this.activeQueries.delete(sessionId);
-      this.streamingSessions.delete(sessionId);
+      // Properly close streaming session: terminate subprocess + generator
+      const ss = this.streamingSessions.get(sessionId);
+      if (ss) {
+        ss.controller.done();
+        ss.query.close();
+        this.streamingSessions.delete(sessionId);
+      }
       console.log(`[sdk] session=${sessionId} streaming session ended`);
     }
 

package/src/providers/cli-provider-base.ts

@@ -84,7 +84,13 @@ export abstract class CliProvider implements AIProvider {
     }));
   }
 
+  markAsResumed(sessionId: string): void {
+    this.messageCount.set(sessionId, 1);
+  }
+
   async deleteSession(sessionId: string): Promise<void> {
+    const proc = this.activeProcesses.get(sessionId);
+    if (proc) { proc.kill(); this.activeProcesses.delete(sessionId); }
     this.sessions.delete(sessionId);
     this.messageCount.delete(sessionId);
   }