@hienlh/ppm 0.9.79 → 0.9.81

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

@@ -16,7 +16,7 @@ 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, getSessionProjectPath, setSessionMapping, getSessionTitles } from "../services/db.service.ts";
+import { getSessionProjectPath, setSessionMetadata, getSessionTitles } from "../services/db.service.ts";
 import { accountSelector } from "../services/account-selector.service.ts";
 import { accountService, type AccountWithTokens } from "../services/account.service.ts";
 import { resolve } from "node:path";
@@ -25,10 +25,6 @@ import { homedir } from "node:os";
 
 const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
 
-function getSdkSessionId(ppmId: string): string {
-  return getSessionMapping(ppmId) ?? ppmId;
-}
-
 // ── Streaming Input: message channel for persistent query ──
 
 interface MessageController {
@@ -113,6 +109,7 @@ interface StreamingSession {
  */
 interface PendingApproval {
   resolve: (result: { approved: boolean; data?: unknown }) => void;
+  sessionId: string;
 }
 
 /**
@@ -266,8 +263,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);
+    // Persist project metadata so project_path survives server restarts
+    setSessionMetadata(id, config.projectName, config.projectPath);
     return meta;
   }
 
@@ -275,31 +272,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     const existing = this.activeSessions.get(sessionId);
     if (existing) return existing;
 
-    // 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 targeted lookup first (searches all project dirs), then fall back to list scan
+    // Try targeted lookup first (searches all project dirs)
     try {
-      const lookupId = mappedSdkId ?? sessionId;
-      const info = await sdkGetSessionInfo(lookupId, { dir: dbProjectPath });
-      if (!info && mappedSdkId) {
-        // Try the original PPM session ID as well
-        const info2 = await sdkGetSessionInfo(sessionId, { dir: dbProjectPath });
-        if (info2) {
-          const meta: Session = {
-            id: sessionId,
-            providerId: this.id,
-            title: info2.customTitle ?? info2.summary ?? "Resumed Chat",
-            projectPath: dbProjectPath,
-            createdAt: new Date(info2.lastModified).toISOString(),
-          };
-          this.activeSessions.set(sessionId, meta);
-          this.messageCount.set(sessionId, 1);
-          return meta;
-        }
-      }
+      const info = await sdkGetSessionInfo(sessionId, { dir: dbProjectPath });
       if (info) {
         const meta: Session = {
           id: sessionId,
@@ -316,11 +294,10 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // SDK not available
     }
 
-    // Session not found in SDK list — it may still have a JSONL on disk
-    // (sdkListSessions may not search the correct project directory).
-    // Use messageCount=1 so sendMessage uses --resume instead of --session-id.
-    // --resume gracefully fails if no JSONL exists, while --session-id crashes
-    // when a JSONL file for the same ID is already present on disk.
+    // Session not found in SDK list — it may still have a JSONL on disk.
+    // Use messageCount=1 so sendMessage uses resume instead of sessionId.
+    // resume gracefully handles missing JSONL, while sessionId crashes
+    // when a JSONL file for the same ID already exists on disk.
     const meta: Session = {
       id: sessionId,
       providerId: this.id,
@@ -384,17 +361,22 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     this.closeStreamingSession(sessionId);
     this.activeSessions.delete(sessionId);
     this.messageCount.delete(sessionId);
-    this.pendingApprovals.delete(sessionId);
+    // Resolve and clean up all pending approvals for this session
+    for (const [reqId, pending] of this.pendingApprovals) {
+      if (pending.sessionId === sessionId) {
+        pending.resolve({ approved: false });
+        this.pendingApprovals.delete(reqId);
+      }
+    }
     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`);
+          const jsonlPath = resolve(CLAUDE_PROJECTS_DIR, dir, `${sessionId}.jsonl`);
           if (existsSync(jsonlPath)) { unlinkSync(jsonlPath); break; }
         }
       }
@@ -423,11 +405,10 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     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, {
+    const result = await forkSession(sessionId, {
       upToMessageId: messageId,
       title: opts?.title,
       dir: opts?.dir,
@@ -569,15 +550,9 @@ export class ClaudeAgentSdkProvider implements AIProvider {
      */
     const waitForApproval = (toolName: string, input: unknown): Promise<{ approved: boolean; data?: unknown }> => {
       const requestId = crypto.randomUUID();
-      const APPROVAL_TIMEOUT_MS = 5 * 60_000;
+      // No timeout — approval waits indefinitely until user responds or session cleanup resolves it.
       const promise = new Promise<{ approved: boolean; data?: unknown }>((resolve) => {
-        this.pendingApprovals.set(requestId, { resolve });
-        setTimeout(() => {
-          if (this.pendingApprovals.has(requestId)) {
-            this.pendingApprovals.delete(requestId);
-            resolve({ approved: false });
-          }
-        }, APPROVAL_TIMEOUT_MS);
+        this.pendingApprovals.set(requestId, { resolve, sessionId });
       });
       approvalEvents.push({ type: "approval_request", requestId, tool: toolName, input });
       approvalNotify?.();
@@ -635,7 +610,6 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       PreToolUse: [{
         matcher: ".*",  // Match all tools — our hook checks internally
         hooks: [preToolUseHook],
-        timeout: 300,  // 5min for user approval
       }],
     };
 
@@ -645,17 +619,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     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
-      const sdkId = shouldFork ? getSdkSessionId(forkSourceId!) : getSdkSessionId(sessionId);
-      // If messageCount > 0 (resumeSession ran) but no real SDK mapping exists,
-      // the session never received an init event (prior attempt hung/crashed).
-      // Treat as first message to avoid resuming a non-existent JSONL → silent hang.
-      const hasRealSdkMapping = getSessionMapping(sessionId) !== null && getSessionMapping(sessionId) !== sessionId;
-      const effectiveIsFirst = isFirstMessage || (!shouldFork && !hasRealSdkMapping);
-      if (effectiveIsFirst && !isFirstMessage) {
-        console.warn(`[sdk] session=${sessionId} no SDK mapping found — treating as new session (was isFirst=false)`);
-      }
+      // Session ID is the canonical ID for both PPM and SDK (no dual-ID mapping).
+      // First message creates a new session; subsequent messages resume.
       // Fallback cwd: SDK needs a valid working directory even when no project is selected.
       // On Windows daemons, undefined cwd can cause the subprocess to fail silently.
       // Resolve path and validate existence — invalid cwd causes spawn to hang on Windows.
@@ -725,7 +690,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           console.warn(`[sdk] session=${sessionId} no account and no API key in env — Claude CLI will use its own auth (if any)`);
         }
       }
-      console.log(`[sdk] query: session=${sessionId} sdkId=${sdkId} isFirst=${isFirstMessage} effectiveIsFirst=${effectiveIsFirst} fork=${shouldFork} cwd=${effectiveCwd} platform=${process.platform} accountMode=${!!account} permissionMode=${permissionMode} isBypass=${isBypass}`);
+      console.log(`[sdk] query: session=${sessionId} isFirst=${isFirstMessage} fork=${shouldFork} cwd=${effectiveCwd} platform=${process.platform} accountMode=${!!account} permissionMode=${permissionMode} isBypass=${isBypass}`);
 
       // Read MCP servers from PPM DB (fresh per query — user may add/remove between chats)
       const mcpServers = mcpConfigService.list();
@@ -746,8 +711,9 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       const queryOptions: Record<string, any> = {
         // On Windows, child_process.spawn("bun") fails with ENOENT — force node
         ...(process.platform === "win32" && { executable: "node" }),
-        sessionId: effectiveIsFirst && !shouldFork ? sessionId : undefined,
-        resume: (effectiveIsFirst && !shouldFork) ? undefined : sdkId,
+        // First message: create session with this ID. Subsequent: resume by same ID.
+        sessionId: isFirstMessage && !shouldFork ? sessionId : undefined,
+        resume: (isFirstMessage && !shouldFork) ? undefined : (shouldFork ? forkSourceId : sessionId),
         ...(shouldFork && { forkSession: true }),
         cwd: effectiveCwd,
         systemPrompt: systemPromptOpt,
@@ -823,9 +789,6 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       let retryCount = 0;
       let rateLimitRetryCount = 0;
       let authRetried = false;
-      /** True after the first init event maps ppmId → sdkId. Prevents retry init events from overwriting the mapping. */
-      let initMappingDone = false;
-
       let hadAnyEvents = false;
       retryLoop: while (true) {
       let sdkEventCount = 0;
@@ -842,7 +805,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
             closeCurrentStream();
             const { generator: retryGen, controller: retryCtrl } = createMessageChannel();
             retryCtrl.push(firstMsg);
-            const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined };
+            // Retry with resume (safe even if JSONL doesn't exist yet — SDK handles gracefully)
+            const retryOpts = { ...queryOptions, sessionId: undefined, resume: sessionId };
             const rq = query({
               prompt: retryGen,
               options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -866,35 +830,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           const subtype = (msg as any).subtype ?? "none";
           console.log(`[sdk] session=${sessionId} system: subtype=${subtype} ${JSON.stringify(msg).slice(0, 500)}`);
 
-          // Capture SDK session metadata from init message
           if (subtype === "init") {
-            const initMsg = msg as any;
-            if (initMsg.session_id && initMsg.session_id !== sessionId) {
-              // Only update sdk_id mapping once per session lifecycle.
-              // Retries (auth refresh, rate limit) create new SDK queries that
-              // emit fresh init events — overwriting would orphan the original JSONL.
-              if (!initMappingDone) {
-                const existingSdkId = getSessionMapping(sessionId);
-                const isFirstMapping = existingSdkId === null || existingSdkId === sessionId;
-                if (isFirstMapping) {
-                  setSessionMapping(sessionId, initMsg.session_id, meta.projectName, meta.projectPath);
-                  initMappingDone = true;
-                } else {
-                  // Already mapped to a real SDK id from a previous conversation
-                  initMappingDone = true;
-                  console.log(`[sdk] session=${sessionId} preserving existing mapping → ${existingSdkId}`);
-                }
-              } else {
-                console.log(`[sdk] session=${sessionId} ignoring retry init sdk_id=${initMsg.session_id} (mapping already set)`);
-              }
-              // Only create activeSessions alias for first-time SDK id mapping.
-              // Retry init events create phantom entries that pollute the map.
-              if (isFirstMessage) {
-                const oldMeta = this.activeSessions.get(sessionId);
-                if (oldMeta) {
-                  this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
-                }
-              }
+            const sdkSid = (msg as any).session_id;
+            if (sdkSid && sdkSid !== sessionId) {
+              console.warn(`[sdk] session=${sessionId} SDK returned different session_id=${sdkSid} — JSONL may be orphaned`);
+            } else {
+              console.log(`[sdk] session=${sessionId} init: sdk_session_id=${sdkSid}`);
             }
           }
 
@@ -935,7 +876,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 const { generator: earlyAuthGen, controller: earlyAuthCtrl } = createMessageChannel();
                 const hasHistory = (this.messageCount.get(sessionId) ?? 0) > 0;
                 if (!hasHistory) earlyAuthCtrl.push(firstMsg);
-                const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? getSdkSessionId(sessionId) : undefined, env: retryEnv };
+                const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? sessionId : undefined, env: retryEnv };
                 const rq = query({
                   prompt: earlyAuthGen,
                   options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -961,7 +902,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 const { generator: switchGen, controller: switchCtrl } = createMessageChannel();
                 const hasHistory = (this.messageCount.get(sessionId) ?? 0) > 0;
                 if (!hasHistory) switchCtrl.push(firstMsg);
-                const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? getSdkSessionId(sessionId) : undefined, env: switchEnv };
+                const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? sessionId : undefined, env: switchEnv };
                 const rq = query({
                   prompt: switchGen,
                   options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -1008,7 +949,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         // Skip this for child messages (parentId set) — subagent internals don't mean parent tools finished.
         if (pendingToolCount > 0 && !parentId && (msg.type === "assistant" || (msg as any).type === "partial" || (msg as any).type === "stream_event")) {
           try {
-            const sessionMsgs = await getSessionMessages(sdkId);
+            const sessionMsgs = await getSessionMessages(sessionId);
             // Find the last user message — it contains tool_result blocks
             const lastUserMsg = [...sessionMsgs].reverse().find(
               (m: any) => m.type === "user",
@@ -1105,14 +1046,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                   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.
-                  // Re-resolve sdkId: the init event may have mapped ppmId → real SDK session_id
-                  // after sdkId was originally resolved. Using the stale value would try to
-                  // resume a non-existent session, causing the SDK to hang forever.
                   closeCurrentStream();
                   const { generator: authRetryGen, controller: authRetryCtrl } = createMessageChannel();
                   const hasHistory = (this.messageCount.get(sessionId) ?? 0) > 0;
                   if (!hasHistory) authRetryCtrl.push(firstMsg);
-                  const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? getSdkSessionId(sessionId) : undefined, env: retryEnv };
+                  const retryOpts = { ...queryOptions, sessionId: undefined, resume: hasHistory ? sessionId : undefined, env: retryEnv };
                   const rq = query({
                     prompt: authRetryGen,
                     options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -1159,13 +1097,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               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 current streaming session and recreate with (potentially new) account env.
-              // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
               closeCurrentStream();
               const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
               const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
               const rlHasHistory = (this.messageCount.get(sessionId) ?? 0) > 0;
               if (!rlHasHistory) rlRetryCtrl.push(firstMsg);
-              const retryOpts = { ...queryOptions, sessionId: undefined, resume: rlHasHistory ? getSdkSessionId(sessionId) : undefined, env: rlRetryEnv };
+              const retryOpts = { ...queryOptions, sessionId: undefined, resume: rlHasHistory ? sessionId : undefined, env: rlRetryEnv };
               const rq = query({
                 prompt: rlRetryGen,
                 options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -1256,13 +1193,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 }
                 yield { type: "error", message: `Rate limited. Auto-retrying in ${backoff / 1000}s... (${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})` };
                 await new Promise((r) => setTimeout(r, backoff));
-                // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
                 closeCurrentStream();
                 const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
                 const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
                 const rlHasHistory2 = (this.messageCount.get(sessionId) ?? 0) > 0;
                 if (!rlHasHistory2) rlRetryCtrl.push(firstMsg);
-                const retryOpts = { ...queryOptions, sessionId: undefined, resume: rlHasHistory2 ? getSdkSessionId(sessionId) : undefined, env: rlRetryEnv };
+                const retryOpts = { ...queryOptions, sessionId: undefined, resume: rlHasHistory2 ? sessionId : undefined, env: rlRetryEnv };
                 const rq = query({
                   prompt: rlRetryGen,
                   options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -1287,13 +1223,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                     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 };
-                    // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
                     closeCurrentStream();
                     const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
                     const { generator: authRetryGen2, controller: authRetryCtrl2 } = createMessageChannel();
                     const authHasHistory2 = (this.messageCount.get(sessionId) ?? 0) > 0;
                     if (!authHasHistory2) authRetryCtrl2.push(firstMsg);
-                    const retryOpts = { ...queryOptions, sessionId: undefined, resume: authHasHistory2 ? getSdkSessionId(sessionId) : undefined, env: retryEnv };
+                    const retryOpts = { ...queryOptions, sessionId: undefined, resume: authHasHistory2 ? sessionId : undefined, env: retryEnv };
                     const rq = query({
                       prompt: authRetryGen2,
                       options: { ...retryOpts, ...(permissionHooks && { hooks: permissionHooks }), canUseTool } as any,
@@ -1317,7 +1252,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           // Flush any remaining pending tool_results before finishing
           if (pendingToolCount > 0) {
             try {
-              const sessionMsgs = await getSessionMessages(sdkId);
+              const sessionMsgs = await getSessionMessages(sessionId);
               const lastUserMsg = [...sessionMsgs].reverse().find(
                 (m: any) => m.type === "user",
               );
@@ -1530,8 +1465,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
   async getMessages(sessionId: string): Promise<ChatMessage[]> {
     try {
-      const sdkId = getSdkSessionId(sessionId);
-      const messages = await getSessionMessages(sdkId);
+      const messages = await getSessionMessages(sessionId);
       const parsed = messages.map((msg) => parseSessionMessage(msg));
 
       // Merge tool_result user messages into the preceding assistant message

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

@@ -152,7 +152,7 @@ export abstract class CliProvider implements AIProvider {
               this.messageCount.delete(processKey);
               this.messageCount.set(capturedSessionId, cnt);
               // Notify frontend about the session ID change
-              yield { type: "session_migrated", oldSessionId: processKey, newSessionId: capturedSessionId } as ChatEvent;
+              yield { type: "session_migrated", oldSessionId: processKey, newSessionId: capturedSessionId } as unknown as ChatEvent;
             }
           }
         }

package/src/server/routes/chat.ts

@@ -8,7 +8,7 @@ import { renameSession as sdkRenameSession } from "@anthropic-ai/claude-agent-sd
 import { listSlashItems } from "../../services/slash-items.service.ts";
 import { getCachedUsage, refreshUsageNow } from "../../services/claude-usage.service.ts";
 import { getSessionLog } from "../../services/session-log.service.ts";
-import { getSessionMapping, getSessionProjectPath, setSessionMapping, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession, deleteSessionMapping, deleteSessionTitle } from "../../services/db.service.ts";
+import { getSessionProjectPath, setSessionMetadata, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession, deleteSessionMapping, deleteSessionMetadata, deleteSessionTitle } from "../../services/db.service.ts";
 import { ok, err } from "../../types/api.ts";
 
 type Env = { Variables: { projectPath: string; projectName: string } };
@@ -152,13 +152,13 @@ chatRoutes.delete("/sessions/:id", async (c) => {
   try {
     const id = c.req.param("id");
     const providerId = c.req.query("providerId") ?? "claude";
-    const sdkId = getSessionMapping(id) ?? id;
     // Provider-specific cleanup (JSONL, process, etc.)
     await chatService.deleteSession(providerId, id);
     // Shared DB cleanup
-    deleteSessionMapping(id);
-    deleteSessionTitle(sdkId);
-    unpinSession(sdkId);
+    deleteSessionMapping(id); // legacy cleanup
+    deleteSessionMetadata(id);
+    deleteSessionTitle(id);
+    unpinSession(id);
     return c.json(ok({ deleted: id }));
   } catch (e) {
     return c.json(err((e as Error).message), 404);
@@ -172,13 +172,11 @@ chatRoutes.patch("/sessions/:id", async (c) => {
     const body = await c.req.json<{ title?: string }>();
     if (!body.title?.trim()) return c.json(err("title is required"), 400);
     const title = body.title.trim();
-    // Resolve PPM UUID → SDK session ID if mapped
-    const sdkId = getSessionMapping(id) ?? id;
     const projectPath = c.get("projectPath");
     // Persist to PPM DB (authoritative source for user-set titles)
-    setSessionTitle(sdkId, title);
+    setSessionTitle(id, title);
     // Also persist to SDK so Claude Code CLI sees the custom title
-    await sdkRenameSession(sdkId, title, { dir: projectPath });
+    await sdkRenameSession(id, title, { dir: projectPath });
     // Also update in-memory session
     const session = chatService.getSession(id);
     if (session) session.title = title;
@@ -229,12 +227,19 @@ chatRoutes.post("/sessions/:id/fork", async (c) => {
       const result = await provider.forkAtMessage(sourceId, body.messageId, {
         title: "Forked Chat", dir: projectPath,
       });
-      const session = await chatService.createSession(providerId, {
-        projectName, projectPath, title: "Forked Chat",
-      });
-      setSessionMapping(session.id, result.sessionId);
-      provider.markAsResumed?.(session.id);
-      return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+      // Register forked session with provider + DB so it's tracked in memory
+      setSessionMetadata(result.sessionId, projectName, projectPath);
+      await provider.resumeSession(result.sessionId);
+      provider.markAsResumed?.(result.sessionId);
+      const forkedSession = {
+        id: result.sessionId,
+        providerId,
+        title: "Forked Chat",
+        projectName,
+        projectPath,
+        createdAt: new Date().toISOString(),
+      };
+      return c.json(ok({ ...forkedSession, forkedFrom: sourceId }), 201);
     } else {
       // No messageId (fork at first message) — create a fresh empty session
       const session = await chatService.createSession(providerId, {
@@ -261,20 +266,19 @@ chatRoutes.get("/sessions/:id/logs", (c) => {
 
 /** GET /chat/sessions/:id/debug — session debug info (IDs, JSONL path) */
 chatRoutes.get("/sessions/:id/debug", (c) => {
-  const ppmId = c.req.param("id");
-  const sdkId = getSessionMapping(ppmId) ?? ppmId;
-  // Resolve JSONL path: ~/.claude/projects/<encoded-cwd>/<sdkId>.jsonl
+  const sessionId = c.req.param("id");
+  // Resolve JSONL path: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl
   const homedir = process.env.HOME ?? process.env.USERPROFILE ?? "";
   const provider = providerRegistry.get("claude") as any;
   // Try in-memory first, fall back to DB-persisted project_path
-  const projectPath = provider?.activeSessions?.get(ppmId)?.projectPath
-    ?? getSessionProjectPath(ppmId)
+  const projectPath = provider?.activeSessions?.get(sessionId)?.projectPath
+    ?? getSessionProjectPath(sessionId)
     ?? "";
   const encodedCwd = projectPath ? projectPath.replace(/\//g, "-") : "";
   const jsonlDir = encodedCwd ? resolve(homedir, ".claude", "projects", encodedCwd) : "";
-  const jsonlPath = jsonlDir ? resolve(jsonlDir, `${sdkId}.jsonl`) : "";
+  const jsonlPath = jsonlDir ? resolve(jsonlDir, `${sessionId}.jsonl`) : "";
   const jsonlExists = jsonlPath ? existsSync(jsonlPath) : false;
-  return c.json(ok({ ppmSessionId: ppmId, sdkSessionId: sdkId, jsonlPath: jsonlExists ? jsonlPath : null, jsonlDir, projectPath }));
+  return c.json(ok({ sessionId, jsonlPath: jsonlExists ? jsonlPath : null, jsonlDir, projectPath }));
 });
 
 /** POST /chat/upload — upload files for chat attachments, returns server-side paths */

package/src/server/ws/chat.ts

@@ -85,6 +85,21 @@ function bufferAndBroadcast(sessionId: string, event: unknown): void {
     if (entry.turnEvents.length < MAX_TURN_EVENTS) {
       entry.turnEvents.push({ ...(event as Record<string, unknown>) });
     }
+    // Enrich: embed tool_result onto matching tool_use for reconnect reliability.
+    // Reconnecting clients may miss separate tool_result events — this ensures
+    // the tool_use event itself carries the result as a fallback.
+    if (evType === "tool_result") {
+      const toolUseId = (event as any)?.toolUseId;
+      if (toolUseId) {
+        for (let i = entry.turnEvents.length - 1; i >= 0; i--) {
+          const buffered = entry.turnEvents[i] as any;
+          if (buffered.type === "tool_use" && buffered.toolUseId === toolUseId) {
+            buffered.result = { output: (event as any).output, isError: (event as any).isError };
+            break;
+          }
+        }
+      }
+    }
   }
   broadcast(sessionId, event);
 }
@@ -208,23 +223,6 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
       const ev = event as any;
       const evType = ev.type ?? "unknown";
 
-      // Session ID migrated: CLI provider assigned a different ID than PPM generated.
-      // Migrate activeSessions key so all subsequent events use the real ID.
-      if (evType === "session_migrated") {
-        const { oldSessionId, newSessionId } = ev;
-        const migrated = activeSessions.get(oldSessionId);
-        if (migrated) {
-          activeSessions.delete(oldSessionId);
-          activeSessions.set(newSessionId, migrated);
-          sessionId = newSessionId; // update local ref for subsequent setPhase/broadcast calls
-          // Notify frontend to update its sessionId state
-          broadcast(newSessionId, { type: "session_migrated", oldSessionId, newSessionId });
-          console.log(`[chat] session migrated: ${oldSessionId} → ${newSessionId}`);
-          logSessionEvent(newSessionId, "INFO", `Session ID migrated from ${oldSessionId}`);
-        }
-        continue;
-      }
-
       // System events → transition connecting → thinking, forward compact events
       if (evType === "system") {
         const sub = (ev as any).subtype;
@@ -339,6 +337,17 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
             : `${project} — ${ev.tool} needs permission`;
           notificationService.broadcast(nType as any, { title, body, project, sessionId, sessionTitle: sTitle, tool: ev.tool });
         }).catch(() => {});
+      } else if (evType === "session_migrated") {
+        // CLI providers discover real session ID from CLI output — migrate WS tracking
+        const newId = ev.newSessionId as string;
+        if (newId && newId !== sessionId) {
+          console.log(`[chat] session_migrated: ${sessionId} → ${newId}`);
+          const oldEntry = activeSessions.get(sessionId);
+          if (oldEntry) {
+            activeSessions.delete(sessionId);
+            activeSessions.set(newId, oldEntry);
+          }
+        }
       } else {
         logSessionEvent(sessionId, evType.toUpperCase(), JSON.stringify(ev).slice(0, 200));
       }

package/src/services/cloud-ws.service.ts

@@ -152,7 +152,9 @@ function doConnect(): void {
   sock.onopen = () => {
     if (ws !== sock) return; // stale — newer connection replaced us
     reconnecting = false;
-    reconnectAttempt = 0;
+    // Don't reset reconnectAttempt here — only after auth succeeds.
+    // Resetting on open causes tight reconnect loops when the server
+    // keeps closing immediately after connect (backoff never builds up).
     log("INFO", "Cloud WS connected, sending auth");
 
     // Send auth as first message — server must process this before any other msg
@@ -170,6 +172,7 @@ function doConnect(): void {
     setTimeout(() => {
       if (ws !== sock) return; // replaced during delay
       connected = true;
+      reconnectAttempt = 0; // Auth succeeded — reset backoff
 
       // Flush queued messages
       while (outboundQueue.length > 0 && connected) {

package/src/services/config.service.ts

@@ -190,10 +190,11 @@ class ConfigService {
     const mapPath = resolve(PPM_DIR, "session-map.json");
     if (!existsSync(mapPath)) return;
     try {
-      const { setSessionMapping } = require("./db.service.ts");
+      const { setSessionMetadata } = require("./db.service.ts");
       const map = JSON.parse(readFileSync(mapPath, "utf-8")) as Record<string, string>;
-      for (const [ppmId, sdkId] of Object.entries(map)) {
-        setSessionMapping(ppmId, sdkId);
+      for (const [_ppmId, sdkId] of Object.entries(map)) {
+        // Use SDK ID as canonical session ID (ppmId is legacy)
+        setSessionMetadata(sdkId);
       }
       renameSync(mapPath, mapPath + ".bak");
       console.log("[config] Migrated session-map.json → SQLite");