aimux-cli 0.1.16 → 0.1.19

package/dist/multiplexer/runtime-state.js

@@ -1,12 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { loadConfig } from "../config.js";
 import { loadMetadataState, updateSessionMetadata } from "../metadata-store.js";
-import { getGraveyardPath, getLocalAimuxDir, getStatePath } from "../paths.js";
 import { isToolInternalWorktree, listWorktrees as listAllWorktrees } from "../worktree.js";
 import { isDashboardWindowName } from "../tmux/runtime-manager.js";
 import { TmuxSessionTransport } from "../tmux/session-transport.js";
 import { markLastUsed } from "../last-used.js";
 import { listWorktreeGraveyardPaths } from "./worktree-graveyard.js";
+import { getServiceLaunchCommandLine } from "./services.js";
+import { listTopologySessionStates, moveTopologySessionToGraveyard, upsertTopologySession, } from "../runtime-core/topology-sessions.js";
+import { listTopologyServiceStates } from "../runtime-core/topology-services.js";
+const DASHBOARD_BACKGROUND_REFRESH_MS = 2000;
 function isAvailableWorktreePath(worktreePath, graveyardPaths = listWorktreeGraveyardPaths()) {
     if (!worktreePath)
         return true;
@@ -110,41 +113,6 @@ export function startStatusRefresh(host) {
         return;
     host.statusInterval = setInterval(() => {
         let dashboardNeedsRender = false;
-        if (host.mode === "project-service") {
-            host.taskDispatcher?.tick(host.sessions.map((s) => s.id));
-            host.orchestrationDispatcher?.tick(host.sessions.map((s) => s.id));
-        }
-        const events = host.taskDispatcher?.drainEvents() ?? [];
-        for (const ev of events) {
-            if (ev.type === "assigned") {
-                host.footerFlash = `⧫ Task assigned → ${ev.sessionId}`;
-            }
-            else if (ev.type === "completed") {
-                host.footerFlash = `✓ Task done by ${ev.sessionId}`;
-            }
-            else if (ev.type === "failed") {
-                host.footerFlash = `✗ Task failed: ${ev.sessionId}`;
-            }
-            else if (ev.type === "review_created") {
-                host.footerFlash = `⧫ Review created: ${ev.description}`;
-            }
-            else if (ev.type === "review_approved") {
-                host.footerFlash = `✓ Review approved: ${ev.description}`;
-            }
-            else if (ev.type === "changes_requested") {
-                host.footerFlash = `↻ Changes requested: ${ev.description}`;
-            }
-            host.footerFlashTicks = 3;
-            dashboardNeedsRender = true;
-        }
-        const orchestrationEvents = host.orchestrationDispatcher?.drainEvents() ?? [];
-        for (const event of orchestrationEvents) {
-            if (event.type === "message_delivered") {
-                host.footerFlash = `✉ Message delivered → ${event.sessionId}`;
-                host.footerFlashTicks = 3;
-                dashboardNeedsRender = true;
-            }
-        }
         if (host.dashboardFeedback.tickFlashVisibilityChanged()) {
             dashboardNeedsRender = true;
         }
@@ -166,7 +134,7 @@ export function startStatusRefresh(host) {
         if (host.mode === "dashboard") {
             const now = Date.now();
             if (now >= host.dashboardNextBackgroundRefreshAt) {
-                host.dashboardNextBackgroundRefreshAt = now + 5000;
+                host.dashboardNextBackgroundRefreshAt = now + DASHBOARD_BACKGROUND_REFRESH_MS;
                 void host.refreshDashboardModelFromService().then((refreshed) => {
                     if (refreshed || dashboardNeedsRender) {
                         host.renderCurrentDashboardView();
@@ -185,45 +153,38 @@ export function stopStatusRefresh(host) {
         host.statusInterval = null;
     }
 }
-export function syncSessionsFromState(host, state = host.constructor.loadState()) {
-    const liveAgentWindows = restoreTmuxSessionsFromState(host, state);
-    loadOfflineSessions(host, state, liveAgentWindows);
+export function syncSessionsFromTopology(host) {
+    const state = host.constructor.loadState();
+    const liveAgentWindows = restoreTmuxSessionsFromTopology(host);
+    loadOfflineTopologySessions(host, liveAgentWindows);
     loadOfflineServices(host, state);
     host.invalidateDesktopStateSnapshot();
 }
-export function loadOfflineSessions(host, state = host.constructor.loadState(), liveAgentWindows = listLiveAgentWindows(host)) {
-    if (!state || state.sessions.length === 0) {
+export function loadOfflineTopologySessions(host, liveAgentWindows = listLiveAgentWindows(host)) {
+    const savedSessions = listTopologySessionStates({ statuses: ["offline"] });
+    if (savedSessions.length === 0) {
         const changed = host.offlineSessions.length > 0;
         host.offlineSessions = [];
         return changed;
     }
     const liveIds = new Set(liveAgentWindows.map(({ metadata }) => metadata.sessionId));
-    const liveBackendIds = new Set(liveAgentWindows
-        .map(({ metadata }) => metadata.backendSessionId)
-        .filter((value) => Boolean(value)));
     const ownedIds = new Set();
     for (const s of host.sessions)
         ownedIds.add(s.id);
-    for (const inst of host.getRemoteInstancesSafe()) {
-        for (const rs of inst.sessions)
-            ownedIds.add(rs.id);
-    }
     const ownedBackendIds = new Set(host.sessions
         .map((session) => session.backendSessionId)
         .filter((value) => Boolean(value)));
-    const nextOfflineSessions = state.sessions
+    const nextOfflineSessions = savedSessions
         .filter((s) => {
         if (!isIntentionalOfflineSession(s))
             return false;
         if (liveIds.has(s.id))
             return false;
-        if (s.backendSessionId && liveBackendIds.has(s.backendSessionId))
-            return false;
         if (ownedIds.has(s.id))
             return false;
         if (s.backendSessionId && ownedBackendIds.has(s.backendSessionId))
             return false;
-        if (host.dashboardPendingActions?.get?.(s.id) === "starting")
+        if (host.dashboardPendingActions?.getSessionAction?.(s.id) === "starting")
             return false;
         if (!isAvailableWorktreePath(s.worktreePath))
             return false;
@@ -231,19 +192,20 @@ export function loadOfflineSessions(host, state = host.constructor.loadState(),
     })
         .map(offlineSessionState);
     const previousKey = host.offlineSessions
-        .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}`)
+        .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}:${session.backendSessionId ?? ""}:${JSON.stringify(session.team ?? null)}`)
         .join("|");
     const nextKey = nextOfflineSessions
-        .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}`)
+        .map((session) => `${session.id}:${session.label ?? ""}:${session.worktreePath ?? ""}:${session.backendSessionId ?? ""}:${JSON.stringify(session.team ?? null)}`)
         .join("|");
     host.offlineSessions = nextOfflineSessions;
     if (host.offlineSessions.length > 0) {
-        host.debug?.(`loaded ${host.offlineSessions.length} offline session(s) from state.json`, "session");
+        host.debug?.(`loaded ${host.offlineSessions.length} offline session(s) from runtime topology`, "session");
     }
     return previousKey !== nextKey;
 }
 export function loadOfflineServices(host, state = host.constructor.loadState()) {
-    const savedServices = state?.services ?? [];
+    const topologyServices = listTopologyServiceStates({ statuses: ["stopped", "offline"] });
+    const savedServices = topologyServices.length > 0 ? topologyServices : (state?.services ?? []);
     if (savedServices.length === 0) {
         const changed = host.offlineServices.length > 0;
         host.offlineServices = [];
@@ -259,7 +221,7 @@ export function loadOfflineServices(host, state = host.constructor.loadState())
     const nextOfflineServices = savedServices.filter((service) => {
         if (liveServiceIds.has(service.id))
             return false;
-        if (host.dashboardPendingActions?.get?.(service.id) === "starting")
+        if (host.dashboardPendingActions?.getServiceAction?.(service.id) === "starting")
             return false;
         if (!isAvailableWorktreePath(service.worktreePath))
             return false;
@@ -288,7 +250,7 @@ export function buildLiveServiceStates(host) {
         if (seen.has(metadata.sessionId))
             continue;
         seen.add(metadata.sessionId);
-        const launchCommandLine = metadata.command === "shell" ? "" : metadata.args?.[0] === "-lc" ? (metadata.args[1] ?? "") : "";
+        const launchCommandLine = metadata.launchCommandLine?.trim() || getServiceLaunchCommandLine(metadata);
         liveServices.push({
             id: metadata.sessionId,
             createdAt: metadata.createdAt,
@@ -301,8 +263,9 @@ export function buildLiveServiceStates(host) {
     }
     return liveServices;
 }
-export function restoreTmuxSessionsFromState(host, state = host.constructor.loadState()) {
-    const savedById = new Map((state?.sessions ?? []).map((session) => [session.id, session]));
+export function restoreTmuxSessionsFromTopology(host) {
+    const savedSessions = listTopologySessionStates({ statuses: ["running", "idle", "offline"] });
+    const savedById = new Map(savedSessions.map((session) => [session.id, session]));
     const cols = process.stdout.columns ?? 80;
     const rows = process.stdout.rows ?? 24;
     const liveAgentWindows = listLiveAgentWindows(host);
@@ -330,9 +293,8 @@ export function restoreTmuxSessionsFromState(host, state = host.constructor.load
         if (existing)
             continue;
         const transport = new TmuxSessionTransport(metadata.sessionId, metadata.command, target, host.tmuxRuntimeManager, cols, rows);
-        transport.backendSessionId = metadata.backendSessionId;
         host.sessionTmuxTargets.set(metadata.sessionId, target);
-        host.registerManagedSession(transport, metadata.args, metadata.toolConfigKey, metadata.worktreePath, metadata.role, metadata.createdAt ? Date.parse(metadata.createdAt) : undefined);
+        host.registerManagedSession(transport, metadata.args, metadata.toolConfigKey, metadata.worktreePath, metadata.role, metadata.createdAt ? Date.parse(metadata.createdAt) : undefined, metadata.team);
         const saved = savedById.get(metadata.sessionId);
         const label = metadata.label ?? saved?.label;
         if (label) {
@@ -343,7 +305,6 @@ export function restoreTmuxSessionsFromState(host, state = host.constructor.load
         }
         host.syncTmuxWindowMetadata(metadata.sessionId);
     }
-    host.writeSessionsFile?.();
     host.updateContextWatcherSessions?.();
     return liveAgentWindows;
 }
@@ -351,6 +312,7 @@ export function stopSessionToOffline(host, session) {
     if (host.stoppingSessionIds.has(session.id))
         return;
     markLifecycleUsed(host, session.id);
+    const backendSessionId = session.backendSessionId;
     const offlineEntry = {
         id: session.id,
         tool: session.command,
@@ -359,16 +321,22 @@ export function stopSessionToOffline(host, session) {
         args: host.sessionOriginalArgs.get(session.id) ?? [],
         lifecycle: "offline",
         createdAt: session.startTime ? new Date(session.startTime).toISOString() : undefined,
-        backendSessionId: session.backendSessionId,
+        backendSessionId,
+        team: session.team,
         worktreePath: host.sessionWorktreePaths.get(session.id),
         label: host.getSessionLabel(session.id),
         headline: host.deriveHeadline(session.id),
     };
-    if (!host.offlineSessions.some((entry) => entry.id === session.id)) {
+    const existingIndex = host.offlineSessions.findIndex((entry) => entry.id === session.id);
+    if (existingIndex >= 0) {
+        host.offlineSessions[existingIndex] = { ...host.offlineSessions[existingIndex], ...offlineEntry };
+    }
+    else {
         host.offlineSessions.push(offlineEntry);
     }
     host.stoppingSessionIds.add(session.id);
     host.startedInDashboard = true;
+    upsertTopologySession(offlineEntry, "offline");
     host.saveState();
     session.kill();
     host.debug?.(`stopped session ${session.id} → offline`, "session");
@@ -390,30 +358,18 @@ export function adjustAfterRemove(host, hasWorktrees) {
         }
     }
 }
-export function graveyardSession(host, sessionId) {
-    const session = host.offlineSessions.find((s) => s.id === sessionId);
+export function graveyardSession(host, sessionId, _sessionSeed) {
+    const session = host.offlineSessions.find((s) => s.id === sessionId) ??
+        listTopologySessionStates({ statuses: ["running", "idle", "offline"] }).find((s) => s.id === sessionId);
     if (!session)
         return;
     markLifecycleUsed(host, sessionId);
     host.offlineSessions = host.offlineSessions.filter((s) => s.id !== sessionId);
-    const graveyardPath = getGraveyardPath();
-    let graveyard = [];
-    if (existsSync(graveyardPath)) {
-        try {
-            graveyard = JSON.parse(readFileSync(graveyardPath, "utf-8"));
-        }
-        catch { }
-    }
-    graveyard.push({ ...session, id: session.id });
-    writeFileSync(graveyardPath, JSON.stringify(graveyard, null, 2) + "\n");
-    const statePath = getStatePath();
-    if (existsSync(statePath)) {
-        try {
-            const state = JSON.parse(readFileSync(statePath, "utf-8"));
-            state.sessions = state.sessions.filter((s) => s.id !== sessionId);
-            writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
-        }
-        catch { }
+    moveTopologySessionToGraveyard(sessionId);
+    host.invalidateDesktopStateSnapshot?.();
+    host.writeStatuslineFile?.();
+    if (host.mode === "dashboard") {
+        host.renderCurrentDashboardView?.();
     }
     host.debug?.(`graveyarded session ${sessionId}`, "session");
 }
@@ -443,7 +399,6 @@ export function evictZombieSession(host, runtime) {
     }
     host.stoppingSessionIds.delete(runtime.id);
     host.sessionTmuxTargets.delete(runtime.id);
-    host.writeSessionsFile();
     host.updateContextWatcherSessions();
     host.saveState();
 }
@@ -464,16 +419,20 @@ export function resumeOfflineSession(host, session) {
         return;
     const derived = loadMetadataState().sessions[session.id]?.derived;
     const relaunchFresh = derived?.activity === "error" || derived?.attention === "error";
-    const useBackendResume = !relaunchFresh && host.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, session.backendSessionId);
+    const backendSessionId = session.backendSessionId;
+    const useBackendResume = !relaunchFresh && host.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, backendSessionId);
     let actionArgs;
     if (useBackendResume) {
-        actionArgs = toolCfg.resumeArgs.map((a) => a.replace("{sessionId}", session.backendSessionId));
+        actionArgs = toolCfg.resumeArgs.map((a) => a.replace("{sessionId}", backendSessionId));
     }
     else if (relaunchFresh) {
         actionArgs = [];
     }
     else {
-        actionArgs = [...(toolCfg.resumeFallback ?? [])];
+        // Targeted dashboard restore must never use "latest session" style fallbacks
+        // such as Claude --continue or Codex resume --last; those can resurrect the
+        // wrong agent after a crash or stale-state mismatch.
+        throw new Error(`Cannot restore session "${session.id}" without an exact resumable backend session id for "${session.toolConfigKey}"`);
     }
     const args = [...(toolCfg.args ?? []), ...actionArgs];
     if (relaunchFresh) {
@@ -492,31 +451,42 @@ export function resumeOfflineSession(host, session) {
     if (preservedLabel) {
         host.sessionLabels.set(session.id, preservedLabel);
     }
-    host.debug?.(`resuming offline session ${session.id} (${relaunchFresh ? "fresh" : useBackendResume ? `backend=${session.backendSessionId ?? "none"}` : "fallback"})`, "session");
-    host.createSession(session.command, args, toolCfg.preambleFlag, session.toolConfigKey, undefined, undefined, session.worktreePath, useBackendResume ? session.backendSessionId : undefined, session.id, true, !relaunchFresh);
+    host.debug?.(`resuming offline session ${session.id} (${relaunchFresh ? "fresh" : useBackendResume ? `backend=${backendSessionId ?? "none"}` : "fallback"})`, "session");
+    host.createSession(session.command, args, toolCfg.preambleFlag, session.toolConfigKey, undefined, undefined, session.worktreePath, useBackendResume ? backendSessionId : undefined, session.id, true, useBackendResume, session.team);
+}
+export function recordSessionBackendSessionId(host, sessionId, backendSessionId) {
+    const normalizedBackendSessionId = backendSessionId.trim();
+    if (!sessionId.trim()) {
+        throw new Error("sessionId is required");
+    }
+    if (!normalizedBackendSessionId) {
+        throw new Error("backendSessionId is required");
+    }
+    const runtime = host.sessions.find((session) => session.id === sessionId);
+    const offline = host.offlineSessions.find((session) => session.id === sessionId);
+    if (!runtime && !offline) {
+        throw new Error(`Agent "${sessionId}" is not managed by this runtime`);
+    }
+    const existing = runtime?.backendSessionId ?? offline?.backendSessionId;
+    if (existing && existing !== normalizedBackendSessionId) {
+        throw new Error(`Agent "${sessionId}" already has backend session "${existing}", cannot replace with "${normalizedBackendSessionId}"`);
+    }
+    const selectedBackendSessionId = existing ?? normalizedBackendSessionId;
+    if (runtime) {
+        runtime.backendSessionId = selectedBackendSessionId;
+        host.syncTmuxWindowMetadata?.(sessionId);
+    }
+    if (offline) {
+        offline.backendSessionId = selectedBackendSessionId;
+    }
+    host.saveState?.();
+    host.invalidateDesktopStateSnapshot?.();
+    host.writeStatuslineFile?.();
+    return { sessionId, backendSessionId: selectedBackendSessionId };
 }
 export function startHeartbeat(host) {
     host.runtimeSync.startHeartbeat();
 }
-export function handleSessionClaimed(host, sessionId) {
-    const session = host.sessions.find((s) => s.id === sessionId);
-    if (!session)
-        return;
-    host.debug?.(`session ${sessionId} was claimed by another instance, killing local PTY`, "instance");
-    session.kill();
-    const idx = host.sessions.indexOf(session);
-    if (idx >= 0) {
-        host.sessions.splice(idx, 1);
-        host.sessionToolKeys.delete(sessionId);
-        host.sessionOriginalArgs.delete(sessionId);
-        host.sessionWorktreePaths.delete(sessionId);
-        host.sessionTmuxTargets.delete(sessionId);
-    }
-    if (host.activeIndex >= host.sessions.length) {
-        host.activeIndex = Math.max(0, host.sessions.length - 1);
-    }
-    host.renderDashboard();
-}
 export function stopHeartbeat(host) {
     host.runtimeSync.stopHeartbeat();
 }
@@ -526,40 +496,6 @@ export function startProjectServiceRefresh(host) {
 export function stopProjectServiceRefresh(host) {
     host.runtimeSync.stopProjectServiceRefresh();
 }
-export function getRemoteInstancesSafe(host) {
-    return host.instanceDirectory.getRemoteInstancesSafe(host.instanceId, process.cwd());
-}
-export function getRemoteOwnedSessionKeys(host) {
-    return host.instanceDirectory.getRemoteOwnedSessionKeys(host.instanceId, process.cwd());
-}
-export function getInstanceSessionRefs(host) {
-    return host.sessions.map((s) => ({
-        id: s.id,
-        tool: s.command,
-        backendSessionId: s.backendSessionId,
-        worktreePath: host.sessionWorktreePaths.get(s.id),
-    }));
-}
-export function writeSessionsFile(host) {
-    const dir = getLocalAimuxDir();
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const localSessions = host.sessions.map((s) => ({
-        id: s.id,
-        tool: s.command,
-        backendSessionId: s.backendSessionId,
-        worktreePath: host.sessionWorktreePaths.get(s.id),
-    }));
-    const data = host.instanceDirectory.buildSessionsFileEntries(localSessions, host.instanceDirectory.getRemoteInstancesSafe(host.instanceId, process.cwd()));
-    writeFileSync(`${dir}/sessions.json`, JSON.stringify(data, null, 2) + "\n");
-}
-export function removeSessionsFile() {
-    try {
-        unlinkSync(`${getLocalAimuxDir()}/sessions.json`);
-    }
-    catch { }
-}
 export function listDesktopWorktrees(_host) {
     return listAllWorktrees().filter((wt) => !wt.isBare && !isToolInternalWorktree(wt));
 }
-//# sourceMappingURL=runtime-state.js.map

package/dist/multiplexer/runtime-sync.d.ts

@@ -1,22 +1,14 @@
-import type { InstanceDirectory } from "../instance-directory.js";
-import type { InstanceSessionRef } from "../instance-registry.js";
 export declare class MultiplexerRuntimeSync {
     private readonly deps;
     private heartbeatInterval;
     private projectServiceInterval;
     constructor(deps: {
-        instanceDirectory: InstanceDirectory;
-        instanceId: string;
         cwd: string;
         getMode: () => "dashboard" | "project-service";
-        getConfirmedRegistered: () => Set<string>;
-        setConfirmedRegistered: (value: Set<string>) => void;
-        getInstanceSessionRefs: () => InstanceSessionRef[];
-        syncSessionsFromState: () => void;
-        loadOfflineSessions: () => boolean;
+        syncSessionsFromTopology: () => void;
+        loadOfflineTopologySessions: () => boolean;
         renderCurrentDashboardView: () => void;
         renderDashboard: () => void;
-        handleSessionClaimed: (sessionId: string) => void;
         writeStatuslineFile: () => void;
     });
     startHeartbeat(): void;

package/dist/multiplexer/runtime-sync.js

@@ -10,25 +10,10 @@ export class MultiplexerRuntimeSync {
             return;
         this.heartbeatInterval = setInterval(() => {
             if (this.deps.getMode() === "project-service") {
-                this.deps.syncSessionsFromState();
+                this.deps.syncSessionsFromTopology();
                 return;
             }
-            let dashboardNeedsRender = false;
-            const sessions = this.deps.getInstanceSessionRefs();
-            this.deps.instanceDirectory
-                .reconcileHeartbeat(this.deps.instanceId, sessions, this.deps.cwd, this.deps.getConfirmedRegistered())
-                .then((result) => {
-                for (const id of result.claimedIds) {
-                    this.deps.handleSessionClaimed(id);
-                    dashboardNeedsRender = true;
-                }
-                this.deps.setConfirmedRegistered(result.confirmedIds);
-                if (dashboardNeedsRender && this.deps.getMode() === "dashboard") {
-                    this.deps.renderCurrentDashboardView();
-                }
-            })
-                .catch(() => { });
-            const offlineChanged = this.deps.loadOfflineSessions();
+            const offlineChanged = this.deps.loadOfflineTopologySessions();
             if (offlineChanged && this.deps.getMode() === "dashboard") {
                 this.deps.renderCurrentDashboardView();
             }
@@ -44,7 +29,7 @@ export class MultiplexerRuntimeSync {
         if (this.projectServiceInterval)
             return;
         this.projectServiceInterval = setInterval(() => {
-            this.deps.syncSessionsFromState();
+            this.deps.syncSessionsFromTopology();
         }, 2000);
     }
     stopProjectServiceRefresh() {
@@ -54,4 +39,3 @@ export class MultiplexerRuntimeSync {
         }
     }
 }
-//# sourceMappingURL=runtime-sync.js.map

package/dist/multiplexer/service-state-snapshot.d.ts

@@ -1,14 +1,12 @@
 import type { TmuxRuntimeManager } from "../tmux/runtime-manager.js";
-import type { SavedState, ServiceState, SessionState } from "./index.js";
+import type { SavedState, ServiceState } from "./index.js";
 export declare function mergeRuntimeSnapshots(state: SavedState | null, snapshots: {
-    sessions?: SessionState[];
     services?: ServiceState[];
 }, cwd: string, savedAt?: string): SavedState;
 export declare function mergeServiceSnapshots(state: SavedState | null, snapshots: ServiceState[], cwd: string, savedAt?: string): SavedState;
-export declare function snapshotProjectAgentWindows(projectRoot: string, tmux: TmuxRuntimeManager): SessionState[];
 export declare function snapshotProjectServiceWindows(projectRoot: string, tmux: TmuxRuntimeManager): ServiceState[];
 export declare function persistProjectRuntimeSnapshotsBeforeTmuxStop(projectRoot: string, tmux: TmuxRuntimeManager): {
-    sessions: SessionState[];
+    sessions: [];
     services: ServiceState[];
 };
 export declare function persistProjectServiceSnapshotsBeforeRuntimeStop(projectRoot: string, tmux: TmuxRuntimeManager): ServiceState[];

package/dist/multiplexer/service-state-snapshot.js

@@ -2,13 +2,6 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { getStatePath } from "../paths.js";
 import { buildServiceStateFromMetadata } from "./services.js";
 import { listWorktreeGraveyardPaths } from "./worktree-graveyard.js";
-function sessionStateKey(session) {
-    return session.backendSessionId ? `backend:${session.backendSessionId}` : `id:${session.id}`;
-}
-function sanitizeSnapshotSession(session) {
-    const { tmuxTarget: _tmuxTarget, ...rest } = session;
-    return { ...rest, lifecycle: "offline" };
-}
 function isAvailableSnapshotWorktree(worktreePath, graveyardPaths = listWorktreeGraveyardPaths()) {
     if (!worktreePath)
         return true;
@@ -17,14 +10,6 @@ function isAvailableSnapshotWorktree(worktreePath, graveyardPaths = listWorktree
     return existsSync(worktreePath);
 }
 export function mergeRuntimeSnapshots(state, snapshots, cwd, savedAt = new Date().toISOString()) {
-    const sessionByKey = new Map();
-    for (const session of state?.sessions ?? []) {
-        sessionByKey.set(sessionStateKey(session), session);
-    }
-    for (const session of snapshots.sessions ?? []) {
-        const offline = sanitizeSnapshotSession(session);
-        sessionByKey.set(sessionStateKey(offline), offline);
-    }
     const byId = new Map();
     for (const service of state?.services ?? []) {
         byId.set(service.id, service);
@@ -39,43 +24,12 @@ export function mergeRuntimeSnapshots(state, snapshots, cwd, savedAt = new Date(
     return {
         savedAt,
         cwd: state?.cwd ?? cwd,
-        sessions: [...sessionByKey.values()],
         services: [...byId.values()],
     };
 }
 export function mergeServiceSnapshots(state, snapshots, cwd, savedAt = new Date().toISOString()) {
     return mergeRuntimeSnapshots(state, { services: snapshots }, cwd, savedAt);
 }
-export function snapshotProjectAgentWindows(projectRoot, tmux) {
-    const seen = new Set();
-    const graveyardPaths = listWorktreeGraveyardPaths();
-    const snapshots = [];
-    for (const { target, metadata } of tmux.listProjectManagedWindows(projectRoot)) {
-        if (metadata.kind !== "agent")
-            continue;
-        if (seen.has(metadata.sessionId))
-            continue;
-        if (!isAvailableSnapshotWorktree(metadata.worktreePath, graveyardPaths))
-            continue;
-        if (tmux.isWindowAlive && !tmux.isWindowAlive(target))
-            continue;
-        seen.add(metadata.sessionId);
-        snapshots.push({
-            id: metadata.sessionId,
-            tool: metadata.command,
-            toolConfigKey: metadata.toolConfigKey ?? metadata.command,
-            command: metadata.command,
-            args: metadata.args ?? [],
-            lifecycle: "offline",
-            createdAt: metadata.createdAt,
-            backendSessionId: metadata.backendSessionId,
-            worktreePath: metadata.worktreePath,
-            label: metadata.label,
-            headline: metadata.statusText,
-        });
-    }
-    return snapshots;
-}
 export function snapshotProjectServiceWindows(projectRoot, tmux) {
     const seen = new Set();
     const graveyardPaths = listWorktreeGraveyardPaths();
@@ -97,10 +51,9 @@ export function snapshotProjectServiceWindows(projectRoot, tmux) {
     return snapshots;
 }
 export function persistProjectRuntimeSnapshotsBeforeTmuxStop(projectRoot, tmux) {
-    const sessions = snapshotProjectAgentWindows(projectRoot, tmux);
     const services = snapshotProjectServiceWindows(projectRoot, tmux);
-    if (sessions.length === 0 && services.length === 0)
-        return { sessions, services };
+    if (services.length === 0)
+        return { sessions: [], services };
     const statePath = getStatePath();
     let existing = null;
     if (existsSync(statePath)) {
@@ -111,11 +64,10 @@ export function persistProjectRuntimeSnapshotsBeforeTmuxStop(projectRoot, tmux)
             existing = null;
         }
     }
-    const nextState = mergeRuntimeSnapshots(existing, { sessions, services }, projectRoot);
+    const nextState = mergeRuntimeSnapshots(existing, { services }, projectRoot);
     writeFileSync(statePath, JSON.stringify(nextState, null, 2) + "\n");
-    return { sessions, services };
+    return { sessions: [], services };
 }
 export function persistProjectServiceSnapshotsBeforeRuntimeStop(projectRoot, tmux) {
     return persistProjectRuntimeSnapshotsBeforeTmuxStop(projectRoot, tmux).services;
 }
-//# sourceMappingURL=service-state-snapshot.js.map

package/dist/multiplexer/services.d.ts

@@ -11,6 +11,7 @@ export declare function buildServiceStateFromMetadata(serviceId: string, metadat
     createdAt?: string;
     worktreePath?: string;
     label?: string;
+    launchCommandLine?: string;
 }, opts?: {
     cwd?: string;
     tmuxTarget?: ServiceState["tmuxTarget"];