aimux-cli 0.1.1 → 0.1.3

package/dist/multiplexer.js

@@ -25,7 +25,7 @@ import { TmuxRuntimeManager } from "./tmux-runtime-manager.js";
 import { isDashboardWindowName } from "./tmux-runtime-manager.js";
 import { TmuxSessionTransport } from "./tmux-session-transport.js";
 import { MetadataServer } from "./metadata-server.js";
-import { loadMetadataState, removeMetadataEndpoint, resolveProjectServiceEndpoint } from "./metadata-store.js";
+import { loadMetadataState, removeMetadataEndpoint, resolveProjectServiceEndpoint, updateSessionMetadata, } from "./metadata-store.js";
 import { PluginRuntime } from "./plugin-runtime.js";
 import { SessionBootstrapService } from "./session-bootstrap.js";
 import { ensureDaemonRunning, ensureProjectService, loadDaemonInfo } from "./daemon.js";
@@ -43,6 +43,7 @@ import { deriveSessionSemantics } from "./session-semantics.js";
 import { injectClaudeHookArgs } from "./claude-hooks.js";
 import { navigationUrgencyScore } from "./fast-control.js";
 import { requestJson } from "./http-client.js";
+import { openDashboardTarget } from "./dashboard-targets.js";
 import { clearNotifications, listNotifications, markNotificationsRead, } from "./notifications.js";
 import { updateNotificationContext } from "./notification-context.js";
 import { buildThreadEntries, buildWorkflowEntries, describeWorkflowNextAction, filterWorkflowEntries, } from "./workflow.js";
@@ -50,7 +51,14 @@ import { renderActivityScreen, renderGraveyardDetails, renderGraveyardScreen, re
 import { renderDashboardBusyOverlay, renderDashboardErrorOverlay, renderHelpOverlay, renderLabelInputOverlay, renderMigratePickerOverlay, renderNotificationPanel, renderServiceInputOverlay, renderSwitcherOverlay, renderWorktreeListOverlay, renderWorktreeRemoveConfirmOverlay, } from "./tui/screens/overlay-renderers.js";
 import { composeTwoPane, stripAnsi, truncateAnsi, truncatePlain, wrapKeyValue, wrapText } from "./tui/render/text.js";
 import { loadStatusline, renderTmuxStatuslineFromData } from "./tmux-statusline.js";
+import { DashboardUiStateStore } from "./dashboard-ui-state-store.js";
+import { DashboardPendingActions } from "./dashboard-pending-actions.js";
+import { DashboardFeedbackController, } from "./dashboard-feedback.js";
+import { MultiplexerRuntimeSync } from "./multiplexer-runtime-sync.js";
+import { openManagedServiceWindow, openManagedSessionWindow, selectLinkedOrOpenTarget } from "./tmux-window-open.js";
+import { graveyardSessionWithFeedback as runGraveyardSessionWithFeedback, resumeOfflineSessionWithFeedback as runResumeOfflineSessionWithFeedback, stopSessionToOfflineWithFeedback as runStopSessionToOfflineWithFeedback, waitForSessionExit, waitForSessionStart, } from "./dashboard-session-actions.js";
 export class Multiplexer {
+    projectRoot;
     sessions = [];
     activeIndex = 0;
     mode = "dashboard";
@@ -83,9 +91,10 @@ export class Multiplexer {
     worktreeListActive = false;
     worktreeRemoveConfirm = null;
     worktreeRemovalJob = null;
-    dashboardBusyState = null;
-    dashboardBusySpinner = null;
-    dashboardErrorState = null;
+    dashboardFeedback = new DashboardFeedbackController({
+        renderDashboard: () => this.renderDashboard(),
+        isDashboardMode: () => this.mode === "dashboard",
+    });
     migratePickerActive = false;
     migratePickerWorktrees = [];
     graveyardEntries = [];
@@ -102,7 +111,11 @@ export class Multiplexer {
     planEntries = [];
     planIndex = 0;
     notificationPanelState = null;
-    pendingDashboardSessionActions = new Map();
+    dashboardPendingActions = new DashboardPendingActions(() => {
+        if (this.mode === "dashboard") {
+            this.renderCurrentDashboardView();
+        }
+    });
     stoppingSessionIds = new Set();
     graveyardAfterStopSessionIds = new Set();
     /** Quick switcher overlay state */
@@ -115,8 +128,8 @@ export class Multiplexer {
     confirmedRegistered = new Set();
     /** The focused worktree path on the dashboard (undefined = main repo) */
     dashboardState = new DashboardState();
+    dashboardUiStateStore = new DashboardUiStateStore();
     statusInterval = null;
-    heartbeatInterval = null;
     agentTracker = new AgentTracker();
     instanceId = randomUUID();
     contextWatcher = new ContextWatcher((target) => this.tmuxRuntimeManager.captureTarget(target, { startLine: -120 }));
@@ -148,7 +161,6 @@ export class Multiplexer {
     metadataServer = null;
     eventBus = new ProjectEventBus();
     pluginRuntime = null;
-    projectServiceInterval = null;
     lastRenderedFrame = null;
     lastStatuslineSnapshotKey = null;
     desktopStateSnapshot = null;
@@ -159,10 +171,37 @@ export class Multiplexer {
     dashboardModelRefreshedAt = 0;
     dashboardServiceSnapshotRefreshing = false;
     dashboardServiceRecovery = null;
+    dashboardNextBackgroundRefreshAt = 0;
+    runtimeSync;
     constructor() {
+        this.projectRoot = (() => {
+            try {
+                return findMainRepo(process.cwd());
+            }
+            catch {
+                return process.cwd();
+            }
+        })();
         this.terminalHost = new TerminalHost();
         this.hotkeys = new HotkeyHandler((action) => this.handleAction(action));
         this.dashboard = new Dashboard();
+        this.runtimeSync = new MultiplexerRuntimeSync({
+            instanceDirectory: this.instanceDirectory,
+            instanceId: this.instanceId,
+            cwd: process.cwd(),
+            getMode: () => this.mode,
+            getConfirmedRegistered: () => this.confirmedRegistered,
+            setConfirmedRegistered: (value) => {
+                this.confirmedRegistered = value;
+            },
+            getInstanceSessionRefs: () => this.getInstanceSessionRefs(),
+            syncSessionsFromState: () => this.syncSessionsFromState(),
+            loadOfflineSessions: () => this.loadOfflineSessions(),
+            renderCurrentDashboardView: () => this.renderCurrentDashboardView(),
+            renderDashboard: () => this.renderDashboard(),
+            handleSessionClaimed: (sessionId) => this.handleSessionClaimed(sessionId),
+            writeStatuslineFile: () => this.writeStatuslineFile(),
+        });
         this.eventBus.subscribe((event) => {
             if (event.type !== "alert")
                 return;
@@ -219,10 +258,7 @@ export class Multiplexer {
         return true;
     }
     openTmuxDashboardTarget() {
-        const session = this.tmuxRuntimeManager.ensureProjectSession(process.cwd());
-        const openSession = this.tmuxRuntimeManager.getOpenSessionName(session.sessionName);
-        const target = this.tmuxRuntimeManager.ensureDashboardWindow(openSession, process.cwd());
-        this.tmuxRuntimeManager.openTarget(target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
+        openDashboardTarget(this.projectRoot, this.tmuxRuntimeManager);
     }
     invalidateDashboardFrame() {
         this.lastRenderedFrame = null;
@@ -232,14 +268,20 @@ export class Multiplexer {
     }
     handleDashboardFocusIn() {
         this.terminalHost.enterAlternateScreen();
-        this.invalidateDashboardFrame();
-        this.renderCurrentDashboardView();
-        void this.refreshDashboardModelFromService(true).then((updated) => {
-            if (!updated || this.mode !== "dashboard")
-                return;
-            this.terminalHost.enterAlternateScreen();
-            this.invalidateDashboardFrame();
-            this.renderCurrentDashboardView();
+        if (this.lastRenderedFrame) {
+            process.stdout.write(this.lastRenderedFrame);
+        }
+        this.tmuxRuntimeManager.refreshStatus();
+    }
+    loadDashboardUiState() {
+        this.dashboardUiStateStore.loadInto(this.dashboardState);
+    }
+    persistDashboardUiState() {
+        this.dashboardUiStateStore.persist(this.mode, this.dashboardState, this.activeIndex, this.getDashboardSessions());
+    }
+    restoreDashboardSelectionFromPreference(dashSessions, hasWorktrees) {
+        this.dashboardUiStateStore.consumeSelectionRestore(this.dashboardState, dashSessions, hasWorktrees, () => this.updateWorktreeSessions(), this.activeIndex, (value) => {
+            this.activeIndex = value;
         });
     }
     writeFrame(output, force = false) {
@@ -314,25 +356,12 @@ export class Multiplexer {
         });
     }
     applyDashboardModel(dashSessions, dashServices, worktreeGroups, mainCheckoutInfo) {
-        this.dashboardSessionsCache = this.applyPendingDashboardSessionStates(dashSessions);
-        this.dashboardServicesCache = dashServices;
+        this.dashboardSessionsCache = this.dashboardPendingActions.applyToSessions(dashSessions);
+        this.dashboardServicesCache = this.dashboardPendingActions.applyToServices(dashServices);
         this.dashboardWorktreeGroupsCache = worktreeGroups;
         this.dashboardMainCheckoutInfoCache = mainCheckoutInfo;
         this.dashboardModelRefreshedAt = Date.now();
-    }
-    applyPendingDashboardSessionStates(sessions) {
-        if (this.pendingDashboardSessionActions.size === 0)
-            return sessions;
-        return sessions.map((session) => {
-            const pendingAction = this.pendingDashboardSessionActions.get(session.id);
-            if (!pendingAction)
-                return session;
-            return {
-                ...session,
-                pendingAction,
-                optimistic: true,
-            };
-        });
+        this.dashboardUiStateStore.markSelectionDirty();
     }
     invalidateDesktopStateSnapshot() {
         this.desktopStateSnapshot = null;
@@ -805,11 +834,43 @@ export class Multiplexer {
                 delete offline.label;
         }
     }
+    applyDashboardSessionLabel(sessionId, label) {
+        const trimmed = label?.trim();
+        this.dashboardSessionsCache = this.dashboardSessionsCache.map((session) => session.id === sessionId ? { ...session, label: trimmed || undefined } : session);
+        this.dashboardWorktreeGroupsCache = this.dashboardWorktreeGroupsCache.map((group) => ({
+            ...group,
+            sessions: group.sessions.map((session) => session.id === sessionId ? { ...session, label: trimmed || undefined } : session),
+        }));
+        this.dashboardState.worktreeSessions = this.dashboardState.worktreeSessions.map((session) => session.id === sessionId ? { ...session, label: trimmed || undefined } : session);
+    }
     async updateSessionLabel(sessionId, label) {
+        if (this.mode === "dashboard") {
+            this.applySessionLabel(sessionId, label);
+            this.applyDashboardSessionLabel(sessionId, label);
+            this.setPendingDashboardSessionAction(sessionId, "renaming");
+            this.writeStatuslineFile();
+            this.renderCurrentDashboardView();
+            void this.postToProjectService("/agents/rename", { sessionId, label })
+                .then(() => {
+                this.invalidateDesktopStateSnapshot();
+                this.setPendingDashboardSessionAction(sessionId, null);
+                this.writeStatuslineFile();
+                this.renderCurrentDashboardView();
+            })
+                .catch((err) => {
+                this.setPendingDashboardSessionAction(sessionId, null);
+                this.footerFlash = `Rename failed: ${err instanceof Error ? err.message : String(err)}`;
+                this.footerFlashTicks = 4;
+                this.writeStatuslineFile();
+                this.renderCurrentDashboardView();
+            });
+            return;
+        }
         this.applySessionLabel(sessionId, label);
+        this.invalidateDesktopStateSnapshot();
         const localSession = this.sessions.find((session) => session.id === sessionId)?.transport;
         if (localSession instanceof TmuxSessionTransport) {
-            localSession.renameWindow(label?.trim() || localSession.command);
+            localSession.renameWindow(localSession.command);
             const target = localSession.tmuxTarget;
             this.sessionTmuxTargets.set(sessionId, target);
             this.syncTmuxWindowMetadata(sessionId);
@@ -1221,6 +1282,7 @@ export class Multiplexer {
         process.stdout.on("resize", this.onResize);
         // Enter dashboard mode directly
         this.mode = "dashboard";
+        this.loadDashboardUiState();
         const primed = await this.refreshDashboardModelFromService(true);
         if (!primed) {
             throw new Error("dashboard requires a live project service desktop-state endpoint");
@@ -1408,17 +1470,12 @@ export class Multiplexer {
         if (session instanceof TmuxSessionTransport) {
             this.syncTmuxWindowMetadata(sessionId);
         }
-        // Focus the new session
         this.activeIndex = this.sessions.length - 1;
         if (this.startedInDashboard && this.mode === "dashboard") {
             this.invalidateDesktopStateSnapshot();
             this.refreshLocalDashboardModel();
             this.updateWorktreeSessions();
-            this.dashboardState.level = "sessions";
-            const selectedIndex = this.dashboardState.worktreeEntries.findIndex((entry) => entry.kind === "session" && entry.id === sessionId);
-            if (selectedIndex >= 0) {
-                this.dashboardState.sessionIndex = selectedIndex;
-            }
+            this.preferDashboardEntrySelection("session", sessionId, worktreePath);
             this.renderDashboard();
         }
         this.saveState();
@@ -1507,18 +1564,7 @@ export class Multiplexer {
         const target = this.sessionTmuxTargets.get(sid);
         if (target) {
             this.saveState();
-            const insideTmux = this.tmuxRuntimeManager.isInsideTmux();
-            if (insideTmux) {
-                const currentClientSession = this.tmuxRuntimeManager.currentClientSession();
-                if (currentClientSession) {
-                    const linkedTarget = this.tmuxRuntimeManager.getTargetByWindowId(currentClientSession, target.windowId);
-                    if (linkedTarget) {
-                        this.tmuxRuntimeManager.selectWindow(linkedTarget);
-                        return;
-                    }
-                }
-            }
-            this.tmuxRuntimeManager.openTarget(target, { insideTmux });
+            selectLinkedOrOpenTarget(this.tmuxRuntimeManager, target);
         }
     }
     handleAction(action) {
@@ -1717,13 +1763,18 @@ export class Multiplexer {
                         : undefined;
                 if (!selEntry)
                     return;
-                if (selEntry.status === "offline" || selEntry.pendingAction === "stopping") {
+                const runtime = this.sessions.find((s) => s.id === selEntry.id);
+                const effectivelyOffline = selEntry.status === "offline" ||
+                    selEntry.pendingAction === "stopping" ||
+                    !runtime ||
+                    !this.isSessionRuntimeLive(runtime);
+                if (effectivelyOffline) {
                     // Second [x] on offline → move to graveyard
                     void this.graveyardSessionWithFeedback(selEntry.id, hasWorktrees);
                     return;
                 }
                 // First [x] on running → stop PTY, keep as offline for resume
-                const pty = this.sessions.find((s) => s.id === selEntry.id);
+                const pty = runtime;
                 if (pty) {
                     void this.stopSessionToOfflineWithFeedback(pty);
                 }
@@ -1787,7 +1838,7 @@ export class Multiplexer {
                     }
                     if (entry?.status === "offline") {
                         const offline = this.offlineSessions.find((s) => s.id === entry.id);
-                        if (offline) {
+                        if (offline && entry.pendingAction !== "starting") {
                             void this.resumeOfflineSessionWithFeedback(offline);
                         }
                         return;
@@ -1887,7 +1938,7 @@ export class Multiplexer {
                     }
                     if (dashEntry.status === "offline") {
                         const offline = this.offlineSessions.find((s) => s.id === dashEntry.id);
-                        if (offline) {
+                        if (offline && dashEntry.pendingAction !== "starting") {
                             void this.resumeOfflineSessionWithFeedback(offline);
                         }
                         return;
@@ -1917,6 +1968,9 @@ export class Multiplexer {
     async activateDashboardEntry(entry) {
         if (!entry)
             return;
+        if (entry.pendingAction === "creating") {
+            return;
+        }
         if (this.openLiveTmuxWindowForEntry(entry)) {
             return;
         }
@@ -1926,7 +1980,7 @@ export class Multiplexer {
         }
         if (entry.status === "offline") {
             const offline = this.offlineSessions.find((session) => session.id === entry.id);
-            if (offline) {
+            if (offline && entry.pendingAction !== "starting") {
                 await this.resumeOfflineSessionWithFeedback(offline);
             }
             return;
@@ -2671,6 +2725,7 @@ export class Multiplexer {
         this.dashboardState.setScreen(screen);
         this.syncTuiNotificationContext(false);
         this.writeDashboardClientStatuslineFile();
+        this.persistDashboardUiState();
         this.tmuxRuntimeManager.refreshStatus();
     }
     handleActiveDashboardOverlayKey(data) {
@@ -2855,27 +2910,18 @@ export class Multiplexer {
         return false;
     }
     openLiveTmuxWindowForEntry(entry) {
-        const tmuxSession = this.tmuxRuntimeManager.getProjectSession(process.cwd());
-        const match = this.tmuxRuntimeManager.findManagedWindow(tmuxSession.sessionName, {
-            sessionId: entry.id,
-            backendSessionId: entry.backendSessionId,
-        });
-        if (!match)
+        const target = openManagedSessionWindow(this.tmuxRuntimeManager, process.cwd(), entry);
+        if (!target)
             return false;
         this.agentTracker.markSeen(entry.id);
         this.noteLastUsedItem(entry.id);
-        this.tmuxRuntimeManager.openTarget(match.target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
         return true;
     }
     openLiveTmuxWindowForService(serviceId) {
-        const tmuxSession = this.tmuxRuntimeManager.getProjectSession(process.cwd());
-        const match = this.tmuxRuntimeManager.findManagedWindow(tmuxSession.sessionName, {
-            sessionId: serviceId,
-        });
-        if (!match || match.metadata.kind !== "service")
+        const target = openManagedServiceWindow(this.tmuxRuntimeManager, process.cwd(), serviceId);
+        if (!target)
             return false;
         this.noteLastUsedItem(serviceId);
-        this.tmuxRuntimeManager.openTarget(match.target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
         return true;
     }
     noteLastUsedItem(itemId) {
@@ -3367,7 +3413,21 @@ export class Multiplexer {
         }
         this.pickerMode = "create";
         this.forkSourceSessionId = null;
-        this.createSession(tool.command, tool.args, tool.preambleFlag, toolKey, undefined, tool.sessionIdFlag, wtPath);
+        const sessionId = this.generateDashboardSessionId(tool.command);
+        const shouldRenderPending = this.startedInDashboard && this.mode === "dashboard";
+        if (shouldRenderPending) {
+            this.setPendingDashboardSessionAction(sessionId, "creating");
+        }
+        try {
+            this.createSession(tool.command, tool.args, tool.preambleFlag, toolKey, undefined, tool.sessionIdFlag, wtPath, undefined, sessionId, shouldRenderPending);
+            this.settleDashboardCreatePending(sessionId);
+        }
+        catch (error) {
+            if (shouldRenderPending) {
+                this.setPendingDashboardSessionAction(sessionId, null);
+            }
+            throw error;
+        }
     }
     showToolPicker(sourceSessionId) {
         const config = loadConfig();
@@ -3530,7 +3590,9 @@ export class Multiplexer {
             throw new Error(`Unable to fork session ${opts.sourceSessionId}`);
         }
         if (opts.open !== false && result.target) {
-            this.tmuxRuntimeManager.openTarget(result.target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
+            if (!this.openLiveTmuxWindowForEntry({ id: result.sessionId })) {
+                this.tmuxRuntimeManager.openTarget(result.target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
+            }
         }
         return {
             sessionId: result.sessionId,
@@ -3554,7 +3616,9 @@ export class Multiplexer {
         const transport = this.createSession(toolCfg.command, toolCfg.args, toolCfg.preambleFlag, opts.toolConfigKey, undefined, toolCfg.sessionIdFlag, targetWorktreePath);
         const target = this.sessionTmuxTargets.get(transport.id);
         if (opts.open !== false && target) {
-            this.tmuxRuntimeManager.openTarget(target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
+            if (!this.openLiveTmuxWindowForEntry({ id: transport.id })) {
+                this.tmuxRuntimeManager.openTarget(target, { insideTmux: this.tmuxRuntimeManager.isInsideTmux() });
+            }
         }
         return { sessionId: transport.id };
     }
@@ -3581,7 +3645,7 @@ export class Multiplexer {
         if (!this.stoppingSessionIds.has(sessionId)) {
             this.stopSessionToOffline(runningSession);
         }
-        await this.waitForSessionExit(runningSession);
+        await waitForSessionExit(runningSession);
         this.saveState();
         return { sessionId, status: "offline" };
     }
@@ -3595,7 +3659,7 @@ export class Multiplexer {
             if (!this.stoppingSessionIds.has(sessionId)) {
                 this.stopSessionToOffline(runningSession);
             }
-            await this.waitForSessionExit(runningSession);
+            await waitForSessionExit(runningSession);
             this.saveState();
         }
         else {
@@ -3620,7 +3684,7 @@ export class Multiplexer {
             throw new Error(`Session "${sessionId}" not found`);
         }
         await this.migrateAgent(sessionId, targetWorktreePath);
-        await this.waitForSessionExit(runningSession);
+        await waitForSessionExit(runningSession);
         return { sessionId, worktreePath: this.getSessionWorktreePath(sessionId) };
     }
     serviceLabelForCommand(commandLine) {
@@ -3630,6 +3694,22 @@ export class Multiplexer {
         const first = trimmed.split(/\s+/)[0] ?? "service";
         return basename(first);
     }
+    generateDashboardSessionId(command) {
+        return `${command}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    settleDashboardCreatePending(itemId) {
+        if (!(this.startedInDashboard && this.mode === "dashboard"))
+            return;
+        this.dashboardPendingActions.settleCreatePending(itemId, () => {
+            this.refreshLocalDashboardModel();
+            this.renderDashboard();
+        });
+    }
+    preferDashboardEntrySelection(kind, id, worktreePath) {
+        if (!(this.startedInDashboard && this.mode === "dashboard"))
+            return;
+        this.dashboardUiStateStore.preferEntrySelection(this.dashboardState, kind, id, worktreePath);
+    }
     createService(commandLine, worktreePath) {
         const serviceId = `service-${randomUUID().slice(0, 8)}`;
         const cwd = worktreePath ?? process.cwd();
@@ -3639,28 +3719,37 @@ export class Multiplexer {
         const args = trimmed ? ["-lc", trimmed] : ["-l"];
         const label = this.serviceLabelForCommand(trimmed);
         const tmuxSession = this.tmuxRuntimeManager.ensureProjectSession(process.cwd());
-        const target = this.tmuxRuntimeManager.createWindow(tmuxSession.sessionName, label, cwd, command, args, {
-            detached: true,
-        });
-        this.tmuxRuntimeManager.setWindowMetadata(target, {
-            kind: "service",
-            sessionId: serviceId,
-            command,
-            args,
-            toolConfigKey: "service",
-            worktreePath,
-            label,
-        });
-        this.tmuxRuntimeManager.applyManagedAgentWindowPolicy(target, "service");
-        this.invalidateDesktopStateSnapshot();
-        this.refreshLocalDashboardModel();
-        this.updateWorktreeSessions();
-        this.dashboardState.level = "sessions";
-        const selectedIndex = this.dashboardState.worktreeEntries.findIndex((entry) => entry.kind === "service" && entry.id === serviceId);
-        if (selectedIndex >= 0) {
-            this.dashboardState.sessionIndex = selectedIndex;
+        const shouldRenderPending = this.startedInDashboard && this.mode === "dashboard";
+        if (shouldRenderPending) {
+            this.setPendingDashboardSessionAction(serviceId, "creating");
+        }
+        try {
+            const target = this.tmuxRuntimeManager.createWindow(tmuxSession.sessionName, label, cwd, command, args, {
+                detached: true,
+            });
+            this.tmuxRuntimeManager.setWindowMetadata(target, {
+                kind: "service",
+                sessionId: serviceId,
+                command,
+                args,
+                toolConfigKey: "service",
+                worktreePath,
+                label,
+            });
+            this.tmuxRuntimeManager.applyManagedAgentWindowPolicy(target, "service");
+            this.invalidateDesktopStateSnapshot();
+            this.refreshLocalDashboardModel();
+            this.updateWorktreeSessions();
+            this.preferDashboardEntrySelection("service", serviceId, worktreePath);
+            this.settleDashboardCreatePending(serviceId);
+            return { serviceId };
+        }
+        catch (error) {
+            if (shouldRenderPending) {
+                this.setPendingDashboardSessionAction(serviceId, null);
+            }
+            throw error;
         }
-        return { serviceId };
     }
     stopService(serviceId) {
         const tmuxSession = this.tmuxRuntimeManager.getProjectSession(process.cwd());
@@ -3689,7 +3778,9 @@ export class Multiplexer {
         // Ensure focusedWorktreePath is valid
         if (!this.dashboardState.worktreeNavOrder.includes(this.dashboardState.focusedWorktreePath)) {
             this.dashboardState.focusedWorktreePath = undefined;
+            this.dashboardUiStateStore.markSelectionDirty();
         }
+        this.restoreDashboardSelectionFromPreference(dashSessions, hasWorktrees);
         // Determine selected session for cursor
         let selectedSession;
         let selectedService;
@@ -3708,6 +3799,7 @@ export class Multiplexer {
         this.dashboard.update(dashSessions, dashServices, worktreeGroups, this.dashboardState.focusedWorktreePath, hasWorktrees ? this.dashboardState.level : "sessions", selectedSession, selectedService, "tmux", mainCheckoutInfo);
         this.syncTuiNotificationContext(Boolean(this.notificationPanelState));
         this.writeFrame(this.dashboard.render(cols, rows));
+        this.persistDashboardUiState();
         if (this.dashboardBusyState) {
             this.renderDashboardBusyOverlay();
         }
@@ -3992,49 +4084,19 @@ export class Multiplexer {
         }
     }
     startDashboardBusy(title, lines) {
-        this.dashboardErrorState = null;
-        this.dashboardBusyState = {
-            title,
-            lines,
-            startedAt: Date.now(),
-            spinnerFrame: 0,
-        };
-        if (this.dashboardBusySpinner) {
-            clearInterval(this.dashboardBusySpinner);
-        }
-        this.dashboardBusySpinner = setInterval(() => {
-            if (!this.dashboardBusyState)
-                return;
-            this.dashboardBusyState.spinnerFrame = (this.dashboardBusyState.spinnerFrame + 1) % 10;
-            if (this.mode === "dashboard")
-                this.renderDashboard();
-        }, 120);
-        this.footerFlash = null;
-        this.footerFlashTicks = 0;
-        this.renderDashboard();
+        this.dashboardFeedback.startBusy(title, lines);
     }
     updateDashboardBusy(lines) {
-        if (!this.dashboardBusyState)
-            return;
-        this.dashboardBusyState.lines = lines;
-        if (this.mode === "dashboard")
-            this.renderDashboard();
+        this.dashboardFeedback.updateBusy(lines);
     }
     clearDashboardBusy() {
-        if (this.dashboardBusySpinner) {
-            clearInterval(this.dashboardBusySpinner);
-            this.dashboardBusySpinner = null;
-        }
-        this.dashboardBusyState = null;
+        this.dashboardFeedback.clearBusy();
     }
     showDashboardError(title, lines) {
-        this.clearDashboardBusy();
-        this.dashboardErrorState = { title, lines };
-        this.renderDashboard();
+        this.dashboardFeedback.showError(title, lines);
     }
     dismissDashboardError() {
-        this.dashboardErrorState = null;
-        this.renderDashboard();
+        this.dashboardFeedback.dismissError();
     }
     beginWorktreeRemoval(path, name, oldIdx) {
         if (this.worktreeRemovalJob)
@@ -4609,67 +4671,14 @@ export class Multiplexer {
     renderMigratePicker() {
         renderMigratePickerOverlay(this);
     }
-    waitForSessionExit(session, timeoutMs = 15_000) {
-        if (session.exited)
-            return Promise.resolve();
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error(`Timed out waiting for ${session.id} to exit`)), timeoutMs);
-            session.onExit(() => {
-                clearTimeout(timer);
-                resolve();
-            });
-        });
-    }
     async runDashboardOperation(title, lines, work, errorTitle = title) {
-        this.startDashboardBusy(title, lines);
-        const minVisibleMs = 250;
-        const startedAt = Date.now();
-        try {
-            const result = await work();
-            const remaining = minVisibleMs - (Date.now() - startedAt);
-            if (remaining > 0) {
-                await new Promise((resolve) => setTimeout(resolve, remaining));
-            }
-            this.clearDashboardBusy();
-            return result;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            this.showDashboardError(errorTitle, [message]);
-            return undefined;
-        }
+        return this.dashboardFeedback.runOperation(title, lines, work, errorTitle);
     }
     setPendingDashboardSessionAction(sessionId, kind) {
-        if (kind) {
-            this.pendingDashboardSessionActions.set(sessionId, kind);
-        }
-        else {
-            this.pendingDashboardSessionActions.delete(sessionId);
-        }
-        if (this.mode === "dashboard") {
-            this.refreshLocalDashboardModel();
-            this.renderDashboard();
-        }
+        this.dashboardPendingActions.set(sessionId, kind);
     }
     async stopSessionToOfflineWithFeedback(session) {
-        const label = this.getSessionLabel(session.id) ?? session.command;
-        this.setPendingDashboardSessionAction(session.id, "stopping");
-        try {
-            this.stopSessionToOffline(session);
-            await this.waitForSessionExit(session);
-            if (!this.graveyardAfterStopSessionIds.has(session.id)) {
-                this.setPendingDashboardSessionAction(session.id, null);
-            }
-            this.refreshLocalDashboardModel();
-            this.footerFlash = `Stopped ${label}`;
-            this.footerFlashTicks = 3;
-            this.renderDashboard();
-        }
-        catch (err) {
-            this.setPendingDashboardSessionAction(session.id, null);
-            const message = err instanceof Error ? err.message : String(err);
-            this.showDashboardError(`Failed to stop "${label}"`, [message]);
-        }
+        await runStopSessionToOfflineWithFeedback(this.dashboardSessionActionDeps(), session);
     }
     clearDashboardSubscreens() {
         this.dashboardState.resetSubscreen();
@@ -4778,30 +4787,34 @@ export class Multiplexer {
     }
     async graveyardSessionWithFeedback(sessionId, hasWorktrees) {
         const session = this.offlineSessions.find((s) => s.id === sessionId) ?? this.sessions.find((s) => s.id === sessionId);
-        if (!session)
-            return;
-        const label = ("label" in session ? session.label : this.getSessionLabel(sessionId)) ?? session.command;
-        this.setPendingDashboardSessionAction(sessionId, "graveyarding");
-        try {
-            await this.sendAgentToGraveyard(sessionId);
-            this.setPendingDashboardSessionAction(sessionId, null);
-            this.adjustAfterRemove(hasWorktrees);
-            this.footerFlash = `Sent ${label} to graveyard`;
-            this.footerFlashTicks = 3;
-            this.renderDashboard();
-        }
-        catch (err) {
-            this.setPendingDashboardSessionAction(sessionId, null);
-            const message = err instanceof Error ? err.message : String(err);
-            this.showDashboardError(`Failed to graveyard "${label}"`, [message]);
-        }
+        await runGraveyardSessionWithFeedback(this.dashboardSessionActionDeps(), session, sessionId, hasWorktrees);
     }
     async resumeOfflineSessionWithFeedback(session) {
-        const label = session.label ?? session.command;
-        await this.runDashboardOperation(`Restoring "${label}"`, [`  Session: ${session.id}`], () => {
-            this.resumeOfflineSession(session);
-            this.focusSession(this.sessions.length - 1);
-        }, `Failed to restore "${label}"`);
+        await runResumeOfflineSessionWithFeedback(this.dashboardSessionActionDeps(), session);
+    }
+    async waitForSessionStart(sessionId, timeoutMs = 8000) {
+        return waitForSessionStart(sessionId, this.dashboardSessionActionDeps(), timeoutMs);
+    }
+    dashboardSessionActionDeps() {
+        return {
+            getSessionLabel: (sessionId) => this.getSessionLabel(sessionId),
+            getPendingAction: (sessionId) => this.dashboardPendingActions.get(sessionId),
+            setPendingAction: (sessionId, kind) => this.setPendingDashboardSessionAction(sessionId, kind),
+            stopSessionToOffline: (session) => this.stopSessionToOffline(session),
+            isGraveyardAfterStop: (sessionId) => this.graveyardAfterStopSessionIds.has(sessionId),
+            sendAgentToGraveyard: (sessionId) => this.sendAgentToGraveyard(sessionId).then(() => undefined),
+            resumeOfflineSession: (session) => this.resumeOfflineSession(session),
+            refreshLocalDashboardModel: () => this.refreshLocalDashboardModel(),
+            adjustAfterRemove: (hasWorktrees) => this.adjustAfterRemove(hasWorktrees),
+            renderDashboard: () => this.renderDashboard(),
+            showDashboardError: (title, lines) => this.showDashboardError(title, lines),
+            setFooterFlash: (message, ticks) => {
+                this.footerFlash = message;
+                this.footerFlashTicks = ticks;
+            },
+            getRuntimeById: (sessionId) => this.sessions.find((session) => session.id === sessionId),
+            isSessionRuntimeLive: (session) => this.isSessionRuntimeLive(session),
+        };
     }
     async takeoverFromDashEntryWithFeedback(entry) {
         const label = entry.label ?? entry.command;
@@ -4811,7 +4824,7 @@ export class Multiplexer {
         const label = this.getSessionLabel(session.id) ?? session.command;
         await this.runDashboardOperation(`Migrating "${label}"`, [`  From: ${this.sessionWorktreePaths.get(session.id) ?? "(main)"}`, `  To: ${targetName}`], async () => {
             await this.migrateAgent(session.id, targetPath);
-            await this.waitForSessionExit(session);
+            await waitForSessionExit(session);
             this.renderDashboard();
         }, `Failed to migrate "${label}"`);
     }
@@ -5097,7 +5110,7 @@ export class Multiplexer {
                     label: session.label,
                     tmuxWindowId: session.tmuxWindowId,
                     tmuxWindowIndex: session.tmuxWindowIndex,
-                    windowName: session.label || session.command,
+                    windowName: session.command,
                     headline: session.headline,
                     status: session.status,
                     role: session.role,
@@ -5112,7 +5125,7 @@ export class Multiplexer {
                     label: service.label,
                     tmuxWindowId: service.tmuxWindowId,
                     tmuxWindowIndex: service.tmuxWindowIndex,
-                    windowName: service.label || service.command,
+                    windowName: service.command,
                     headline: service.previewLine,
                     status: service.status,
                     active: service.active,
@@ -5273,12 +5286,35 @@ export class Multiplexer {
     /** Track previous statuses for notification on transition */
     prevStatuses = new Map();
     /** Flash message shown temporarily in footer, cleared after a few renders */
-    footerFlash = null;
-    footerFlashTicks = 0;
+    get dashboardBusyState() {
+        return this.dashboardFeedback.busyState;
+    }
+    set dashboardBusyState(value) {
+        this.dashboardFeedback.busyState = value;
+    }
+    get dashboardErrorState() {
+        return this.dashboardFeedback.errorState;
+    }
+    set dashboardErrorState(value) {
+        this.dashboardFeedback.errorState = value;
+    }
+    get footerFlash() {
+        return this.dashboardFeedback.flash;
+    }
+    set footerFlash(value) {
+        this.dashboardFeedback.flash = value;
+    }
+    get footerFlashTicks() {
+        return this.dashboardFeedback.flashTicks;
+    }
+    set footerFlashTicks(value) {
+        this.dashboardFeedback.flashTicks = value;
+    }
     startStatusRefresh() {
         if (this.statusInterval)
             return;
         this.statusInterval = setInterval(() => {
+            let dashboardNeedsRender = false;
             if (this.mode === "project-service") {
                 this.taskDispatcher?.tick(this.sessions.map((s) => s.id));
                 this.orchestrationDispatcher?.tick(this.sessions.map((s) => s.id));
@@ -5305,18 +5341,19 @@ export class Multiplexer {
                     this.footerFlash = `↻ Changes requested: ${ev.description}`;
                 }
                 this.footerFlashTicks = 3;
+                dashboardNeedsRender = true;
             }
             const orchestrationEvents = this.orchestrationDispatcher?.drainEvents() ?? [];
             for (const event of orchestrationEvents) {
                 if (event.type === "message_delivered") {
                     this.footerFlash = `✉ Message delivered → ${event.sessionId}`;
                     this.footerFlashTicks = 3;
+                    dashboardNeedsRender = true;
                 }
             }
-            if (this.footerFlashTicks > 0)
-                this.footerFlashTicks--;
-            if (this.footerFlashTicks === 0)
-                this.footerFlash = null;
+            if (this.dashboardFeedback.tickFlashVisibilityChanged()) {
+                dashboardNeedsRender = true;
+            }
             for (const session of this.sessions) {
                 const prev = this.prevStatuses.get(session.id);
                 const curr = session.status;
@@ -5333,8 +5370,18 @@ export class Multiplexer {
                 this.prevStatuses.set(session.id, curr);
             }
             if (this.mode === "dashboard") {
-                void this.refreshDashboardModelFromService();
-                this.renderCurrentDashboardView();
+                const now = Date.now();
+                if (now >= this.dashboardNextBackgroundRefreshAt) {
+                    this.dashboardNextBackgroundRefreshAt = now + 5000;
+                    void this.refreshDashboardModelFromService().then((refreshed) => {
+                        if (refreshed || dashboardNeedsRender) {
+                            this.renderCurrentDashboardView();
+                        }
+                    });
+                }
+                else if (dashboardNeedsRender) {
+                    this.renderCurrentDashboardView();
+                }
             }
         }, 1000);
     }
@@ -5351,8 +5398,11 @@ export class Multiplexer {
         this.invalidateDesktopStateSnapshot();
     }
     loadOfflineSessions(state = Multiplexer.loadState()) {
-        if (!state || state.sessions.length === 0)
-            return;
+        if (!state || state.sessions.length === 0) {
+            const changed = this.offlineSessions.length > 0;
+            this.offlineSessions = [];
+            return changed;
+        }
         // Get all session IDs owned by live instances (including ourselves)
         const ownedIds = new Set();
         for (const s of this.sessions)
@@ -5363,7 +5413,7 @@ export class Multiplexer {
         }
         // Also exclude by backendSessionId to catch resumed sessions with new IDs
         const ownedBackendIds = new Set(this.sessions.map((session) => session.backendSessionId).filter((value) => Boolean(value)));
-        this.offlineSessions = state.sessions.filter((s) => {
+        const nextOfflineSessions = state.sessions.filter((s) => {
             if (ownedIds.has(s.id))
                 return false;
             if (s.backendSessionId && ownedBackendIds.has(s.backendSessionId))
@@ -5372,9 +5422,17 @@ export class Multiplexer {
                 return false;
             return true;
         });
+        const previousKey = this.offlineSessions
+            .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}`)
+            .join("|");
+        const nextKey = nextOfflineSessions
+            .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}`)
+            .join("|");
+        this.offlineSessions = nextOfflineSessions;
         if (this.offlineSessions.length > 0) {
             debug(`loaded ${this.offlineSessions.length} offline session(s) from state.json`, "session");
         }
+        return previousKey !== nextKey;
     }
     restoreTmuxSessionsFromState(state = Multiplexer.loadState()) {
         const savedById = new Map((state?.sessions ?? []).map((session) => [session.id, session]));
@@ -5396,7 +5454,9 @@ export class Multiplexer {
             const label = metadata.label ?? saved?.label;
             if (label) {
                 this.sessionLabels.set(metadata.sessionId, label);
-                transport.renameWindow(label);
+            }
+            if (target.windowName !== metadata.command) {
+                transport.renameWindow(metadata.command);
             }
             this.syncTmuxWindowMetadata(metadata.sessionId);
         }
@@ -5478,55 +5538,85 @@ export class Multiplexer {
         }
         debug(`graveyarded session ${sessionId}`, "session");
     }
+    isSessionRuntimeLive(runtime) {
+        if (runtime.exited)
+            return false;
+        const mappedTarget = this.sessionTmuxTargets.get(runtime.id);
+        const runtimeTarget = runtime.transport instanceof TmuxSessionTransport ? runtime.transport.tmuxTarget : undefined;
+        const target = mappedTarget ?? runtimeTarget;
+        if (!target)
+            return false;
+        try {
+            return Boolean(this.tmuxRuntimeManager.getTargetByWindowId(target.sessionName, target.windowId));
+        }
+        catch {
+            return false;
+        }
+    }
+    evictZombieSession(runtime) {
+        const idx = this.sessions.indexOf(runtime);
+        if (idx >= 0) {
+            this.sessions.splice(idx, 1);
+        }
+        this.stoppingSessionIds.delete(runtime.id);
+        this.sessionTmuxTargets.delete(runtime.id);
+        this.writeSessionsFile();
+        this.updateContextWatcherSessions();
+        this.saveState();
+    }
     /** Resume a specific offline session */
     resumeOfflineSession(session) {
+        const existing = this.sessions.find((runtime) => runtime.id === session.id);
+        if (existing) {
+            if (this.isSessionRuntimeLive(existing)) {
+                this.offlineSessions = this.offlineSessions.filter((s) => s.id !== session.id);
+                this.invalidateDesktopStateSnapshot();
+                this.writeStatuslineFile();
+                return;
+            }
+            this.evictZombieSession(existing);
+        }
         const config = loadConfig();
         const toolCfg = config.tools[session.toolConfigKey];
         if (!toolCfg)
             return;
+        const derived = loadMetadataState().sessions[session.id]?.derived;
+        const relaunchFresh = derived?.activity === "error" || derived?.attention === "error";
+        const useBackendResume = !relaunchFresh && this.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, session.backendSessionId);
         let actionArgs;
-        if (this.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, session.backendSessionId)) {
+        if (useBackendResume) {
             actionArgs = toolCfg.resumeArgs.map((a) => a.replace("{sessionId}", session.backendSessionId));
         }
+        else if (relaunchFresh) {
+            actionArgs = [];
+        }
         else {
             actionArgs = [...(toolCfg.resumeFallback ?? [])];
         }
-        const args = this.sessionBootstrap.composeToolArgs(toolCfg, actionArgs, session.args);
-        // Remove from offline list
+        const args = [...(toolCfg.args ?? []), ...actionArgs];
+        if (relaunchFresh) {
+            updateSessionMetadata(session.id, (current) => {
+                const next = { ...current };
+                delete next.derived;
+                delete next.status;
+                delete next.progress;
+                return next;
+            });
+        }
+        const preservedLabel = session.label ?? this.getSessionLabel(session.id);
         this.offlineSessions = this.offlineSessions.filter((s) => s.id !== session.id);
-        debug(`resuming offline session ${session.id} (backend=${session.backendSessionId ?? "none"})`, "session");
+        this.invalidateDesktopStateSnapshot();
+        this.saveState();
+        this.writeStatuslineFile();
+        if (preservedLabel) {
+            this.sessionLabels.set(session.id, preservedLabel);
+        }
+        debug(`resuming offline session ${session.id} (${relaunchFresh ? "fresh" : useBackendResume ? `backend=${session.backendSessionId ?? "none"}` : "fallback"})`, "session");
         this.createSession(session.command, args, toolCfg.preambleFlag, session.toolConfigKey, undefined, undefined, // don't pass sessionIdFlag — we're resuming with existing backend ID
-        session.worktreePath, session.backendSessionId);
+        session.worktreePath, useBackendResume ? session.backendSessionId : undefined, session.id, true);
     }
     startHeartbeat() {
-        if (this.heartbeatInterval)
-            return;
-        this.heartbeatInterval = setInterval(() => {
-            if (this.mode === "project-service") {
-                this.syncSessionsFromState();
-                return;
-            }
-            const sessions = this.getInstanceSessionRefs();
-            this.instanceDirectory
-                .reconcileHeartbeat(this.instanceId, sessions, process.cwd(), this.confirmedRegistered)
-                .then((result) => {
-                for (const id of result.claimedIds) {
-                    debug(`session ${id} claimed: was in confirmedRegistered but not in previousIds`, "instance");
-                    this.handleSessionClaimed(id);
-                }
-                if (result.skippedClaimDetection && this.confirmedRegistered.size > 0) {
-                    debug(`skipping claim detection: previousIds empty but ${this.confirmedRegistered.size} confirmed sessions (registry entry may have been pruned)`, "instance");
-                }
-                this.confirmedRegistered = result.confirmedIds;
-            })
-                .catch(() => { });
-            // Refresh offline sessions from state.json (picks up cross-instance graveyard/kill)
-            this.loadOfflineSessions();
-            // Refresh dashboard to pick up remote instance changes (skip if overlay is active)
-            if (this.mode === "dashboard") {
-                this.renderCurrentDashboardView();
-            }
-        }, 5000);
+        this.runtimeSync.startHeartbeat();
     }
     /**
      * Handle a session that was claimed (taken over) by another aimux instance.
@@ -5555,24 +5645,13 @@ export class Multiplexer {
         this.renderDashboard();
     }
     stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
+        this.runtimeSync.stopHeartbeat();
     }
     startProjectServiceRefresh() {
-        if (this.projectServiceInterval)
-            return;
-        this.projectServiceInterval = setInterval(() => {
-            this.syncSessionsFromState();
-            this.writeStatuslineFile();
-        }, 2000);
+        this.runtimeSync.startProjectServiceRefresh();
     }
     stopProjectServiceRefresh() {
-        if (this.projectServiceInterval) {
-            clearInterval(this.projectServiceInterval);
-            this.projectServiceInterval = null;
-        }
+        this.runtimeSync.stopProjectServiceRefresh();
     }
     getRemoteInstancesSafe() {
         return this.instanceDirectory.getRemoteInstancesSafe(this.instanceId, process.cwd());