aimux-cli 0.1.16 → 0.1.19

package/dist/multiplexer/dashboard-tail-methods.js

@@ -1,29 +1,181 @@
-import { debug } from "../debug.js";
-import { forkAgent as forkAgentImpl, migrateAgentSession as migrateAgentSessionImpl, renameAgent as renameAgentImpl, sendAgentToGraveyard as sendAgentToGraveyardImpl, spawnAgent as spawnAgentImpl, stopAgent as stopAgentImpl, } from "./session-actions.js";
 import { buildPlanPreview as buildPlanPreviewImpl, handleGraveyardKey as handleGraveyardKeyImpl, handlePlansKey as handlePlansKeyImpl, loadPlanEntries as loadPlanEntriesImpl, openPlanInEditor as openPlanInEditorImpl, parsePlanFrontmatter as parsePlanFrontmatterImpl, renderGraveyard as renderGraveyardImpl, renderGraveyardDetailsForHost as renderGraveyardDetailsForHostImpl, renderPlanDetailsForHost as renderPlanDetailsForHostImpl, renderPlans as renderPlansImpl, resurrectGraveyardEntry as resurrectGraveyardEntryImpl, showGraveyard as showGraveyardImpl, showPlans as showPlansImpl, } from "./archives.js";
 import { confirmSwitcher as confirmSwitcherImpl, dismissHelp as dismissHelpImpl, dismissSwitcher as dismissSwitcherImpl, getSwitcherList as getSwitcherListImpl, handleHelpKey as handleHelpKeyImpl, handleMigratePickerKey as handleMigratePickerKeyImpl, handleSwitcherKey as handleSwitcherKeyImpl, redrawCurrentView as redrawCurrentViewImpl, renderHelp as renderHelpImpl, renderMigratePicker as renderMigratePickerImpl, renderSwitcher as renderSwitcherImpl, resetSwitcherTimeout as resetSwitcherTimeoutImpl, showHelp as showHelpImpl, showMigratePicker as showMigratePickerImpl, showSwitcher as showSwitcherImpl, } from "./navigation.js";
-import { basenameForHost, clearDashboardSubscreens as clearDashboardSubscreensImpl, composeSplitScreen as composeSplitScreenImpl, composeTwoPaneLines as composeTwoPaneLinesImpl, createDashboardServiceWithFeedback as createDashboardServiceWithFeedbackImpl, dashboardSessionActionDeps as dashboardSessionActionDepsImpl, graveyardSessionWithFeedback as graveyardSessionWithFeedbackImpl, migrateSessionWithFeedback as migrateSessionWithFeedbackImpl, removeDashboardServiceWithFeedback as removeDashboardServiceWithFeedbackImpl, renderSessionDetails as renderSessionDetailsImpl, resumeOfflineServiceWithFeedback as resumeOfflineServiceWithFeedbackImpl, resumeOfflineSessionWithFeedback as resumeOfflineSessionWithFeedbackImpl, runDashboardOperation as runDashboardOperationImpl, setPendingDashboardSessionAction as setPendingDashboardSessionActionImpl, stopDashboardServiceWithFeedback as stopDashboardServiceWithFeedbackImpl, stopSessionToOfflineWithFeedback as stopSessionToOfflineWithFeedbackImpl, takeoverFromDashEntryWithFeedback as takeoverFromDashEntryWithFeedbackImpl, truncateAnsiForHost, truncatePlainForHost, waitForSessionStartForHost, wrapKeyValueForHost, wrapTextForHost, } from "./dashboard-ops.js";
+import { basenameForHost, clearDashboardSubscreens as clearDashboardSubscreensImpl, composeSplitScreen as composeSplitScreenImpl, composeTwoPaneLines as composeTwoPaneLinesImpl, createDashboardServiceWithFeedback as createDashboardServiceWithFeedbackImpl, dashboardSessionActionDeps as dashboardSessionActionDepsImpl, graveyardSessionWithFeedback as graveyardSessionWithFeedbackImpl, migrateSessionWithFeedback as migrateSessionWithFeedbackImpl, removeDashboardServiceWithFeedback as removeDashboardServiceWithFeedbackImpl, renderSessionDetails as renderSessionDetailsImpl, resumeOfflineServiceWithFeedback as resumeOfflineServiceWithFeedbackImpl, resumeOfflineSessionWithFeedback as resumeOfflineSessionWithFeedbackImpl, runDashboardOperation as runDashboardOperationImpl, setPendingDashboardServiceAction as setPendingDashboardServiceActionImpl, setPendingDashboardSessionAction as setPendingDashboardSessionActionImpl, stopDashboardServiceWithFeedback as stopDashboardServiceWithFeedbackImpl, stopSessionToOfflineWithFeedback as stopSessionToOfflineWithFeedbackImpl, truncateAnsiForHost, truncatePlainForHost, waitForSessionStartForHost, wrapKeyValueForHost, wrapTextForHost, } from "./dashboard-ops.js";
 import { findMainRepo, listWorktrees as listAllWorktrees } from "../worktree.js";
 import { orderDashboardSessionsByVisualWorktree } from "../dashboard/session-registry.js";
 import { loadConfig } from "../config.js";
+import { listTopologySessionStates, moveTopologySessionToGraveyard, upsertTopologySession, } from "../runtime-core/topology-sessions.js";
+function isLiveTopologyStatus(status) {
+    return status === "running" || status === "idle" || status === "starting";
+}
+function runtimeToTopologySessionState(host, session) {
+    return {
+        id: session.id,
+        tool: session.command,
+        toolConfigKey: host.sessionToolKeys?.get?.(session.id) ?? session.command,
+        command: session.command,
+        args: host.sessionOriginalArgs?.get?.(session.id) ?? [],
+        lifecycle: "offline",
+        createdAt: session.startTime ? new Date(session.startTime).toISOString() : undefined,
+        backendSessionId: session.backendSessionId,
+        team: session.team,
+        worktreePath: host.sessionWorktreePaths?.get?.(session.id),
+        label: host.getSessionLabel?.(session.id),
+        headline: host.deriveHeadline?.(session.id),
+    };
+}
+function cacheOfflineSession(host, entry) {
+    const cache = host.offlineSessions;
+    if (!Array.isArray(cache))
+        return;
+    const offlineEntry = { ...entry, lifecycle: "offline", status: "offline" };
+    const existingIndex = cache.findIndex((session) => session.id === entry.id);
+    if (existingIndex >= 0) {
+        cache[existingIndex] = { ...cache[existingIndex], ...offlineEntry };
+    }
+    else {
+        cache.push(offlineEntry);
+    }
+}
+function removeOfflineSessionCache(host, sessionId) {
+    if (!Array.isArray(host.offlineSessions))
+        return;
+    host.offlineSessions = host.offlineSessions.filter((session) => session.id !== sessionId);
+}
+function findTopologySession(sessionId) {
+    return listTopologySessionStates({ statuses: ["running", "idle", "starting", "offline", "graveyard"] }).find((session) => session.id === sessionId);
+}
+function refreshLifecycleViews(host) {
+    host.invalidateDesktopStateSnapshot?.();
+    host.writeStatuslineFile?.();
+    if (host.mode === "dashboard") {
+        host.renderCurrentDashboardView?.();
+    }
+    host.updateContextWatcherSessions?.();
+}
 export const dashboardTailMethods = {
     async forkAgent(opts) {
-        return forkAgentImpl(this, opts);
+        const result = await this.forkSessionFromSource(opts.sourceSessionId, opts.targetToolConfigKey, opts.targetSessionId, opts.instruction, opts.targetWorktreePath, opts.extraArgs ?? []);
+        if (!result) {
+            throw new Error(`Unable to fork agent "${opts.sourceSessionId}"`);
+        }
+        if (opts.open) {
+            this.openLiveTmuxWindowForEntry({ id: result.sessionId });
+        }
+        return { sessionId: result.sessionId, threadId: result.threadId };
     },
     async spawnAgent(opts) {
-        return spawnAgentImpl(this, opts);
+        const config = loadConfig();
+        const tool = config.tools[opts.toolConfigKey];
+        if (!tool) {
+            throw new Error(`Unknown tool config: ${opts.toolConfigKey}`);
+        }
+        const sessionId = opts.targetSessionId ?? this.generateDashboardSessionId?.(tool.command);
+        const transport = this.createSession(tool.command, [...tool.args, ...(opts.extraArgs ?? [])], tool.preambleFlag, opts.toolConfigKey, undefined, tool.sessionIdFlag, opts.targetWorktreePath, undefined, sessionId, !opts.open);
+        if (opts.open) {
+            this.openLiveTmuxWindowForEntry({ id: transport.id });
+        }
+        return { sessionId: transport.id };
+    },
+    async createTeammateAgent(opts) {
+        const config = loadConfig();
+        const toolConfigKey = opts.toolConfigKey ?? config.defaultTool;
+        const tool = config.tools[toolConfigKey];
+        if (!tool) {
+            throw new Error(`Unknown tool config: ${toolConfigKey}`);
+        }
+        const sessionId = opts.targetSessionId ?? this.generateDashboardSessionId?.(tool.command);
+        const team = {
+            teamId: `team-${opts.parentSessionId}`,
+            parentSessionId: opts.parentSessionId,
+            role: opts.role,
+            label: opts.label,
+            order: typeof opts.order === "number" ? opts.order : undefined,
+        };
+        const transport = this.createSession(tool.command, [...tool.args, ...(opts.extraArgs ?? [])], tool.preambleFlag, toolConfigKey, undefined, tool.sessionIdFlag, opts.targetWorktreePath, undefined, sessionId, !opts.open, false, team);
+        if (opts.label) {
+            this.applySessionLabel(transport.id, opts.label);
+        }
+        if (opts.open) {
+            this.openLiveTmuxWindowForEntry({ id: transport.id });
+        }
+        return {
+            sessionId: transport.id,
+            parentSessionId: opts.parentSessionId,
+            teamId: team.teamId,
+            role: opts.role,
+            label: opts.label,
+        };
     },
     async renameAgent(sessionId, label) {
-        return renameAgentImpl(this, sessionId, label);
+        await this.updateSessionLabel(sessionId, label);
+        return { sessionId, label: label?.trim() || undefined };
     },
     async stopAgent(sessionId) {
-        return stopAgentImpl(this, sessionId);
+        const runtime = this.sessions?.find?.((session) => session.id === sessionId);
+        if (runtime) {
+            if (this.graveyardAfterStopSessionIds?.has?.(sessionId)) {
+                throw new Error(`Session "${sessionId}" is being sent to graveyard`);
+            }
+            if (this.stoppingSessionIds?.has?.(sessionId)) {
+                return { sessionId, status: "offline" };
+            }
+            const offlineEntry = runtimeToTopologySessionState(this, runtime);
+            upsertTopologySession(offlineEntry, "offline");
+            cacheOfflineSession(this, offlineEntry);
+            this.stoppingSessionIds?.add?.(sessionId);
+            this.startedInDashboard = true;
+            runtime.kill();
+            refreshLifecycleViews(this);
+            this.debug?.(`stopped session ${sessionId} -> offline`, "session");
+            return { sessionId, status: "offline" };
+        }
+        const existing = findTopologySession(sessionId);
+        if (existing?.status === "offline") {
+            cacheOfflineSession(this, existing);
+            return { sessionId, status: "offline" };
+        }
+        if (existing && isLiveTopologyStatus(existing.status)) {
+            throw new Error(`Session "${sessionId}" is live but not owned by this runtime`);
+        }
+        if (existing?.status === "graveyard") {
+            throw new Error(`Session "${sessionId}" is already in graveyard`);
+        }
+        throw new Error(`Unknown session "${sessionId}"`);
     },
     async sendAgentToGraveyard(sessionId) {
-        return sendAgentToGraveyardImpl(this, sessionId);
+        const runtime = this.sessions?.find?.((session) => session.id === sessionId);
+        const existing = findTopologySession(sessionId);
+        const previousStatus = runtime || isLiveTopologyStatus(existing?.status) ? "running" : "offline";
+        if (existing?.status === "graveyard") {
+            return { sessionId, status: "graveyard", previousStatus };
+        }
+        if (!runtime && existing && isLiveTopologyStatus(existing.status)) {
+            throw new Error(`Session "${sessionId}" is live but not owned by this runtime`);
+        }
+        if (runtime && !existing) {
+            upsertTopologySession(runtimeToTopologySessionState(this, runtime), "running");
+        }
+        else if (!runtime && !existing) {
+            throw new Error(`Unknown session "${sessionId}"`);
+        }
+        const moved = moveTopologySessionToGraveyard(sessionId);
+        if (!moved) {
+            throw new Error(`Unable to graveyard session "${sessionId}"`);
+        }
+        removeOfflineSessionCache(this, sessionId);
+        if (runtime) {
+            this.graveyardAfterStopSessionIds?.add?.(sessionId);
+            this.stoppingSessionIds?.add?.(sessionId);
+            runtime.kill();
+        }
+        refreshLifecycleViews(this);
+        this.debug?.(`graveyarded session ${sessionId}`, "session");
+        return { sessionId, status: "graveyard", previousStatus };
     },
     async migrateAgentSession(sessionId, targetWorktreePath) {
-        return migrateAgentSessionImpl(this, sessionId, targetWorktreePath);
+        await this.migrateAgent(sessionId, targetWorktreePath);
+        return { sessionId, worktreePath: targetWorktreePath };
     },
     showGraveyard() {
         showGraveyardImpl(this);
@@ -112,6 +264,9 @@ export const dashboardTailMethods = {
     setPendingDashboardSessionAction(sessionId, kind, opts) {
         setPendingDashboardSessionActionImpl(this, sessionId, kind, opts);
     },
+    setPendingDashboardServiceAction(serviceId, kind, opts) {
+        setPendingDashboardServiceActionImpl(this, serviceId, kind, opts);
+    },
     async stopSessionToOfflineWithFeedback(session) {
         await stopSessionToOfflineWithFeedbackImpl(this, session);
     },
@@ -169,9 +324,6 @@ export const dashboardTailMethods = {
     dashboardSessionActionDeps() {
         return dashboardSessionActionDepsImpl(this);
     },
-    async takeoverFromDashEntryWithFeedback(entry) {
-        await takeoverFromDashEntryWithFeedbackImpl(this, entry);
-    },
     async migrateSessionWithFeedback(session, targetPath, targetName) {
         await migrateSessionWithFeedbackImpl(this, session, targetPath, targetName);
     },
@@ -225,40 +377,4 @@ export const dashboardTailMethods = {
         }
         return orderDashboardSessionsByVisualWorktree(allDash, worktreePaths, mainRepoPath);
     },
-    async takeoverSessionFromDashEntry(entry) {
-        if (!entry.remoteInstanceId || !entry.remoteBackendSessionId)
-            return;
-        await this.takeoverSession({
-            id: entry.id,
-            tool: entry.command,
-            backendSessionId: entry.remoteBackendSessionId,
-            fromInstanceId: entry.remoteInstanceId,
-        });
-    },
-    async takeoverSession(target) {
-        const mux = this;
-        const claimed = await mux.instanceDirectory.claimSession(target.id, target.fromInstanceId, process.cwd());
-        if (!claimed) {
-            debug(`takeover: session ${target.id} not found in instance ${target.fromInstanceId}`, "instance");
-            return;
-        }
-        const config = loadConfig();
-        const toolEntry = Object.entries(config.tools).find(([, t]) => t.command === target.tool);
-        const toolCfg = toolEntry?.[1];
-        const toolConfigKey = toolEntry?.[0];
-        if (!toolCfg?.resumeArgs) {
-            debug(`takeover: no resumeArgs configured for tool ${target.tool}`, "instance");
-            return;
-        }
-        if (!mux.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, target.backendSessionId)) {
-            debug(`takeover: tool ${target.tool} does not support backendSessionId resume`, "instance");
-            return;
-        }
-        const resumeArgs = toolCfg.resumeArgs.map((a) => a.replace("{sessionId}", target.backendSessionId));
-        const args = mux.sessionBootstrap.composeToolArgs(toolCfg, resumeArgs);
-        debug(`taking over session ${target.id} (backend=${target.backendSessionId}) from instance ${target.fromInstanceId}`, "instance");
-        this.createSession(target.tool, args, toolCfg.preambleFlag, toolConfigKey, undefined, undefined, claimed.worktreePath, target.backendSessionId, undefined, false, true);
-        this.renderDashboard();
-    },
 };
-//# sourceMappingURL=dashboard-tail-methods.js.map

package/dist/multiplexer/dashboard-view-methods.d.ts

@@ -1,7 +1,7 @@
 export declare const dashboardViewMethods: {
     serviceLabelForCommand(this: any, commandLine: string): string;
     generateDashboardSessionId(this: any, command: string): string;
-    settleDashboardCreatePending(this: any, itemId: string): void;
+    settleDashboardCreatePending(this: any, itemId: string, target?: "session" | "service" | "worktree"): void;
     preferDashboardEntrySelection(this: any, kind: "session" | "service", id: string, worktreePath?: string): void;
     createService(this: any, commandLine: string, worktreePath?: string, opts?: {
         serviceId?: string;

package/dist/multiplexer/dashboard-view-methods.js

@@ -2,6 +2,7 @@ import { closeNotificationPanel as closeNotificationPanelImpl, handleNotificatio
 import { beginWorktreeRemoval as beginWorktreeRemovalImpl, finishWorktreeRemoval as finishWorktreeRemovalImpl, handleWorktreeInputKey as handleWorktreeInputKeyImpl, handleWorktreeRemoveConfirmKey as handleWorktreeRemoveConfirmKeyImpl, handleWorktreeListKey as handleWorktreeListKeyImpl, renderWorktreeInput as renderWorktreeInputImpl, renderWorktreeList as renderWorktreeListImpl, renderWorktreeRemoveConfirm as renderWorktreeRemoveConfirmImpl, showWorktreeCreatePrompt as showWorktreeCreatePromptImpl, showWorktreeList as showWorktreeListImpl, } from "./worktrees.js";
 import { createService as createServiceImpl, removeOfflineService as removeOfflineServiceImpl, resumeOfflineService as resumeOfflineServiceImpl, resumeOfflineServiceById as resumeOfflineServiceByIdImpl, serviceLabelForCommand as serviceLabelForCommandImpl, stopService as stopServiceImpl, } from "./services.js";
 import { derivedStatusLabel } from "../dashboard/index.js";
+import { selectDashboardTeammates } from "../dashboard/session-registry.js";
 import { hasRuntimeEvidence, isAttachableDashboardSessionEntry } from "../dashboard/runtime-evidence.js";
 export const dashboardViewMethods = {
     serviceLabelForCommand(commandLine) {
@@ -10,29 +11,38 @@ export const dashboardViewMethods = {
     generateDashboardSessionId(command) {
         return `${command}-${Math.random().toString(36).slice(2, 8)}`;
     },
-    settleDashboardCreatePending(itemId) {
+    settleDashboardCreatePending(itemId, target) {
         if (!(this.startedInDashboard && this.mode === "dashboard"))
             return;
-        this.dashboardPendingActions.settleCreatePending(itemId, () => {
+        const pendingTarget = target ??
+            (itemId.startsWith("worktree:")
+                ? "worktree"
+                : this.getDashboardSessions?.().some((entry) => entry.id === itemId)
+                    ? "session"
+                    : "service");
+        this.dashboardPendingActions.settleCreatePending(pendingTarget, itemId, () => {
             this.refreshLocalDashboardModel();
             this.renderDashboard();
         }, {
-            timeoutMs: itemId.startsWith("worktree:") ? 180_000 : undefined,
+            timeoutMs: pendingTarget === "worktree" ? 180_000 : undefined,
             isSettled: async () => {
                 if (typeof this.refreshDashboardModelFromService === "function") {
                     await this.refreshDashboardModelFromService(true);
                 }
-                if (itemId.startsWith("worktree:")) {
-                    const path = itemId.slice("worktree:".length);
+                if (pendingTarget === "worktree") {
+                    const path = itemId.startsWith("worktree:") ? itemId.slice("worktree:".length) : itemId;
                     const rawWorktree = this.listDesktopWorktrees?.().find((entry) => entry.path === path);
                     if (rawWorktree && rawWorktree.pending !== true && rawWorktree.pendingAction !== "creating")
                         return true;
                     const group = this.dashboardWorktreeGroupsCache?.find((entry) => entry.path === path);
                     return Boolean(group) && group.pendingAction !== "creating" && group.pending !== true;
                 }
-                const service = this.getDashboardServices?.().find((entry) => entry.id === itemId);
-                if (service)
-                    return service.pendingAction !== "creating" || hasRuntimeEvidence(service);
+                if (pendingTarget === "service") {
+                    const service = this.getDashboardServices?.().find((entry) => entry.id === itemId);
+                    if (service)
+                        return service.pendingAction !== "creating" || hasRuntimeEvidence(service);
+                    return false;
+                }
                 const session = this.getDashboardSessions?.().find((entry) => entry.id === itemId);
                 return isAttachableDashboardSessionEntry(session);
             },
@@ -72,6 +82,7 @@ export const dashboardViewMethods = {
                 }
                 : this.getViewportSize();
             const dashSessions = this.dashboardSessionsCache;
+            const dashTeammates = this.dashboardTeammatesCache ?? [];
             const dashServices = this.dashboardServicesCache;
             const worktreeGroups = this.dashboardWorktreeGroupsCache;
             const mainCheckoutInfo = this.dashboardMainCheckoutInfoCache;
@@ -88,6 +99,9 @@ export const dashboardViewMethods = {
             else if (!hasWorktrees && dashSessions.length > 0) {
                 selectedSession = dashSessions[this.activeIndex]?.id;
             }
+            const selectedSessionEntry = selectedSession
+                ? dashSessions.find((session) => session.id === selectedSession)
+                : undefined;
             this.dashboard.update({
                 sessions: dashSessions,
                 services: dashServices,
@@ -97,6 +111,7 @@ export const dashboardViewMethods = {
                 navLevel: hasWorktrees ? this.dashboardState.level : "sessions",
                 selectedSessionId: selectedSession,
                 selectedServiceId: selectedService,
+                selectedTeammates: selectDashboardTeammates(dashTeammates, selectedSessionEntry),
                 runtimeLabel: "tmux",
                 mainCheckout: mainCheckoutInfo,
                 operationFailures: this.dashboardOperationFailuresCache ?? [],
@@ -199,4 +214,3 @@ export const dashboardViewMethods = {
         handleWorktreeListKeyImpl(this, data);
     },
 };
-//# sourceMappingURL=dashboard-view-methods.js.map

package/dist/multiplexer/graveyard-view-model.d.ts

@@ -54,7 +54,13 @@ export type GraveyardStandaloneAgentRow = {
     actionNumber: number;
     lastUsedAt?: string;
 };
-export type GraveyardViewRow = GraveyardSectionRow | GraveyardAgentWorktreeRow | GraveyardWorktreeRow | GraveyardAttachedAgentRow | GraveyardAttachedServiceRow | GraveyardAttachedMoreRow | GraveyardStandaloneAgentRow;
+export type GraveyardOrphanTeammateRow = {
+    kind: "orphan-teammate";
+    entry: SessionState;
+    parentSessionId: string;
+    lastUsedAt?: string;
+};
+export type GraveyardViewRow = GraveyardSectionRow | GraveyardAgentWorktreeRow | GraveyardWorktreeRow | GraveyardAttachedAgentRow | GraveyardAttachedServiceRow | GraveyardAttachedMoreRow | GraveyardStandaloneAgentRow | GraveyardOrphanTeammateRow;
 export type GraveyardSelectableRow = GraveyardWorktreeRow | GraveyardStandaloneAgentRow;
 export interface GraveyardViewModel {
     rows: GraveyardViewRow[];
@@ -63,6 +69,8 @@ export interface GraveyardViewModel {
 export interface BuildGraveyardViewModelInput {
     worktrees: WorktreeGraveyardEntry[];
     agents: SessionState[];
+    parentSessions?: SessionState[];
+    teammates?: SessionState[];
     lastUsedById?: Record<string, LastUsedEntry | undefined>;
 }
 export declare function buildGraveyardViewModel(input: BuildGraveyardViewModelInput): GraveyardViewModel;

package/dist/multiplexer/graveyard-view-model.js

@@ -1,10 +1,12 @@
 import { basename } from "node:path";
 import { parseRecencyTimestamp } from "../recency.js";
+import { isTeammateSession, selectOrphanTeammates } from "../team.js";
 export const MAX_VISIBLE_ATTACHED_AGENTS_PER_WORKTREE = 5;
 export function buildGraveyardViewModel(input) {
     const rows = [];
     const selectableRows = [];
     const flatAgentsClaimedByWorktree = new Set();
+    const renderedAgentIds = new Set();
     const addSelectable = (row) => {
         const actionIndex = selectableRows.length;
         const withAction = { ...row, actionIndex, actionNumber: actionIndex + 1 };
@@ -34,6 +36,9 @@ export function buildGraveyardViewModel(input) {
                 sortAt: worktreeSortTimestamp(worktree, attachedAgents, attachedServices),
             });
             rows.push(worktreeRow);
+            for (const agent of attachedAgents) {
+                renderedAgentIds.add(agent.entry.id);
+            }
             for (const agent of visibleAttachedAgents) {
                 rows.push({ kind: "attached-agent-display", parentPath: worktree.path, agent });
             }
@@ -61,6 +66,7 @@ export function buildGraveyardViewModel(input) {
                     entry: agent,
                     lastUsedAt: input.lastUsedById?.[agent.id]?.lastUsedAt,
                 }));
+                renderedAgentIds.add(agent.id);
             }
         }
     }
@@ -73,10 +79,43 @@ export function buildGraveyardViewModel(input) {
                 entry: agent,
                 lastUsedAt: input.lastUsedById?.[agent.id]?.lastUsedAt,
             }));
+            renderedAgentIds.add(agent.id);
+        }
+    }
+    const orphanTeammates = selectOrphanTeammates(input.teammates ?? [], collectKnownParentIds(input)).filter((session) => !renderedAgentIds.has(session.id) && !input.agents.some((agent) => agent.id === session.id));
+    if (orphanTeammates.length > 0) {
+        rows.push({ kind: "section", label: "Orphaned Teammates" });
+        for (const teammate of orphanTeammates) {
+            const parentSessionId = teammate.team?.parentSessionId;
+            if (!parentSessionId)
+                continue;
+            rows.push({
+                kind: "orphan-teammate",
+                entry: teammate,
+                parentSessionId,
+                lastUsedAt: input.lastUsedById?.[teammate.id]?.lastUsedAt,
+            });
         }
     }
     return { rows, selectableRows };
 }
+function collectKnownParentIds(input) {
+    const ids = new Set();
+    const add = (session) => {
+        if (!session || isTeammateSession(session))
+            return;
+        ids.add(session.id);
+    };
+    for (const session of input.parentSessions ?? [])
+        add(session);
+    for (const agent of input.agents)
+        add(agent);
+    for (const worktree of input.worktrees) {
+        for (const agent of worktree.agents ?? [])
+            add(agent);
+    }
+    return ids;
+}
 function sortWorktrees(worktrees, flatAgents, lastUsedById) {
     const sortMsByPath = new Map();
     for (const worktree of worktrees) {
@@ -182,4 +221,3 @@ function compareRecencyOrCreated(left, leftLastUsedAt, right, rightLastUsedAt) {
     const rightCreated = parseRecencyTimestamp(right.createdAt) ?? 0;
     return rightCreated - leftCreated || left.id.localeCompare(right.id);
 }
-//# sourceMappingURL=graveyard-view-model.js.map

package/dist/multiplexer/index.d.ts

@@ -1,5 +1,6 @@
 import { SessionRuntime, type SessionTransport } from "../session-runtime.js";
 import { type TmuxTarget } from "../tmux/runtime-manager.js";
+import type { SessionTeamMetadata } from "../team.js";
 import { type DashboardActionMethods } from "./dashboard-actions-methods.js";
 import { type AgentIoMethods } from "./agent-io-methods.js";
 import { type DashboardInteractionMethods } from "./dashboard-interaction.js";
@@ -18,6 +19,7 @@ export interface SessionState {
     lifecycle?: "live" | "offline";
     createdAt?: string;
     backendSessionId?: string;
+    team?: SessionTeamMetadata;
     worktreePath?: string;
     label?: string;
     headline?: string;
@@ -36,7 +38,6 @@ export interface ServiceState {
 export interface SavedState {
     savedAt: string;
     cwd: string;
-    sessions: SessionState[];
     services?: ServiceState[];
 }
 type ManagedSession = SessionRuntime;
@@ -95,8 +96,10 @@ export declare class Multiplexer {
     private planEntries;
     private planIndex;
     private notificationPanelState;
+    private teammatePickerState;
     private dashboardPendingActions;
     private stoppingSessionIds;
+    private unpreservedExitedSessionIds;
     private graveyardAfterStopSessionIds;
     private dashboardQuickJumpTimeout;
     /** Quick switcher overlay state */
@@ -105,7 +108,6 @@ export declare class Multiplexer {
     /** MRU order of session IDs (most recent first) */
     private sessionMRU;
     /** Sessions confirmed registered in the instance registry (for claim detection) */
-    private confirmedRegistered;
     /** The focused worktree path on the dashboard (undefined = main repo) */
     private dashboardState;
     private dashboardUiStateStore;
@@ -117,11 +119,8 @@ export declare class Multiplexer {
     private dashboardPendingExpandedViewportCount;
     private dashboardModelVersion;
     private agentTracker;
-    private instanceId;
     private contextWatcher;
-    private taskDispatcher;
-    private orchestrationDispatcher;
-    /** Maps session ID → toolConfigKey for state saving */
+    /** Maps session ID → toolConfigKey for topology persistence */
     private sessionToolKeys;
     /** Maps session ID → original args (before preamble injection) */
     private sessionOriginalArgs;
@@ -131,10 +130,9 @@ export declare class Multiplexer {
     private sessionRoles;
     /** Maps session ID → user-provided stable label */
     private sessionLabels;
-    /** Offline sessions from previous runs (loaded from state.json) */
+    /** Offline sessions from previous runs (loaded from runtime topology) */
     private offlineSessions;
     /** Cross-instance discovery and claim/heartbeat ownership */
-    private instanceDirectory;
     private tmuxRuntimeManager;
     private sessionBootstrap;
     private sessionTmuxTargets;
@@ -147,7 +145,9 @@ export declare class Multiplexer {
     private lastStatuslineSnapshotKey;
     private desktopStateSnapshot;
     private dashboardSessionsCache;
+    private dashboardTeammatesCache;
     private dashboardServicesCache;
+    private dashboardRawWorktreeGroupsCache;
     private dashboardWorktreeGroupsCache;
     private dashboardOperationFailuresCache;
     private dashboardMainCheckoutInfoCache;
@@ -161,14 +161,13 @@ export declare class Multiplexer {
     get sessionCount(): number;
     get activeSession(): ManagedSession | null;
     private publishAlert;
+    private resolveSessionAlertDisplayContext;
     private deriveSessionSemanticState;
     private registerManagedSession;
     private handleSessionRuntimeEvent;
     private buildTmuxWindowMetadata;
     private syncTmuxWindowMetadata;
     private updateContextWatcherSessions;
-    private createTaskDispatcher;
-    private createOrchestrationDispatcher;
     private selectLinkedOrOpenTarget;
     run(opts: {
         command: string;
@@ -178,7 +177,7 @@ export declare class Multiplexer {
     runProjectService(): Promise<number>;
     /**
      * Resume previous sessions using each tool's native resume mechanism.
-     * Reads state.json and spawns sessions with resumeArgs instead of normal args.
+     * Reads runtime topology and spawns sessions with resumeArgs instead of normal args.
      */
     resumeSessions(toolFilter?: string): Promise<number>;
     /**
@@ -186,7 +185,11 @@ export declare class Multiplexer {
      * Starts fresh sessions but with context from the previous conversation.
      */
     restoreSessions(toolFilter?: string): Promise<number>;
-    createSession(command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean): SessionTransport;
+    createSession(command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean, team?: SessionTeamMetadata): SessionTransport;
+    recordSessionBackendSessionId(sessionId: string, backendSessionId: string): {
+        sessionId: string;
+        backendSessionId: string;
+    };
     /**
      * Migrate an agent from its current worktree to a target worktree.
      * Copies history and context, kills the old session, starts a new one