aimux-cli 0.1.3 → 0.1.4

package/dist/multiplexer.js

@@ -41,6 +41,7 @@ import { appendSessionMessage, readSessionMessages } from "./session-message-his
 import { ProjectEventBus } from "./project-events.js";
 import { deriveSessionSemantics } from "./session-semantics.js";
 import { injectClaudeHookArgs } from "./claude-hooks.js";
+import { wrapCommandWithShellIntegration, wrapInteractiveShellWithIntegration } from "./shell-hooks.js";
 import { navigationUrgencyScore } from "./fast-control.js";
 import { requestJson } from "./http-client.js";
 import { openDashboardTarget } from "./dashboard-targets.js";
@@ -60,6 +61,7 @@ import { graveyardSessionWithFeedback as runGraveyardSessionWithFeedback, resume
 export class Multiplexer {
     projectRoot;
     sessions = [];
+    offlineServices = [];
     activeIndex = 0;
     mode = "dashboard";
     hotkeys;
@@ -168,6 +170,7 @@ export class Multiplexer {
     dashboardServicesCache = [];
     dashboardWorktreeGroupsCache = [];
     dashboardMainCheckoutInfoCache = { name: "Main Checkout", branch: "" };
+    dashboardModelSnapshotKey = null;
     dashboardModelRefreshedAt = 0;
     dashboardServiceSnapshotRefreshing = false;
     dashboardServiceRecovery = null;
@@ -356,12 +359,24 @@ export class Multiplexer {
         });
     }
     applyDashboardModel(dashSessions, dashServices, worktreeGroups, mainCheckoutInfo) {
+        const snapshotKey = JSON.stringify({
+            sessions: dashSessions,
+            services: dashServices,
+            worktreeGroups,
+            mainCheckoutInfo,
+        });
+        if (snapshotKey === this.dashboardModelSnapshotKey) {
+            this.dashboardModelRefreshedAt = Date.now();
+            return false;
+        }
+        this.dashboardModelSnapshotKey = snapshotKey;
         this.dashboardSessionsCache = this.dashboardPendingActions.applyToSessions(dashSessions);
         this.dashboardServicesCache = this.dashboardPendingActions.applyToServices(dashServices);
         this.dashboardWorktreeGroupsCache = worktreeGroups;
         this.dashboardMainCheckoutInfoCache = mainCheckoutInfo;
         this.dashboardModelRefreshedAt = Date.now();
         this.dashboardUiStateStore.markSelectionDirty();
+        return true;
     }
     invalidateDesktopStateSnapshot() {
         this.desktopStateSnapshot = null;
@@ -503,10 +518,9 @@ export class Multiplexer {
     }
     computeDashboardServices(worktrees = this.listDesktopWorktrees()) {
         const lastUsedState = loadLastUsedState(process.cwd());
-        const tmuxSession = this.tmuxRuntimeManager.getProjectSession(process.cwd());
         const worktreeByPath = new Map(worktrees.map((wt) => [wt.path, wt]));
-        return this.tmuxRuntimeManager
-            .listManagedWindows(tmuxSession.sessionName)
+        const liveServices = this.tmuxRuntimeManager
+            .listProjectManagedWindows(process.cwd())
             .filter(({ target, metadata }) => !isDashboardWindowName(target.windowName) && metadata.kind === "service")
             .map(({ target, metadata }) => {
             const worktree = metadata.worktreePath ? worktreeByPath.get(metadata.worktreePath) : undefined;
@@ -530,6 +544,30 @@ export class Multiplexer {
                 previewLine: info.previewLine,
             };
         });
+        const liveIds = new Set(liveServices.map((service) => service.id));
+        const offlineServices = this.offlineServices
+            .filter((service) => !liveIds.has(service.id))
+            .map((service) => {
+            const worktree = service.worktreePath ? worktreeByPath.get(service.worktreePath) : undefined;
+            const label = service.label ?? this.serviceLabelForCommand(service.launchCommandLine ?? "");
+            const previewLine = service.launchCommandLine?.trim() || "Interactive shell";
+            return {
+                id: service.id,
+                command: service.launchCommandLine?.trim() ?? "",
+                args: [],
+                lastUsedAt: lastUsedState.items[service.id]?.lastUsedAt,
+                worktreePath: service.worktreePath,
+                worktreeName: worktree?.name,
+                worktreeBranch: worktree?.branch,
+                status: "offline",
+                active: false,
+                label,
+                cwd: service.worktreePath,
+                foregroundCommand: label,
+                previewLine,
+            };
+        });
+        return [...liveServices, ...offlineServices];
     }
     readTmuxProcessInfo(target) {
         const raw = this.tmuxRuntimeManager.displayMessage("#{pane_current_command}\t#{pane_pid}", target.windowId) ?? "";
@@ -595,8 +633,7 @@ export class Multiplexer {
                             const dashServices = body.services ?? [];
                             const worktrees = body.worktrees ?? [];
                             const worktreeGroups = this.buildDashboardWorktreeGroups(dashSessions, dashServices, worktrees, body.mainCheckoutPath);
-                            this.applyDashboardModel(dashSessions, dashServices, worktreeGroups, body.mainCheckoutInfo ?? { name: "Main Checkout", branch: "" });
-                            return true;
+                            return this.applyDashboardModel(dashSessions, dashServices, worktreeGroups, body.mainCheckoutInfo ?? { name: "Main Checkout", branch: "" });
                         }
                     }
                     catch {
@@ -638,6 +675,8 @@ export class Multiplexer {
                 removeWorktree: ({ path }) => this.removeDesktopWorktree(path),
                 createService: ({ command, worktreePath }) => this.createService(command ?? "", worktreePath),
                 stopService: ({ serviceId }) => this.stopService(serviceId),
+                resumeService: ({ serviceId }) => this.resumeOfflineServiceById(serviceId),
+                removeService: ({ serviceId }) => this.removeOfflineService(serviceId),
                 listGraveyard: () => this.listGraveyardEntries(),
                 resurrectGraveyard: ({ sessionId }) => this.resurrectGraveyardSession(sessionId),
             },
@@ -1437,14 +1476,14 @@ export class Multiplexer {
             finalArgs = [...finalArgs, ...expandedFlag];
         }
         const toolCfg = toolConfigKey ? loadConfig().tools[toolConfigKey] : undefined;
+        let projectRoot = process.cwd();
+        try {
+            projectRoot = findMainRepo(worktreePath ?? process.cwd());
+        }
+        catch {
+            projectRoot = process.cwd();
+        }
         if (toolCfg && toolConfigKey === "claude" && toolCfg.command === command && toolCfg.wrapperEnabled !== false) {
-            let projectRoot = process.cwd();
-            try {
-                projectRoot = findMainRepo(worktreePath ?? process.cwd());
-            }
-            catch {
-                projectRoot = process.cwd();
-            }
             finalArgs = injectClaudeHookArgs(finalArgs, {
                 sessionId,
                 projectRoot,
@@ -1452,6 +1491,17 @@ export class Multiplexer {
             });
             launchCommand = toolCfg.command;
         }
+        else if (toolCfg && toolCfg.command === command) {
+            const wrapped = wrapCommandWithShellIntegration({
+                projectRoot,
+                sessionId,
+                tool: toolConfigKey ?? command,
+                command: launchCommand,
+                args: finalArgs,
+            });
+            launchCommand = wrapped.command;
+            finalArgs = wrapped.args;
+        }
         if (preambleFlag) {
             this.sessionBootstrap.finalizePreamble(command, preamble);
         }
@@ -1558,6 +1608,11 @@ export class Multiplexer {
         const sid = this.sessions[index].id;
         this.sessionMRU = [sid, ...this.sessionMRU.filter((id) => id !== sid)];
         this.agentTracker.markSeen(sid);
+        updateNotificationContext("tui", {
+            focused: true,
+            sessionId: sid,
+            panelOpen: false,
+        });
         this.noteLastUsedItem(sid);
         markNotificationsRead({ sessionId: sid });
         this.syncTuiNotificationContext(false);
@@ -1740,13 +1795,19 @@ export class Multiplexer {
                 const selectedService = this.getSelectedDashboardServiceForActions();
                 if (selectedService) {
                     try {
-                        this.stopService(selectedService.id);
-                        this.footerFlash = `◆ Stopped service ${selectedService.label ?? selectedService.id}`;
+                        if (selectedService.status === "offline") {
+                            this.removeOfflineService(selectedService.id);
+                            this.footerFlash = `◆ Deleted service ${selectedService.label ?? selectedService.id}`;
+                        }
+                        else {
+                            this.stopService(selectedService.id);
+                            this.footerFlash = `◆ Stopped service ${selectedService.label ?? selectedService.id}`;
+                        }
                         this.footerFlashTicks = 3;
                         this.renderDashboard();
                     }
                     catch (error) {
-                        this.showDashboardError("Failed to stop service", [error instanceof Error ? error.message : String(error)]);
+                        this.showDashboardError(selectedService.status === "offline" ? "Failed to delete service" : "Failed to stop service", [error instanceof Error ? error.message : String(error)]);
                     }
                     return;
                 }
@@ -1829,7 +1890,10 @@ export class Multiplexer {
                 case "enter": {
                     const ds = this.getDashboardSessions();
                     const entry = ds[this.activeIndex];
-                    if (entry && this.openLiveTmuxWindowForEntry(entry)) {
+                    if (entry?.pendingAction === "creating" || entry?.pendingAction === "starting") {
+                        return;
+                    }
+                    if (entry && this.openLiveTmuxWindowForEntry(entry) !== "missing") {
                         return;
                     }
                     if (entry?.remoteInstanceId) {
@@ -1838,7 +1902,7 @@ export class Multiplexer {
                     }
                     if (entry?.status === "offline") {
                         const offline = this.offlineSessions.find((s) => s.id === entry.id);
-                        if (offline && entry.pendingAction !== "starting") {
+                        if (offline) {
                             void this.resumeOfflineSessionWithFeedback(offline);
                         }
                         return;
@@ -1923,13 +1987,38 @@ export class Multiplexer {
                     if (!selectedEntry)
                         break;
                     if (selectedEntry.kind === "service") {
-                        this.openLiveTmuxWindowForService(selectedEntry.id);
+                        const service = this.getDashboardServices().find((entry) => entry.id === selectedEntry.id);
+                        if (!service)
+                            break;
+                        if (service.pendingAction === "creating" || service.pendingAction === "starting") {
+                            return;
+                        }
+                        if (service.status === "offline") {
+                            try {
+                                this.resumeOfflineServiceById(service.id);
+                                this.footerFlash = `◆ Started service ${service.label ?? service.id}`;
+                                this.footerFlashTicks = 3;
+                                this.renderDashboard();
+                            }
+                            catch (error) {
+                                this.showDashboardError("Failed to start service", [
+                                    error instanceof Error ? error.message : String(error),
+                                ]);
+                            }
+                            return;
+                        }
+                        if (this.openLiveTmuxWindowForService(selectedEntry.id) !== "missing") {
+                            return;
+                        }
                         break;
                     }
                     const dashEntry = this.dashboardState.worktreeSessions.find((entry) => entry.id === selectedEntry.id);
                     if (!dashEntry)
                         break;
-                    if (this.openLiveTmuxWindowForEntry(dashEntry)) {
+                    if (dashEntry.pendingAction === "creating" || dashEntry.pendingAction === "starting") {
+                        return;
+                    }
+                    if (this.openLiveTmuxWindowForEntry(dashEntry) !== "missing") {
                         return;
                     }
                     if (dashEntry.remoteInstanceId) {
@@ -1938,7 +2027,7 @@ export class Multiplexer {
                     }
                     if (dashEntry.status === "offline") {
                         const offline = this.offlineSessions.find((s) => s.id === dashEntry.id);
-                        if (offline && dashEntry.pendingAction !== "starting") {
+                        if (offline) {
                             void this.resumeOfflineSessionWithFeedback(offline);
                         }
                         return;
@@ -1968,10 +2057,10 @@ export class Multiplexer {
     async activateDashboardEntry(entry) {
         if (!entry)
             return;
-        if (entry.pendingAction === "creating") {
+        if (entry.pendingAction === "creating" || entry.pendingAction === "starting") {
             return;
         }
-        if (this.openLiveTmuxWindowForEntry(entry)) {
+        if (this.openLiveTmuxWindowForEntry(entry) !== "missing") {
             return;
         }
         if (entry.remoteInstanceId) {
@@ -1980,7 +2069,7 @@ export class Multiplexer {
         }
         if (entry.status === "offline") {
             const offline = this.offlineSessions.find((session) => session.id === entry.id);
-            if (offline && entry.pendingAction !== "starting") {
+            if (offline) {
                 await this.resumeOfflineSessionWithFeedback(offline);
             }
             return;
@@ -2910,19 +2999,42 @@ export class Multiplexer {
         return false;
     }
     openLiveTmuxWindowForEntry(entry) {
-        const target = openManagedSessionWindow(this.tmuxRuntimeManager, process.cwd(), entry);
-        if (!target)
-            return false;
-        this.agentTracker.markSeen(entry.id);
-        this.noteLastUsedItem(entry.id);
-        return true;
+        try {
+            const target = openManagedSessionWindow(this.tmuxRuntimeManager, process.cwd(), entry);
+            if (!target)
+                return "missing";
+            this.agentTracker.markSeen(entry.id);
+            updateNotificationContext("tui", {
+                focused: true,
+                sessionId: entry.id,
+                panelOpen: false,
+            });
+            this.noteLastUsedItem(entry.id);
+            return "opened";
+        }
+        catch (error) {
+            this.showDashboardError("Failed to open agent", [
+                error instanceof Error ? error.message : String(error),
+                "The tmux window may still be starting. Try again in a moment.",
+            ]);
+            return "error";
+        }
     }
     openLiveTmuxWindowForService(serviceId) {
-        const target = openManagedServiceWindow(this.tmuxRuntimeManager, process.cwd(), serviceId);
-        if (!target)
-            return false;
-        this.noteLastUsedItem(serviceId);
-        return true;
+        try {
+            const target = openManagedServiceWindow(this.tmuxRuntimeManager, process.cwd(), serviceId);
+            if (!target)
+                return "missing";
+            this.noteLastUsedItem(serviceId);
+            return "opened";
+        }
+        catch (error) {
+            this.showDashboardError("Failed to open service", [
+                error instanceof Error ? error.message : String(error),
+                "The tmux window may still be starting. Try again in a moment.",
+            ]);
+            return "error";
+        }
     }
     noteLastUsedItem(itemId) {
         markLastUsed(process.cwd(), {
@@ -3715,8 +3827,30 @@ export class Multiplexer {
         const cwd = worktreePath ?? process.cwd();
         const shell = process.env.SHELL || "zsh";
         const trimmed = commandLine.trim();
-        const command = shell;
-        const args = trimmed ? ["-lc", trimmed] : ["-l"];
+        let projectRoot = process.cwd();
+        try {
+            projectRoot = findMainRepo(cwd);
+        }
+        catch {
+            projectRoot = process.cwd();
+        }
+        const wrapped = trimmed
+            ? wrapCommandWithShellIntegration({
+                projectRoot,
+                sessionId: serviceId,
+                tool: "service",
+                command: shell,
+                args: ["-lc", trimmed],
+                shellPath: shell,
+            })
+            : wrapInteractiveShellWithIntegration({
+                projectRoot,
+                sessionId: serviceId,
+                tool: "service",
+                shellPath: shell,
+            });
+        const command = wrapped.command;
+        const args = wrapped.args;
         const label = this.serviceLabelForCommand(trimmed);
         const tmuxSession = this.tmuxRuntimeManager.ensureProjectSession(process.cwd());
         const shouldRenderPending = this.startedInDashboard && this.mode === "dashboard";
@@ -3730,13 +3864,14 @@ export class Multiplexer {
             this.tmuxRuntimeManager.setWindowMetadata(target, {
                 kind: "service",
                 sessionId: serviceId,
-                command,
-                args,
+                command: trimmed ? shell : "shell",
+                args: trimmed ? ["-lc", trimmed] : ["-l"],
                 toolConfigKey: "service",
                 worktreePath,
                 label,
             });
             this.tmuxRuntimeManager.applyManagedAgentWindowPolicy(target, "service");
+            this.saveState();
             this.invalidateDesktopStateSnapshot();
             this.refreshLocalDashboardModel();
             this.updateWorktreeSessions();
@@ -3759,12 +3894,112 @@ export class Multiplexer {
         if (!match || match.metadata.kind !== "service") {
             throw new Error(`Service "${serviceId}" not found`);
         }
+        const launchCommandLine = match.metadata.command === "shell"
+            ? ""
+            : match.metadata.args?.[0] === "-lc"
+                ? (match.metadata.args[1] ?? "")
+                : "";
+        this.offlineServices = [
+            ...this.offlineServices.filter((service) => service.id !== serviceId),
+            {
+                id: serviceId,
+                worktreePath: match.metadata.worktreePath,
+                label: match.metadata.label,
+                launchCommandLine,
+            },
+        ];
         this.tmuxRuntimeManager.killWindow(match.target);
+        this.saveState();
         this.invalidateDesktopStateSnapshot();
         this.refreshLocalDashboardModel();
         this.adjustAfterRemove(this.dashboardWorktreeGroupsCache.length > 0);
         return { serviceId, status: "stopped" };
     }
+    removeOfflineService(serviceId) {
+        this.offlineServices = this.offlineServices.filter((service) => service.id !== serviceId);
+        const statePath = getStatePath();
+        if (existsSync(statePath)) {
+            try {
+                const state = JSON.parse(readFileSync(statePath, "utf-8"));
+                state.services = (state.services ?? []).filter((service) => service.id !== serviceId);
+                writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
+            }
+            catch { }
+        }
+        this.saveState();
+        this.invalidateDesktopStateSnapshot();
+        this.refreshLocalDashboardModel();
+        this.adjustAfterRemove(this.dashboardWorktreeGroupsCache.length > 0);
+        return { serviceId, status: "removed" };
+    }
+    resumeOfflineService(service) {
+        const existing = this.tmuxRuntimeManager.findManagedWindow(this.tmuxRuntimeManager.getProjectSession(process.cwd()).sessionName, {
+            sessionId: service.id,
+        });
+        if (existing && existing.metadata.kind === "service") {
+            this.offlineServices = this.offlineServices.filter((entry) => entry.id !== service.id);
+            this.saveState();
+            this.invalidateDesktopStateSnapshot();
+            this.refreshLocalDashboardModel();
+            return { serviceId: service.id, status: "running" };
+        }
+        const cwd = service.worktreePath ?? process.cwd();
+        const shell = process.env.SHELL || "zsh";
+        const launchCommandLine = service.launchCommandLine?.trim() ?? "";
+        let projectRoot = process.cwd();
+        try {
+            projectRoot = findMainRepo(cwd);
+        }
+        catch {
+            projectRoot = process.cwd();
+        }
+        const wrapped = launchCommandLine
+            ? wrapCommandWithShellIntegration({
+                projectRoot,
+                sessionId: service.id,
+                tool: "service",
+                command: shell,
+                args: ["-lc", launchCommandLine],
+                shellPath: shell,
+            })
+            : wrapInteractiveShellWithIntegration({
+                projectRoot,
+                sessionId: service.id,
+                tool: "service",
+                shellPath: shell,
+            });
+        const command = wrapped.command;
+        const args = wrapped.args;
+        const label = service.label ?? this.serviceLabelForCommand(launchCommandLine);
+        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: service.id,
+            command: launchCommandLine ? shell : "shell",
+            args: launchCommandLine ? ["-lc", launchCommandLine] : ["-l"],
+            toolConfigKey: "service",
+            worktreePath: service.worktreePath,
+            label,
+        });
+        this.tmuxRuntimeManager.applyManagedAgentWindowPolicy(target, "service");
+        this.offlineServices = this.offlineServices.filter((entry) => entry.id !== service.id);
+        this.saveState();
+        this.invalidateDesktopStateSnapshot();
+        this.refreshLocalDashboardModel();
+        this.updateWorktreeSessions();
+        this.preferDashboardEntrySelection("service", service.id, service.worktreePath);
+        return { serviceId: service.id, status: "running" };
+    }
+    resumeOfflineServiceById(serviceId) {
+        const service = this.offlineServices.find((entry) => entry.id === serviceId);
+        if (!service) {
+            throw new Error(`Service "${serviceId}" not found`);
+        }
+        return this.resumeOfflineService(service);
+    }
     renderDashboard() {
         this.writeStatuslineFile();
         const { cols, rows } = this.getViewportSize();
@@ -5395,6 +5630,7 @@ export class Multiplexer {
     syncSessionsFromState(state = Multiplexer.loadState()) {
         this.restoreTmuxSessionsFromState(state);
         this.loadOfflineSessions(state);
+        this.loadOfflineServices(state);
         this.invalidateDesktopStateSnapshot();
     }
     loadOfflineSessions(state = Multiplexer.loadState()) {
@@ -5434,12 +5670,57 @@ export class Multiplexer {
         }
         return previousKey !== nextKey;
     }
+    loadOfflineServices(state = Multiplexer.loadState()) {
+        const savedServices = state?.services ?? [];
+        if (savedServices.length === 0) {
+            const changed = this.offlineServices.length > 0;
+            this.offlineServices = [];
+            return changed;
+        }
+        const liveServiceIds = new Set(this.tmuxRuntimeManager
+            .listProjectManagedWindows(process.cwd())
+            .filter(({ target, metadata }) => !isDashboardWindowName(target.windowName) && metadata.kind === "service")
+            .map(({ metadata }) => metadata.sessionId));
+        const nextOfflineServices = savedServices.filter((service) => {
+            if (liveServiceIds.has(service.id))
+                return false;
+            if (service.worktreePath && !existsSync(service.worktreePath))
+                return false;
+            return true;
+        });
+        const previousKey = this.offlineServices
+            .map((service) => `${service.id}:${service.label ?? ""}:${service.worktreePath ?? ""}:${service.launchCommandLine ?? ""}`)
+            .join("|");
+        const nextKey = nextOfflineServices
+            .map((service) => `${service.id}:${service.label ?? ""}:${service.worktreePath ?? ""}:${service.launchCommandLine ?? ""}`)
+            .join("|");
+        this.offlineServices = nextOfflineServices;
+        return previousKey !== nextKey;
+    }
+    buildLiveServiceStates() {
+        const seen = new Set();
+        const liveServices = [];
+        for (const { metadata } of this.tmuxRuntimeManager.listProjectManagedWindows(process.cwd())) {
+            if (metadata.kind !== "service")
+                continue;
+            if (seen.has(metadata.sessionId))
+                continue;
+            seen.add(metadata.sessionId);
+            const launchCommandLine = metadata.command === "shell" ? "" : metadata.args?.[0] === "-lc" ? (metadata.args[1] ?? "") : "";
+            liveServices.push({
+                id: metadata.sessionId,
+                worktreePath: metadata.worktreePath,
+                label: metadata.label,
+                launchCommandLine,
+            });
+        }
+        return liveServices;
+    }
     restoreTmuxSessionsFromState(state = Multiplexer.loadState()) {
         const savedById = new Map((state?.sessions ?? []).map((session) => [session.id, session]));
         const cols = process.stdout.columns ?? 80;
         const rows = process.stdout.rows ?? 24;
-        const tmuxSession = this.tmuxRuntimeManager.getProjectSession(process.cwd());
-        for (const { target, metadata } of this.tmuxRuntimeManager.listManagedWindows(tmuxSession.sessionName)) {
+        for (const { target, metadata } of this.tmuxRuntimeManager.listProjectManagedWindows(process.cwd())) {
             if (isDashboardWindowName(target.windowName))
                 continue;
             if (metadata.kind === "service")
@@ -5687,11 +5968,14 @@ export class Multiplexer {
             tmuxTarget: this.sessionTmuxTargets.get(s.id),
         }));
         const mySessions = [...this.offlineSessions, ...liveSessions];
-        if (mySessions.length === 0)
+        const liveServices = this.buildLiveServiceStates();
+        const myServices = [...this.offlineServices, ...liveServices].filter((service, index, services) => services.findIndex((entry) => entry.id === service.id) === index);
+        if (mySessions.length === 0 && myServices.length === 0)
             return;
         // Merge with existing state (other instances may have written their sessions)
         const statePath = Multiplexer.getSharedStatePath();
         let mergedSessions = mySessions;
+        let mergedServices = myServices;
         if (existsSync(statePath)) {
             try {
                 const existing = JSON.parse(readFileSync(statePath, "utf-8"));
@@ -5706,6 +5990,9 @@ export class Multiplexer {
                     return true;
                 });
                 mergedSessions = [...otherSessions, ...mySessions];
+                const myServiceIds = new Set(myServices.map((service) => service.id));
+                const otherServices = (existing.services ?? []).filter((service) => !myServiceIds.has(service.id));
+                mergedServices = [...otherServices, ...myServices];
             }
             catch {
                 // Corrupt file — just overwrite with ours
@@ -5715,6 +6002,7 @@ export class Multiplexer {
             savedAt: new Date().toISOString(),
             cwd: process.cwd(),
             sessions: mergedSessions,
+            services: mergedServices,
         };
         writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
         this.invalidateDesktopStateSnapshot();