@hienlh/ppm 0.8.94 → 0.8.95

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

@@ -19,9 +19,11 @@ import { getSessionMapping, getSessionProjectPath, setSessionMapping, getSession
 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;
 }
@@ -323,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 */ }
   }
 
   /**
@@ -341,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" },
@@ -704,6 +744,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;
@@ -852,6 +910,18 @@ 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;
+            }
+
             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.",
@@ -1100,7 +1170,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);
   }

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, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession } from "../../services/db.service.ts";
+import { getSessionMapping, getSessionProjectPath, setSessionMapping, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession, deleteSessionMapping, deleteSessionTitle } from "../../services/db.service.ts";
 import { ok, err } from "../../types/api.ts";
 
 type Env = { Variables: { projectPath: string; projectName: string } };
@@ -125,7 +125,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);
     return c.json(ok({ deleted: id }));
   } catch (e) {
     return c.json(err((e as Error).message), 404);
@@ -184,16 +190,31 @@ chatRoutes.post("/sessions/:id/fork", async (c) => {
     const projectName = c.get("projectName");
     const projectPath = c.get("projectPath");
     const providerId = c.req.query("providerId") ?? "claude";
-    // Create a new PPM session that will fork from sourceId on first message
-    const session = await chatService.createSession(providerId, {
-      projectName,
-      projectPath,
-      title: "Forked Chat",
-    });
-    // Store fork source so WS handler knows to use forkSession on first message
+    const body = await c.req.json<{ messageId?: string }>().catch(() => ({} as { messageId?: string }));
     const provider = providerRegistry.get(providerId);
-    provider?.setForkSource?.(session.id, sourceId);
-    return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+    if (!provider) return c.json(err("Provider not found"), 404);
+
+    if (body.messageId) {
+      // Mid-fork at a specific message
+      if (!provider.forkAtMessage) {
+        return c.json(err("Provider does not support forking"), 400);
+      }
+      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);
+    } else {
+      // No messageId (fork at first message) — create a fresh empty session
+      const session = await chatService.createSession(providerId, {
+        projectName, projectPath, title: "Forked Chat",
+      });
+      return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+    }
   } catch (e) {
     return c.json(err((e as Error).message), 500);
   }

package/src/server/routes/settings.ts

@@ -252,6 +252,33 @@ settingsRoutes.post("/telegram/test", async (c) => {
   }
 });
 
+// ── Auth / Password ──────────────────────────────────────────────────
+
+/** PUT /settings/auth/password — change the access password (token) */
+settingsRoutes.put("/auth/password", async (c) => {
+  try {
+    const { password, confirm } = await c.req.json<{ password: string; confirm: string }>();
+    if (typeof password !== "string" || !password.trim()) {
+      return c.json(err("Password is required"), 400);
+    }
+    if (password !== confirm) {
+      return c.json(err("Passwords do not match"), 400);
+    }
+    const trimmed = password.trim();
+    if (trimmed.length < 4) {
+      return c.json(err("Password must be at least 4 characters"), 400);
+    }
+
+    const auth = configService.get("auth");
+    configService.set("auth", { ...auth, token: trimmed });
+    configService.save();
+
+    return c.json(ok({ token: trimmed }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 400);
+  }
+});
+
 // ── Proxy ────────────────────────────────────────────────────────────
 
 /** GET /settings/proxy — proxy status */

package/src/server/ws/chat.ts

@@ -218,8 +218,14 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         continue;
       }
 
-      // System events → transition connecting → thinking
+      // System events → transition connecting → thinking, forward compact events
       if (evType === "system") {
+        const sub = (ev as any).subtype;
+        if (sub === "compacting") {
+          broadcast(sessionId, { type: "compact_status", status: "compacting" });
+        } else if (sub === "compact_done") {
+          broadcast(sessionId, { type: "compact_status", status: "done" });
+        }
         if (!firstEventReceived) {
           if (heartbeat) clearInterval(heartbeat);
           setPhase(sessionId, "thinking");

package/src/services/account.service.ts

@@ -139,7 +139,7 @@ class AccountService {
       await this.refreshAccessToken(id, false);
       return this.getWithTokens(id);
     } catch (e) {
-      console.error(`[accounts] Pre-flight refresh failed for ${id}:`, e);
+      console.error(`[accounts] Pre-flight refresh failed for ${id}: ${(e as Error).message ?? e}`);
       return null;
     }
   }
@@ -709,7 +709,7 @@ class AccountService {
         try {
           await this.refreshAccessToken(acc.id, false);
         } catch (e) {
-          console.error(`[accounts] Auto-refresh failed for ${acc.id}:`, e);
+          console.error(`[accounts] Auto-refresh failed for ${acc.id}: ${(e as Error).message ?? e}`);
         }
       }
     };

package/src/services/claude-usage.service.ts

@@ -273,14 +273,9 @@ export function getUsageForAccount(accountId: string): ClaudeUsage {
   return row ? snapshotToUsage(row) : {};
 }
 
-/** Get usage for all accounts (excludes expired temporary accounts) */
+/** Get usage for all accounts */
 export function getAllAccountUsages(): AccountUsageEntry[] {
-  const nowS = Math.floor(Date.now() / 1000);
-  const accounts = accountService.list().filter(acc => {
-    // Exclude expired accounts without refresh token (temporary/invalid)
-    if (!accountService.hasRefreshToken(acc.id) && acc.expiresAt && acc.expiresAt < nowS) return false;
-    return true;
-  });
+  const accounts = accountService.list();
   const snapshots = getAllLatestSnapshots();
   const snapshotMap = new Map(snapshots.map(s => [s.account_id, s]));
   return accounts.map(acc => {

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

@@ -21,6 +21,7 @@ interface HeartbeatMsg extends WsMessage {
   availableVersion: string | null;
   serverPid: number | null;
   uptime: number;
+  deviceName?: string;
 }
 
 interface StateChangeMsg extends WsMessage {

package/src/services/cloud.service.ts

@@ -354,6 +354,7 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
         secret_key: device.secret_key,
         tunnel_url: tunnelUrl,
         status: "online",
+        name: device.name,
       }),
     });
     return res.ok;

package/src/services/db.service.ts

@@ -444,6 +444,14 @@ 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);
+}
+
+export function deleteSessionTitle(sessionId: string): void {
+  getDb().query("DELETE FROM session_titles WHERE session_id = ?").run(sessionId);
+}
+
 // ---------------------------------------------------------------------------
 // Push subscription helpers
 // ---------------------------------------------------------------------------

package/src/services/mcp-config.service.ts

@@ -27,13 +27,22 @@ export class McpConfigService {
 
   /** List all MCP servers as Record (SDK-compatible format) */
   list(): Record<string, McpServerConfig> {
-    const rows = this.db.query("SELECT name, config FROM mcp_servers ORDER BY name").all() as { name: string; config: string }[];
-    const result: Record<string, McpServerConfig> = {};
-    for (const row of rows) {
-      const parsed = safeParse(row.config, row.name);
-      if (parsed) result[row.name] = parsed;
+    try {
+      const rows = this.db.query("SELECT name, config FROM mcp_servers ORDER BY name").all() as { name: string; config: string }[];
+      const result: Record<string, McpServerConfig> = {};
+      for (const row of rows) {
+        const parsed = safeParse(row.config, row.name);
+        if (parsed) result[row.name] = parsed;
+      }
+      return result;
+    } catch (e) {
+      const msg = (e as Error).message ?? String(e);
+      if (msg.includes("no such table")) {
+        console.warn("[mcp] mcp_servers table not found — returning empty list");
+        return {};
+      }
+      throw e;
     }
-    return result;
   }
 
   /** List as array with metadata (for UI) */

package/src/services/supervisor.ts

@@ -378,17 +378,33 @@ function adoptTunnel(): boolean {
     const status = readStatus();
     const pid = status.tunnelPid as number;
     const url = status.shareUrl as string;
-    if (!pid || !url) return false;
+    if (!pid || !url) {
+      log("DEBUG", `adoptTunnel: missing tunnelPid(${pid}) or shareUrl(${url}) in status`);
+      return false;
+    }
     process.kill(pid, 0); // throws if process is dead
     adoptedTunnelPid = pid;
     tunnelUrl = url;
     log("INFO", `Adopted existing tunnel (PID: ${pid}, URL: ${url})`);
     return true;
-  } catch {
+  } catch (e) {
+    log("WARN", `adoptTunnel: tunnel PID ${(readStatus().tunnelPid)} unreachable: ${e}`);
     return false;
   }
 }
 
+/** Kill stale tunnel PID from status.json (cleanup after failed adoption) */
+function killStaleTunnel() {
+  try {
+    const status = readStatus();
+    const pid = status.tunnelPid as number;
+    if (!pid) return;
+    try { process.kill(pid, "SIGTERM"); } catch {}
+    log("INFO", `Killed stale tunnel (PID: ${pid})`);
+  } catch {}
+  updateStatus({ tunnelPid: null, shareUrl: null });
+}
+
 /** Spawn new supervisor from updated code, wait for it to be healthy, then exit */
 async function selfReplace(): Promise<{ success: boolean; error?: string }> {
   log("INFO", "Starting self-replace for upgrade");
@@ -490,6 +506,8 @@ async function connectCloud(opts: { port: number }, serverArgs: string[], logFd:
       secretKey: device.secret_key,
       heartbeatFn: () => {
         const status = readStatus();
+        // Re-read device file each heartbeat to pick up name changes
+        const currentDevice = getCloudDevice();
         return {
           type: "heartbeat" as const,
           tunnelUrl,
@@ -499,6 +517,7 @@ async function connectCloud(opts: { port: number }, serverArgs: string[], logFd:
           availableVersion: (status.availableVersion as string) || null,
           serverPid: serverChild?.pid ?? null,
           uptime: Math.floor((Date.now() - startTime) / 1000),
+          deviceName: currentDevice?.name ?? device.name,
           timestamp: new Date().toISOString(),
         };
       },
@@ -559,30 +578,6 @@ async function connectCloud(opts: { port: number }, serverArgs: string[], logFd:
           }, 500);
           break;
 
-        case "upgrade": {
-          // Install new version FIRST (same as CLI / HTTP route)
-          const { applyUpgrade } = await import("./upgrade.service.ts");
-          sendResult(true, undefined, { status: "installing" });
-          await new Promise(r => setTimeout(r, 300));
-          const installResult = await applyUpgrade();
-          if (!installResult.success) {
-            sendResult(false, installResult.error);
-            break;
-          }
-          // New version installed — self-replace to pick it up
-          sendResult(true, undefined, { status: "upgrading", newVersion: installResult.newVersion });
-          await new Promise(r => setTimeout(r, 300));
-          const result = await selfReplace();
-          // Only reaches here on failure — selfReplace exits on success
-          if (!result.success) {
-            sendResult(false, result.error);
-            if (!serverChild && !shuttingDown) {
-              spawnServer(serverArgs, logFd);
-            }
-          }
-          break;
-        }
-
         case "status":
           sendResult(true, undefined, {
             state: supervisorState,
@@ -706,6 +701,7 @@ export async function runSupervisor(opts: {
     startTunnelProbe(opts.port);
     // Try adopting tunnel kept alive from previous upgrade; spawn new if dead
     if (!adoptTunnel()) {
+      killStaleTunnel(); // kill orphaned tunnel before spawning new one
       promises.push(spawnTunnel(opts.port));
     }
   }

package/src/types/api.ts

@@ -44,4 +44,5 @@ export type ChatWsServerMessage =
   | { type: "session_state"; sessionId: string; phase: SessionPhase; pendingApproval: { requestId: string; tool: string; input: unknown } | null; sessionTitle: string | null }
   | { type: "turn_events"; events: unknown[] }
   | { type: "title_updated"; title: string }
+  | { type: "compact_status"; status: "compacting" | "done" }
   | { type: "ping" };

package/src/types/chat.ts

@@ -29,6 +29,8 @@ export interface AIProvider {
   listSessionsByDir?(dir: string): Promise<SessionInfo[]>;
   ensureProjectPath?(sessionId: string, path: string): void;
   setForkSource?(sessionId: string, sourceSessionId: string): void;
+  forkAtMessage?(sessionId: string, messageId: string, opts?: { title?: string; dir?: string }): Promise<{ sessionId: string }>;
+  markAsResumed?(sessionId: string): void;
   isAvailable?(): Promise<boolean>;
   listModels?(): Promise<ModelOption[]>;
 }

package/src/web/app.tsx

@@ -37,6 +37,7 @@ type AuthState = "checking" | "authenticated" | "unauthenticated";
 
 export function App() {
   const [authState, setAuthState] = useState<AuthState>("checking");
+  const [upgradeBannerVisible, setUpgradeBannerVisible] = useState(false);
   const [drawerOpen, setDrawerOpen] = useState(false);
   const [drawerTab, setDrawerTab] = useState<"explorer" | "git" | "settings" | undefined>();
   const [projectSheetOpen, setProjectSheetOpen] = useState(false);
@@ -229,11 +230,11 @@ export function App() {
     <TooltipProvider>
       <div className="h-dvh flex flex-col bg-background text-foreground overflow-hidden relative">
         {/* Upgrade banner — shown when new version available */}
-        <UpgradeBanner />
+        <UpgradeBanner onVisibilityChange={setUpgradeBannerVisible} />
 
         {/* Mobile device name badge — floating top-left */}
         {deviceName && (
-          <div className="md:hidden fixed top-0 left-0 z-50 px-2 py-0.5 bg-primary/80 text-primary-foreground text-[10px] font-medium rounded-br">
+          <div className={cn("md:hidden fixed left-0 z-50 px-2 py-0.5 bg-primary/80 text-primary-foreground text-[10px] font-medium rounded-br transition-[top]", upgradeBannerVisible ? "top-7" : "top-0")}>
             {deviceName}
           </div>
         )}

package/src/web/components/chat/chat-history-bar.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback, useRef } from "react";
-import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff } from "lucide-react";
+import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff, Trash2 } from "lucide-react";
 import { Activity } from "lucide-react";
 import { api, projectUrl } from "@/lib/api-client";
 import { useTabStore } from "@/stores/tab-store";
@@ -16,6 +16,7 @@ interface ChatHistoryBarProps {
   projectName: string;
   usageInfo: UsageInfo;
   contextWindowPct?: number | null;
+  compactStatus?: "compacting" | null;
   usageLoading?: boolean;
   refreshUsage?: () => void;
   lastFetchedAt?: string | null;
@@ -79,7 +80,7 @@ function DebugCopyButton({ sessionId, projectName }: { sessionId: string; projec
 }
 
 export function ChatHistoryBar({
-  projectName, usageInfo, contextWindowPct, usageLoading, refreshUsage, lastFetchedAt,
+  projectName, usageInfo, contextWindowPct, compactStatus, usageLoading, refreshUsage, lastFetchedAt,
   sessionId, providerId, onSelectSession, onBugReport, isConnected, onReconnect,
 }: ChatHistoryBarProps) {
   const [activePanel, setActivePanel] = useState<PanelType>(null);
@@ -172,6 +173,16 @@ export function ChatHistoryBar({
     } catch { /* silent */ }
   }, [projectName]);
 
+  const deleteSession = useCallback(async (e: React.MouseEvent, session: SessionInfo) => {
+    e.stopPropagation();
+    if (!projectName) return;
+    if (!window.confirm("Delete this session? This cannot be undone.")) return;
+    try {
+      await api.del(`${projectUrl(projectName)}/chat/sessions/${session.id}?providerId=${session.providerId}`);
+      setSessions((prev) => prev.filter((s) => s.id !== session.id));
+    } catch { /* silent */ }
+  }, [projectName]);
+
   // Filter sessions by search query
   const filteredSessions = searchQuery.trim()
     ? sessions.filter((s) => (s.title || "").toLowerCase().includes(searchQuery.toLowerCase()))
@@ -240,14 +251,27 @@ export function ChatHistoryBar({
                 <span className={pctColor(contextWindowPct)}>Ctx:{contextWindowPct}%</span>
               </>
             )}
+            {compactStatus === "compacting" && (
+              <>
+                <span className="text-text-subtle">·</span>
+                <span className="text-blue-400 animate-pulse">compacting...</span>
+              </>
+            )}
           </button>
         ) : (
-          contextWindowPct != null && (
-            <span className={`flex items-center gap-1 px-1.5 py-0.5 text-[11px] font-medium tabular-nums ${pctColor(contextWindowPct)}`}>
-              <Activity className="size-3" />
-              <span>Ctx:{contextWindowPct}%</span>
-            </span>
-          )
+          <>
+            {contextWindowPct != null && (
+              <span className={`flex items-center gap-1 px-1.5 py-0.5 text-[11px] font-medium tabular-nums ${pctColor(contextWindowPct)}`}>
+                <Activity className="size-3" />
+                <span>Ctx:{contextWindowPct}%</span>
+              </span>
+            )}
+            {compactStatus === "compacting" && (
+              <span className="text-[11px] px-1.5 py-0.5 text-blue-400 animate-pulse">
+                compacting...
+              </span>
+            )}
+          </>
         )}
 
         {/* Spacer */}
@@ -369,6 +393,13 @@ export function ChatHistoryBar({
                       >
                         <Pencil className="size-3" />
                       </button>
+                      <button
+                        onClick={(e) => deleteSession(e, session)}
+                        className="p-0.5 rounded text-text-subtle hover:text-red-400 hover:bg-red-500/20 md:opacity-0 md:group-hover:opacity-100 transition-opacity"
+                        title="Delete session"
+                      >
+                        <Trash2 className="size-3" />
+                      </button>
                     </>
                   )}
                   {editingId !== session.id && session.updatedAt && (

package/src/web/components/chat/chat-tab.tsx

@@ -89,6 +89,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     connectingElapsed,
     pendingApproval,
     contextWindowPct,
+    compactStatus,
     sessionTitle,
     migratedSessionId,
     sendMessage,
@@ -134,14 +135,12 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     }
   }, [sessionTitle]); // eslint-disable-line react-hooks/exhaustive-deps
 
-  // Auto-send pending message for forked sessions (set by handleFork)
-  const pendingForkMsgRef = useRef(metadata?.pendingMessage as string | undefined);
+  // Pending fork message — show in input for user to edit, not auto-send
+  const [forkDraft, setForkDraft] = useState<string | undefined>(metadata?.pendingMessage as string | undefined);
   useEffect(() => {
-    if (pendingForkMsgRef.current && isConnected && sessionId) {
-      const msg = pendingForkMsgRef.current;
-      pendingForkMsgRef.current = undefined;
-      if (tabId) updateTab(tabId, { metadata: { ...metadata, pendingMessage: undefined } });
-      setTimeout(() => sendMessage(msg, { permissionMode }), 100);
+    if (forkDraft && isConnected && sessionId && tabId) {
+      // Clear from tab metadata once consumed
+      updateTab(tabId, { metadata: { ...metadata, pendingMessage: undefined } });
     }
   }, [isConnected, sessionId]); // eslint-disable-line react-hooks/exhaustive-deps
 
@@ -162,12 +161,13 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   }, [tabId, updateTab]);
 
   /** Fork current session and open new tab with the forked session, resending userMessage */
-  const handleFork = useCallback(async (userMessage: string) => {
+  const handleFork = useCallback(async (userMessage: string, messageId?: string) => {
     if (!sessionId || !projectName) return;
     try {
       const { api, projectUrl } = await import("@/lib/api-client");
       const forked = await api.post<{ id: string; forkedFrom: string }>(
         `${projectUrl(projectName)}/chat/sessions/${sessionId}/fork?providerId=${providerId}`,
+        { messageId },
       );
       // Open new chat tab with forked session — it will send userMessage on connect
       useTabStore.getState().openTab({
@@ -350,6 +350,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           projectName={projectName}
           usageInfo={usageInfo}
           contextWindowPct={contextWindowPct}
+          compactStatus={compactStatus}
           usageLoading={usageLoading}
           refreshUsage={refreshUsage}
           lastFetchedAt={lastFetchedAt}
@@ -382,10 +383,14 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
 
         {/* Input */}
         <MessageInput
-          onSend={handleSend}
+          onSend={(content, attachments, priority) => {
+            if (forkDraft) setForkDraft(undefined);
+            handleSend(content, attachments, priority);
+          }}
           isStreaming={isStreaming}
           onCancel={cancelStreaming}
-          autoFocus={!(metadata?.sessionId)}
+          autoFocus={!(metadata?.sessionId) || !!forkDraft}
+          initialValue={forkDraft}
           projectName={projectName}
           onSlashStateChange={handleSlashStateChange}
           onSlashItemsLoaded={setSlashItems}