@hienlh/ppm 0.9.79 → 0.9.80

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 {
@@ -266,8 +262,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 +271,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 +293,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,
@@ -388,13 +364,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     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 +398,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,
@@ -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

@@ -208,23 +208,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 +322,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/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");

package/src/services/db.service.ts

@@ -431,6 +431,53 @@ function runMigrations(database: Database): void {
     }
     database.exec("PRAGMA user_version = 15");
   }
+
+  if (current < 16) {
+    // Create session_metadata table — replaces dual-ID session_map system.
+    // Session ID is now always the SDK session ID (no more ppmId vs sdkId).
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS session_metadata (
+        session_id TEXT PRIMARY KEY,
+        project_name TEXT,
+        project_path TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+    // Migrate existing data from session_map: use sdk_id as the canonical session_id.
+    // Also migrate session_titles and session_pins that used old ppm_id keys.
+    try {
+      const rows = database.query("SELECT ppm_id, sdk_id, project_name, project_path FROM session_map").all() as
+        { ppm_id: string; sdk_id: string; project_name: string | null; project_path: string | null }[];
+      for (const row of rows) {
+        const canonicalId = row.sdk_id || row.ppm_id;
+        // Insert into session_metadata using canonical SDK ID
+        database.query(
+          "INSERT OR IGNORE INTO session_metadata (session_id, project_name, project_path) VALUES (?, ?, ?)",
+        ).run(canonicalId, row.project_name, row.project_path);
+        // Migrate session_titles from ppm_id to sdk_id if they differ
+        if (row.ppm_id !== row.sdk_id) {
+          const titleRow = database.query("SELECT title FROM session_titles WHERE session_id = ?").get(row.ppm_id) as { title: string } | null;
+          if (titleRow) {
+            database.query(
+              "INSERT OR IGNORE INTO session_titles (session_id, title, updated_at) VALUES (?, ?, datetime('now'))",
+            ).run(canonicalId, titleRow.title);
+            // Remove orphaned ppm_id entry
+            database.query("DELETE FROM session_titles WHERE session_id = ?").run(row.ppm_id);
+          }
+          // Migrate session_pins from ppm_id to sdk_id
+          const pinRow = database.query("SELECT 1 FROM session_pins WHERE session_id = ?").get(row.ppm_id);
+          if (pinRow) {
+            database.query("INSERT OR IGNORE INTO session_pins (session_id) VALUES (?)").run(canonicalId);
+            // Remove orphaned ppm_id entry
+            database.query("DELETE FROM session_pins WHERE session_id = ?").run(row.ppm_id);
+          }
+        }
+      }
+    } catch (e) {
+      console.warn(`[db] session_map migration warning: ${(e as Error).message}`);
+    }
+    database.exec("PRAGMA user_version = 16");
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -517,46 +564,28 @@ export function updateProject(currentName: string, newName: string, newPath: str
 }
 
 // ---------------------------------------------------------------------------
-// Session map helpers
+// Session project metadata helpers (replaced session_map dual-ID system)
 // ---------------------------------------------------------------------------
 
-export function getSessionMapping(ppmId: string): string | null {
-  const row = getDb().query("SELECT sdk_id FROM session_map WHERE ppm_id = ?").get(ppmId) as { sdk_id: string } | null;
-  return row?.sdk_id ?? null;
-}
-
-export function getSessionProjectPath(ppmId: string): string | null {
-  const row = getDb().query("SELECT project_path FROM session_map WHERE ppm_id = ?").get(ppmId) as { project_path: string } | null;
-  return row?.project_path ?? null;
-}
-
-/**
- * Set session mapping. By default, refuses to overwrite an existing real SDK ID
- * (one that differs from both ppmId and the new sdkId) to prevent orphaning JSONL history.
- * Pass force=true to override (e.g. session delete + recreate).
- */
-export function setSessionMapping(ppmId: string, sdkId: string, projectName?: string, projectPath?: string, force = false): void {
-  if (!force) {
-    const existing = getSessionMapping(ppmId);
-    if (existing && existing !== ppmId && existing !== sdkId) {
-      console.warn(`[db] Refusing to overwrite session mapping ${ppmId} → ${existing} with ${sdkId} (use force=true to override)`);
-      // Still update project metadata even when refusing sdk_id overwrite
-      getDb().query(
-        "UPDATE session_map SET project_name = COALESCE(?, session_map.project_name), project_path = COALESCE(?, session_map.project_path) WHERE ppm_id = ?",
-      ).run(projectName ?? null, projectPath ?? null, ppmId);
-      return;
-    }
-  }
+export function getSessionProjectPath(sessionId: string): string | null {
+  const row = getDb().query("SELECT project_path FROM session_metadata WHERE session_id = ?").get(sessionId) as { project_path: string } | null;
+  if (row?.project_path) return row.project_path;
+  // Legacy fallback: session_map.sdk_id is indexed (PRIMARY KEY is ppm_id, so try both)
+  const legacy = getDb().query("SELECT project_path FROM session_map WHERE ppm_id = ?").get(sessionId) as { project_path: string } | null;
+  if (legacy?.project_path) return legacy.project_path;
+  const legacySdk = getDb().query("SELECT project_path FROM session_map WHERE sdk_id = ?").get(sessionId) as { project_path: string } | null;
+  return legacySdk?.project_path ?? null;
+}
+
+/** Store project metadata for a session */
+export function setSessionMetadata(sessionId: string, projectName?: string, projectPath?: string): void {
   getDb().query(
-    "INSERT INTO session_map (ppm_id, sdk_id, project_name, project_path) VALUES (?, ?, ?, ?) ON CONFLICT(ppm_id) DO UPDATE SET sdk_id = excluded.sdk_id, project_name = COALESCE(excluded.project_name, session_map.project_name), project_path = COALESCE(excluded.project_path, session_map.project_path)",
-  ).run(ppmId, sdkId, projectName ?? null, projectPath ?? null);
+    "INSERT INTO session_metadata (session_id, project_name, project_path) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET project_name = COALESCE(excluded.project_name, session_metadata.project_name), project_path = COALESCE(excluded.project_path, session_metadata.project_path)",
+  ).run(sessionId, projectName ?? null, projectPath ?? null);
 }
 
-export function getAllSessionMappings(): Record<string, string> {
-  const rows = getDb().query("SELECT ppm_id, sdk_id FROM session_map").all() as { ppm_id: string; sdk_id: string }[];
-  const result: Record<string, string> = {};
-  for (const r of rows) result[r.ppm_id] = r.sdk_id;
-  return result;
+export function deleteSessionMetadata(sessionId: string): void {
+  getDb().query("DELETE FROM session_metadata WHERE session_id = ?").run(sessionId);
 }
 
 // ---------------------------------------------------------------------------
@@ -605,8 +634,9 @@ export function getPinnedSessionIds(): Set<string> {
   return new Set(rows.map((r) => r.session_id));
 }
 
-export function deleteSessionMapping(ppmId: string): void {
-  getDb().query("DELETE FROM session_map WHERE ppm_id = ?").run(ppmId);
+/** @deprecated Legacy cleanup — removes from old session_map if present */
+export function deleteSessionMapping(sessionId: string): void {
+  getDb().query("DELETE FROM session_map WHERE ppm_id = ? OR sdk_id = ?").run(sessionId, sessionId);
 }
 
 export function deleteSessionTitle(sessionId: string): void {

package/src/services/ppmbot/ppmbot-streamer.ts

@@ -48,7 +48,6 @@ export interface StreamResult {
   contextWindowPct?: number;
   resultSubtype?: ResultSubtype;
   messageIds: number[];
-  newSessionId?: string;
 }
 
 /**
@@ -222,11 +221,6 @@ export async function streamToTelegram(
           break eventLoop; // break the for-await, not just the switch
         }
 
-        case "session_migrated": {
-          result.newSessionId = event.newSessionId;
-          break;
-        }
-
         case "account_retry": {
           appendHtml(
             segments,

package/src/types/chat.ts

@@ -117,7 +117,6 @@ export type ChatEvent =
   | { type: "approval_request"; requestId: string; tool: string; input: unknown }
   | { type: "error"; message: string }
   | { type: "done"; sessionId: string; resultSubtype?: ResultSubtype; numTurns?: number; contextWindowPct?: number }
-  | { type: "session_migrated"; oldSessionId: string; newSessionId: string }
   | { type: "account_info"; accountId: string; accountLabel: string }
   | { type: "account_retry"; reason: string; accountId?: string; accountLabel?: string }
   | { type: "status_update"; phase: "routing" | "refreshing" | "switching"; message: string; accountLabel?: string }