@brimveyn/aimux 1.14.11 → 1.14.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.11",
+  "version": "1.14.14",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.6",
+    "@brimveyn/aimux-config": "0.6.8",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/side-effects.ts

@@ -29,7 +29,6 @@ import {
   removeGitWorktree,
 } from '../git/worktree'
 import { createPrefixedId } from '../platform/id'
-import { linkNodeModules } from '../platform/worktree-deps'
 import {
   assertSafeAimuxWorktreePath,
   isInsideAimuxWorktreeRoot,
@@ -1337,9 +1336,6 @@ async function createAimuxTempWorktree(
   await mkdir(dirname(targetPath), { recursive: true })
   await assertSafeAimuxWorktreePath(targetPath)
   await createGitWorktree({ baseRef, branchName, repoPath: repoRoot, targetPath })
-  // For JS projects, reuse the source checkout's installed dependencies instead
-  // of forcing a fresh install in the new worktree.
-  const linkedModules = await linkNodeModules(sourcePath, targetPath).catch(() => false)
   const now = new Date().toISOString()
 
   const worktree: WorktreeRecord = {
@@ -1364,11 +1360,7 @@ async function createAimuxTempWorktree(
   }))
   saveSessionCatalog(sessions)
   ctx.dispatch({ sessions, type: 'set-sessions' })
-  toast.success(
-    linkedModules
-      ? `Created worktree ${branchName} (linked node_modules)`
-      : `Created worktree ${branchName}`
-  )
+  toast.success(`Created worktree ${branchName}`)
   return worktree
 }
 

package/src/state/reducers/session-state.ts

@@ -28,12 +28,24 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       // honor the patched worktree by filtering the restored tab list.
       const loadedSession = state.sessions.find((entry) => entry.id === action.sessionId)
       const visible = filterTabsForActiveWorktree(restored.tabs, loadedSession)
-      const activeTabId =
+      // Prefer the snapshot's tab; if it isn't visible under the active
+      // worktree (e.g. a multi-worktree session restored onto a different
+      // worktree), fall back to the last tab we viewed in that worktree,
+      // then to the first visible tab.
+      const rememberedForWorktree =
+        loadedSession?.activeWorktreeId != null && loadedSession.activeWorktreeId !== ''
+          ? state.lastActiveTabByWorktree[loadedSession.activeWorktreeId]
+          : undefined
+      const snapshotTabVisible =
         restored.activeTabId != null &&
         restored.activeTabId !== '' &&
         visible.some((t) => t.id === restored.activeTabId)
-          ? restored.activeTabId
-          : (visible[0]?.id ?? null)
+      const rememberedTabVisible =
+        rememberedForWorktree != null &&
+        rememberedForWorktree !== '' &&
+        visible.some((t) => t.id === rememberedForWorktree)
+      const fallbackTabId = rememberedTabVisible ? rememberedForWorktree : (visible[0]?.id ?? null)
+      const activeTabId = snapshotTabVisible ? restored.activeTabId : fallbackTabId
       return {
         ...state,
         ...restored,
@@ -196,15 +208,29 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       const sessions = state.sessions.map((session) =>
         session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session
       )
+      // Remember the tab we're leaving so coming back to this worktree later
+      // restores it instead of snapping to the first tab. Keyed by the
+      // worktree we're departing (the current session's active one).
+      const leavingSession = state.sessions.find((s) => s.id === action.sessionId)
+      const leavingWorktreeId = leavingSession?.activeWorktreeId
+      const lastActiveTabByWorktree =
+        action.sessionId === state.currentSessionId &&
+        leavingWorktreeId != null &&
+        leavingWorktreeId !== '' &&
+        state.activeTabId != null &&
+        state.activeTabId !== ''
+          ? { ...state.lastActiveTabByWorktree, [leavingWorktreeId]: state.activeTabId }
+          : state.lastActiveTabByWorktree
       // Changing the worktree of a non-current session has no effect on
       // which tab the user is looking at — leave activeTabId alone.
       if (action.sessionId !== state.currentSessionId) {
-        return { ...state, sessions }
+        return { ...state, lastActiveTabByWorktree, sessions }
       }
       // For the current session: if the existing activeTabId belongs to
-      // the new worktree, keep it. Otherwise hop to the first tab visible
-      // under that worktree (or clear it if the worktree is empty — the
-      // pane then renders the "this worktree has no tabs" placeholder).
+      // the new worktree, keep it. Otherwise restore the last tab we viewed
+      // in that worktree, falling back to the first visible tab (or clearing
+      // it if the worktree is empty — the pane then renders the "this
+      // worktree has no tabs" placeholder).
       const updated = sessions.find((s) => s.id === action.sessionId)
       const visible = filterTabsForActiveWorktree(state.tabs, updated)
       const currentStillVisible =
@@ -212,9 +238,14 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
         state.activeTabId !== '' &&
         visible.some((t) => t.id === state.activeTabId)
       if (currentStillVisible) {
-        return { ...state, sessions }
+        return { ...state, lastActiveTabByWorktree, sessions }
       }
-      return { ...state, activeTabId: visible[0]?.id ?? null, sessions }
+      const remembered = lastActiveTabByWorktree[action.worktreeId]
+      const nextActiveTabId =
+        remembered != null && remembered !== '' && visible.some((t) => t.id === remembered)
+          ? remembered
+          : (visible[0]?.id ?? null)
+      return { ...state, activeTabId: nextActiveTabId, lastActiveTabByWorktree, sessions }
     }
     case 'update-worktree-record':
       return {

package/src/state/session-persistence.ts

@@ -15,6 +15,15 @@ export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
   }
 }
 
+/**
+ * The per-worktree last-tab memory is serialized into every snapshot now so the
+ * data accrues across sessions, but restoring it at startup stays dormant until
+ * a future (non-breaking) change is ready to consume it. Flipping this to true
+ * makes restart restore the last-viewed tab per worktree; until then restart
+ * behavior is unchanged and the live in-memory map is never clobbered on switch.
+ */
+const RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE: boolean = false
+
 function getDisconnectedStatus(status: TabStatus): TabStatus {
   if (status === 'running' || status === 'starting') {
     return 'disconnected'
@@ -26,6 +35,10 @@ function getDisconnectedStatus(status: TabStatus): TabStatus {
 export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
   return {
     activeTabId: state.activeTabId,
+    lastActiveTabByWorktree:
+      Object.keys(state.lastActiveTabByWorktree).length > 0
+        ? state.lastActiveTabByWorktree
+        : undefined,
     layoutTree: Object.values(state.layoutTrees)[0] ?? undefined,
     layoutTrees: Object.keys(state.layoutTrees).length > 0 ? state.layoutTrees : undefined,
     savedAt: new Date().toISOString(),
@@ -241,7 +254,8 @@ export function restoreWorkspaceState(
 ): Pick<
   AppState,
   'tabs' | 'activeTabId' | 'focusMode' | 'sidebar' | 'layoutTrees' | 'tabGroupMap'
-> {
+> &
+  Partial<Pick<AppState, 'lastActiveTabByWorktree'>> {
   const tabs = restoreTabsFromWorkspace(workspaceSnapshot, options)
   const activeTabId =
     workspaceSnapshot?.activeTabId != null &&
@@ -253,6 +267,14 @@ export function restoreWorkspaceState(
   const { layoutTrees, tabGroupMap } = restoreLayoutTrees(workspaceSnapshot, tabs)
   const orderedTabs = normalizeGroupedTabOrder(tabs, layoutTrees, tabGroupMap)
 
+  // Dormant until the gate flips: merge the persisted per-worktree memory over
+  // the live in-memory map. While off, the key is omitted entirely so callers
+  // that spread the result never overwrite their existing map on a switch.
+  const persistedLastActiveTab =
+    RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE && workspaceSnapshot?.lastActiveTabByWorktree
+      ? { ...state.lastActiveTabByWorktree, ...workspaceSnapshot.lastActiveTabByWorktree }
+      : undefined
+
   return {
     activeTabId,
     focusMode: 'navigation',
@@ -260,5 +282,6 @@ export function restoreWorkspaceState(
     sidebar: state.sidebar,
     tabGroupMap,
     tabs: orderedTabs,
+    ...(persistedLastActiveTab ? { lastActiveTabByWorktree: persistedLastActiveTab } : {}),
   }
 }

package/src/state/store.ts

@@ -84,6 +84,7 @@ export function createInitialState(
       position: gitPanePosition,
     },
     gitPanel: emptyGitPanel(),
+    lastActiveTabByWorktree: {},
     layout: {
       terminalCols: DEFAULT_TERMINAL_COLS,
       terminalRows: DEFAULT_TERMINAL_ROWS,

package/src/state/types.ts

@@ -117,6 +117,13 @@ export interface WorkspaceSnapshotV1 {
   layoutTree?: LayoutNode
   layoutTrees?: Record<string, LayoutNode>
   tabGroupMap?: Record<string, string>
+  /**
+   * Last viewed tab per worktree, keyed by worktree id. Optional and additive
+   * (no version bump): older builds ignore it, newer builds tolerate its
+   * absence. Written now so the data accrues, but restoring it at startup is
+   * gated off until a future change flips RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE.
+   */
+  lastActiveTabByWorktree?: Record<string, string>
 }
 
 export type WorktreeSource = 'primary' | 'aimux-temp' | 'external'
@@ -489,6 +496,12 @@ export interface AppState {
    * keyed by worktree id. Ephemeral (polled); not persisted to the catalog.
    */
   worktreeDivergence: Record<string, BranchDivergence>
+  /**
+   * Last active tab a user viewed within each worktree, keyed by worktree id.
+   * Lets switching back to a worktree restore its last-viewed tab instead of
+   * snapping to the first one. Ephemeral (in-memory); not persisted to the catalog.
+   */
+  lastActiveTabByWorktree: Record<string, string>
   /** Chord prefix the sequence resolver is currently waiting on, or null when idle. */
   pendingChords: string[] | null
 }

package/src/platform/worktree-deps.ts

@@ -1,22 +0,0 @@
-import { existsSync } from 'node:fs'
-import { realpath, symlink } from 'node:fs/promises'
-import { join } from 'node:path'
-
-/**
- * Symlink the source checkout's `node_modules` into a freshly created worktree
- * so a JS project's dependencies don't need reinstalling. No-op when the source
- * isn't a JS project, has no installed `node_modules`, or the worktree already
- * has one. Returns true when a symlink was created.
- */
-export async function linkNodeModules(sourceDir: string, worktreePath: string): Promise<boolean> {
-  if (!existsSync(join(sourceDir, 'package.json'))) return false
-  const sourceModules = join(sourceDir, 'node_modules')
-  if (!existsSync(sourceModules)) return false
-  const targetModules = join(worktreePath, 'node_modules')
-  if (existsSync(targetModules)) return false
-  // Resolve through any existing symlink so the new link points at the real
-  // dependency store rather than chaining through another worktree.
-  const resolved = await realpath(sourceModules)
-  await symlink(resolved, targetModules, 'dir')
-  return true
-}