Release v0.0.63

## What's New

**Features**
- **Fork Sub-Chat** — Fork a new sub-chat from any assistant message
- **Shared Terminals** — Terminals are now shared across local-mode workspaces

**Improvements & Fixes**
- **Scroll-to-Bottom** — Restored auto-scroll on chat open and tab switch
- **Early Access Updates** — No longer offers downgrade to older beta versions
- **Queue Attachments** — Show typed attachment labels instead of generic "files"
- **Traffic Lights** — Fixed visibility when agents sidebar is closed on app reopen

Author: serafimcloud

package.json

@@ -1,6 +1,6 @@
 {
   "name": "21st-desktop",
-  "version": "0.0.62",
+  "version": "0.0.63",
   "private": true,
   "description": "1Code - UI for parallel work with AI agents",
   "author": {

src/main/lib/auto-updater.ts

@@ -42,21 +42,18 @@ function getChannelPrefPath(): string {
 }
 
 function getSavedChannel(): UpdateChannel {
-  // Beta channel disabled until beta-mac.yml is published to CDN.
-  // Always use "latest" to prevent 404 errors for users who toggled Early Access.
+  try {
+    const prefPath = getChannelPrefPath()
+    if (existsSync(prefPath)) {
+      const data = JSON.parse(readFileSync(prefPath, "utf-8"))
+      if (data.channel === "beta" || data.channel === "latest") {
+        return data.channel
+      }
+    }
+  } catch {
+    // Ignore read errors, fall back to default
+  }
   return "latest"
-  // try {
-  //   const prefPath = getChannelPrefPath()
-  //   if (existsSync(prefPath)) {
-  //     const data = JSON.parse(readFileSync(prefPath, "utf-8"))
-  //     if (data.channel === "beta" || data.channel === "latest") {
-  //       return data.channel
-  //     }
-  //   }
-  // } catch {
-  //   // Ignore read errors, fall back to default
-  // }
-  // return "latest"
 }
 
 function saveChannel(channel: UpdateChannel): void {
@@ -98,6 +95,9 @@ export async function initAutoUpdater(getWindows: () => BrowserWindow[]) {
   // Set update channel from saved preference
   const savedChannel = getSavedChannel()
   autoUpdater.channel = savedChannel
+  // electron-updater auto-sets allowDowngrade=true when channel is changed.
+  // We never want to offer a downgrade (e.g. beta 0.0.60-beta.5 when stable is 0.0.62).
+  autoUpdater.allowDowngrade = false
   log.info(`[AutoUpdater] Using update channel: ${savedChannel}`)
 
   // Configure feed URL to point to R2 CDN
@@ -253,6 +253,9 @@ function registerIpcHandlers() {
     }
     log.info(`[AutoUpdater] Switching update channel to: ${channel}`)
     autoUpdater.channel = channel
+    // electron-updater auto-sets allowDowngrade=true when channel is changed.
+    // We never want to offer a downgrade — only show updates newer than current version.
+    autoUpdater.allowDowngrade = false
     saveChannel(channel)
     // Check for updates immediately with new channel
     if (app.isPackaged) {

src/main/lib/terminal/manager.ts

@@ -336,6 +336,23 @@ export class TerminalManager extends EventEmitter {
 		).length
 	}
 
+	/**
+	 * Get all alive sessions for a given scope key.
+	 * Used by new workspaces to discover shared terminals.
+	 */
+	getSessionsByScopeKey(
+		scopeKey: string,
+	): Array<{ paneId: string; cwd: string; lastActive: number }> {
+		return Array.from(this.sessions.values())
+			.filter((session) => session.scopeKey === scopeKey && session.isAlive)
+			.map((session) => ({
+				paneId: session.paneId,
+				cwd: session.cwd,
+				lastActive: session.lastActive,
+			}))
+	}
+
+
 	/**
 	 * Send a newline to all terminals in a workspace to refresh their prompts.
 	 * Useful after switching branches to update the branch name in prompts.

src/main/lib/terminal/session.ts

@@ -156,6 +156,7 @@ export async function createSession(
 		pty: ptyProcess,
 		paneId,
 		workspaceId: workspaceId || "",
+		scopeKey: params.scopeKey || workspaceId || "",
 		cwd: workingDir,
 		cols: terminalCols,
 		rows: terminalRows,

src/main/lib/terminal/types.ts

@@ -4,6 +4,8 @@ export interface TerminalSession {
 	pty: pty.IPty
 	paneId: string
 	workspaceId: string
+	/** Terminal scope key: "path:<dir>" for shared (local mode) or "ws:<chatId>" for isolated (worktree mode) */
+	scopeKey: string
 	cwd: string
 	cols: number
 	rows: number
@@ -38,6 +40,8 @@ export interface CreateSessionParams {
 	paneId: string
 	tabId?: string
 	workspaceId?: string
+	/** Terminal scope key: "path:<dir>" for shared (local mode) or "ws:<chatId>" for isolated (worktree mode) */
+	scopeKey?: string
 	workspaceName?: string
 	workspacePath?: string
 	rootPath?: string

src/main/lib/trpc/routers/chats.ts

@@ -514,16 +514,21 @@ export const chatsRouter = router({
       // Track workspace archived
       trackWorkspaceArchived(input.id)
 
-      // Kill terminal processes in background (don't await)
-      terminalManager.killByWorkspaceId(input.id).then((killResult) => {
-        if (killResult.killed > 0) {
-          console.log(
-            `[chats.archive] Killed ${killResult.killed} terminal session(s) for workspace ${input.id}`,
-          )
-        }
-      }).catch((error) => {
-        console.error(`[chats.archive] Error killing processes:`, error)
-      })
+      // Kill terminal processes only for worktree-mode workspaces.
+      // Local-mode terminals are shared across workspaces on the same project path,
+      // so they should not be killed when a single workspace is archived.
+      const isLocalMode = !chat?.branch
+      if (!isLocalMode) {
+        terminalManager.killByWorkspaceId(input.id).then((killResult) => {
+          if (killResult.killed > 0) {
+            console.log(
+              `[chats.archive] Killed ${killResult.killed} terminal session(s) for workspace ${input.id}`,
+            )
+          }
+        }).catch((error) => {
+          console.error(`[chats.archive] Error killing processes:`, error)
+        })
+      }
 
       // Optionally delete worktree in background (don't await)
       if (input.deleteWorktree && chat?.worktreePath && chat?.branch) {
@@ -588,6 +593,14 @@ export const chatsRouter = router({
       const db = getDatabase()
       if (input.chatIds.length === 0) return []
 
+      // Identify worktree-mode workspaces before archiving (for terminal cleanup)
+      const worktreeChats = db
+        .select({ id: chats.id, branch: chats.branch })
+        .from(chats)
+        .where(inArray(chats.id, input.chatIds))
+        .all()
+        .filter((c) => c.branch != null)
+
       // Archive immediately (optimistic)
       const result = db
         .update(chats)
@@ -596,19 +609,23 @@ export const chatsRouter = router({
         .returning()
         .all()
 
-      // Kill terminal processes for all workspaces in background (don't await)
-      Promise.all(
-        input.chatIds.map((id) => terminalManager.killByWorkspaceId(id)),
-      ).then((killResults) => {
-        const totalKilled = killResults.reduce((sum, r) => sum + r.killed, 0)
-        if (totalKilled > 0) {
-          console.log(
-            `[chats.archiveBatch] Killed ${totalKilled} terminal session(s) for ${input.chatIds.length} workspace(s)`,
-          )
-        }
-      }).catch((error) => {
-        console.error(`[chats.archiveBatch] Error killing processes:`, error)
-      })
+      // Kill terminal processes only for worktree-mode workspaces.
+      // Local-mode terminals are shared and should not be killed.
+
+      if (worktreeChats.length > 0) {
+        Promise.all(
+          worktreeChats.map((c) => terminalManager.killByWorkspaceId(c.id)),
+        ).then((killResults) => {
+          const totalKilled = killResults.reduce((sum, r) => sum + r.killed, 0)
+          if (totalKilled > 0) {
+            console.log(
+              `[chats.archiveBatch] Killed ${totalKilled} terminal session(s) for ${worktreeChats.length} worktree workspace(s)`,
+            )
+          }
+        }).catch((error) => {
+          console.error(`[chats.archiveBatch] Error killing processes:`, error)
+        })
+      }
 
       return result
     }),
@@ -639,6 +656,14 @@ export const chatsRouter = router({
         }
       }
 
+      // Kill terminal processes for worktree-mode workspaces.
+      // Local-mode terminals are shared and should not be killed on delete.
+      if (chat?.branch) {
+        terminalManager.killByWorkspaceId(input.id).catch((error) => {
+          console.error(`[chats.delete] Error killing processes:`, error)
+        })
+      }
+
       // Track workspace deleted
       trackWorkspaceDeleted(input.id)
 
@@ -710,6 +735,148 @@ export const chatsRouter = router({
         .get()
     }),
 
+  /**
+   * Fork a sub-chat from a specific message, preserving SDK session context.
+   * Creates a new sub-chat with messages up to the target message,
+   * copies the .jsonl session file, and marks it for forkSession resume.
+   */
+  forkSubChat: publicProcedure
+    .input(
+      z.object({
+        subChatId: z.string(),
+        messageId: z.string(),
+        name: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      const db = getDatabase()
+
+      // 1. Get the source sub-chat
+      const sourceSubChat = db
+        .select()
+        .from(subChats)
+        .where(eq(subChats.id, input.subChatId))
+        .get()
+      if (!sourceSubChat) throw new Error("Source sub-chat not found")
+
+      // 2. Parse messages and find the cutoff point
+      const allMessages = JSON.parse(sourceSubChat.messages || "[]")
+      const cutoffIndex = allMessages.findIndex(
+        (m: any) => m.id === input.messageId,
+      )
+      if (cutoffIndex === -1) throw new Error("Message not found")
+
+      // 3. Slice messages up to and including the target
+      const messagesToFork = allMessages.slice(0, cutoffIndex + 1)
+
+      // 4. Find sdkMessageUuid of last assistant message (for resumeSessionAt)
+      const lastAssistant = [...messagesToFork]
+        .reverse()
+        .find((m: any) => m.role === "assistant")
+      const forkAtSdkUuid = lastAssistant?.metadata?.sdkMessageUuid || null
+
+      // 5. Generate new IDs for all messages + set shouldForkResume on last assistant
+      const forkedMessages = messagesToFork.map((msg: any, i: number) => ({
+        ...msg,
+        id: `fork-${Date.now()}-${i}-${Math.random().toString(36).slice(2, 7)}`,
+        metadata: {
+          ...msg.metadata,
+          shouldResume: undefined,
+          ...(msg === lastAssistant &&
+            forkAtSdkUuid && {
+              shouldForkResume: true,
+            }),
+        },
+      }))
+
+      // 6. Generate fork name: [N] originalName
+      let forkName = input.name
+      if (!forkName) {
+        // Strip existing [N] prefix from source name to get base name
+        const sourceName = sourceSubChat.name || "Chat"
+        const baseName = sourceName.replace(/^\[\d+\]\s*/, "")
+
+        // Find highest [N] among all sibling sub-chats
+        const siblings = db
+          .select({ name: subChats.name })
+          .from(subChats)
+          .where(eq(subChats.chatId, sourceSubChat.chatId))
+          .all()
+
+        let maxN = 0
+        for (const s of siblings) {
+          const match = s.name?.match(/^\[(\d+)\]/)
+          if (match) {
+            maxN = Math.max(maxN, parseInt(match[1], 10))
+          }
+        }
+
+        forkName = `[${maxN + 1}] ${baseName}`
+      }
+
+      // 7. Insert new sub-chat with sessionId from original (needed for resume)
+      const newSubChat = db
+        .insert(subChats)
+        .values({
+          chatId: sourceSubChat.chatId,
+          name: forkName,
+          mode: sourceSubChat.mode,
+          messages: JSON.stringify(forkedMessages),
+          sessionId: sourceSubChat.sessionId,
+        })
+        .returning()
+        .get()
+
+      // 8. Copy .jsonl session files to the new isolated config dir
+      if (sourceSubChat.sessionId) {
+        try {
+          const { app } = await import("electron")
+          const userDataPath = app.getPath("userData")
+          const sourceDir = path.join(
+            userDataPath,
+            "claude-sessions",
+            input.subChatId,
+            "projects",
+          )
+          const targetDir = path.join(
+            userDataPath,
+            "claude-sessions",
+            newSubChat.id,
+            "projects",
+          )
+
+          const sourceDirExists = await fs
+            .stat(sourceDir)
+            .then(() => true)
+            .catch(() => false)
+
+          if (sourceDirExists) {
+            await fs.cp(sourceDir, targetDir, { recursive: true })
+          }
+        } catch (err) {
+          console.warn("[forkSubChat] Failed to copy session files:", err)
+          // Clear shouldForkResume since there's no .jsonl to fork from
+          for (const m of forkedMessages) {
+            if (m.metadata?.shouldForkResume) {
+              delete m.metadata.shouldForkResume
+            }
+          }
+          db.update(subChats)
+            .set({ messages: JSON.stringify(forkedMessages) })
+            .where(eq(subChats.id, newSubChat.id))
+            .run()
+        }
+      }
+
+      console.log("[forkSubChat] Created", { id: newSubChat.id, name: forkName, messages: forkedMessages.length })
+
+      return {
+        subChat: newSubChat,
+        messageCount: forkedMessages.length,
+        forkAtSdkUuid,
+      }
+    }),
+
   /**
    * Update sub-chat messages
    */