aimux-cli 0.1.16 → 0.1.18

package/dist/multiplexer/dashboard-model.js

@@ -8,18 +8,344 @@ import { listThreadSummaries, readMessages } from "../threads.js";
 import { deriveSessionSemantics } from "../session-semantics.js";
 import { summarizeUnreadNotificationsBySession } from "../notifications.js";
 import { requestJson } from "../http-client.js";
+import { isTeammateSession, selectDirectTeammates } from "../team.js";
 import { buildWorkflowEntries, describeWorkflowNextAction } from "../workflow.js";
 import { ensureDaemonRunning, ensureProjectService } from "../daemon.js";
 import { isDashboardWindowName } from "../tmux/runtime-manager.js";
 import { dashboardCreatedSortKey, sortDashboardEntriesByCreatedAt } from "../dashboard/sort.js";
 import { listDashboardOperationFailures } from "../dashboard/operation-failures.js";
 import { listWorktreeGraveyardPaths } from "./worktree-graveyard.js";
+import { setPendingDashboardServiceAction, setPendingDashboardSessionAction } from "./dashboard-ops.js";
+import { listTopologySessionStates } from "../runtime-core/topology-sessions.js";
+const METADATA_PENDING_SETTLE_TIMEOUT_MS = 10_000;
+const METADATA_PENDING_SETTLE_INTERVAL_MS = 100;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function listOfflineSessionsForAction(host) {
+    const sessionsById = new Map();
+    for (const session of host.offlineSessions ?? []) {
+        if (session?.id)
+            sessionsById.set(session.id, session);
+    }
+    for (const session of listTopologySessionStates({ statuses: ["offline"] })) {
+        if (session?.id && !sessionsById.has(session.id))
+            sessionsById.set(session.id, session);
+    }
+    return [...sessionsById.values()];
+}
+function reconcileSessionsForLifecycleAction(host) {
+    host.syncSessionsFromTopology?.();
+    host.saveState?.();
+}
+function resolveOfflineSessionForAction(host, sessionId) {
+    return listOfflineSessionsForAction(host).find((session) => session.id === sessionId);
+}
+function findDashboardSessionSeed(host, sessionId, fallback) {
+    const cached = host.dashboardSessionsCache?.find?.((entry) => entry.id === sessionId);
+    if (cached)
+        return cached;
+    return toDashboardSessionSeed(host.sessions?.find?.((entry) => entry.id === sessionId) ??
+        host.offlineSessions?.find?.((entry) => entry.id === sessionId) ??
+        (fallback?.id ? fallback : undefined));
+}
+function findDashboardServiceSeed(host, serviceId) {
+    const cached = host.dashboardServicesCache?.find?.((entry) => entry.id === serviceId);
+    if (cached)
+        return cached;
+    return toDashboardServiceSeed(host.services?.find?.((entry) => entry.id === serviceId) ??
+        host.offlineServices?.find?.((entry) => entry.id === serviceId));
+}
+function toDashboardSessionSeed(seed) {
+    if (!seed?.id || !seed.command)
+        return undefined;
+    return {
+        index: typeof seed.index === "number" ? seed.index : -1,
+        id: seed.id,
+        command: seed.command,
+        label: seed.label,
+        status: seed.status ?? (seed.lifecycle === "offline" ? "offline" : "running"),
+        active: Boolean(seed.active),
+        worktreePath: seed.worktreePath,
+        createdAt: seed.createdAt,
+        backendSessionId: seed.backendSessionId,
+        headline: seed.headline,
+        team: seed.team,
+    };
+}
+function toDashboardServiceSeed(seed) {
+    if (!seed?.id)
+        return undefined;
+    return {
+        id: seed.id,
+        command: seed.command ?? seed.launchCommandLine ?? seed.label ?? "service",
+        args: Array.isArray(seed.args) ? seed.args : [],
+        label: seed.label,
+        status: seed.status ?? (seed.lifecycle === "offline" ? "offline" : "running"),
+        active: Boolean(seed.active),
+        worktreePath: seed.worktreePath,
+        createdAt: seed.createdAt,
+    };
+}
+function buildMetadataPendingSessionSeed(input) {
+    return {
+        index: -1,
+        id: input.sessionId,
+        command: input.tool,
+        label: input.tool,
+        createdAt: new Date().toISOString(),
+        status: "waiting",
+        active: false,
+        worktreePath: input.worktreePath,
+        pendingAction: input.pendingAction,
+        optimistic: true,
+        team: input.team,
+    };
+}
+async function waitForMetadataCondition(host, predicate, timeoutMs = METADATA_PENDING_SETTLE_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            host.invalidateDesktopStateSnapshot?.();
+            host.refreshLocalDashboardModel?.();
+        }
+        catch { }
+        if (predicate())
+            return true;
+        await sleep(METADATA_PENDING_SETTLE_INTERVAL_MS);
+    }
+    try {
+        host.invalidateDesktopStateSnapshot?.();
+        host.refreshLocalDashboardModel?.();
+    }
+    catch { }
+    return predicate();
+}
+function hasLiveManagedAgentWindow(host, sessionId) {
+    try {
+        if (!host.tmuxRuntimeManager?.listProjectManagedWindows)
+            return false;
+        return host.tmuxRuntimeManager.listProjectManagedWindows(process.cwd()).some(({ target, metadata }) => {
+            if (isDashboardWindowName(target.windowName))
+                return false;
+            if (metadata.kind !== "agent" || metadata.sessionId !== sessionId)
+                return false;
+            if (host.tmuxRuntimeManager.isWindowAlive && !host.tmuxRuntimeManager.isWindowAlive(target))
+                return false;
+            return true;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function hasLiveManagedServiceWindow(host, serviceId) {
+    try {
+        if (!host.tmuxRuntimeManager?.listProjectManagedWindows)
+            return false;
+        return host.tmuxRuntimeManager.listProjectManagedWindows(process.cwd()).some(({ target, metadata }) => {
+            if (isDashboardWindowName(target.windowName))
+                return false;
+            if (metadata.kind !== "service" || metadata.sessionId !== serviceId)
+                return false;
+            if (host.tmuxRuntimeManager.isWindowAlive && !host.tmuxRuntimeManager.isWindowAlive(target))
+                return false;
+            return true;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function isMetadataSessionRunning(host, sessionId) {
+    if (host.sessions?.some?.((session) => session.id === sessionId && !session.exited))
+        return true;
+    if (host.sessionTmuxTargets?.has?.(sessionId))
+        return true;
+    return hasLiveManagedAgentWindow(host, sessionId);
+}
+async function waitForMetadataSessionRunning(host, sessionId) {
+    if (typeof host.waitForSessionStart === "function") {
+        try {
+            if (await host.waitForSessionStart(sessionId, METADATA_PENDING_SETTLE_TIMEOUT_MS))
+                return true;
+        }
+        catch { }
+    }
+    return waitForMetadataCondition(host, () => isMetadataSessionRunning(host, sessionId));
+}
+function isMetadataServiceRunning(host, serviceId) {
+    const offline = host.offlineServices?.some?.((service) => service.id === serviceId);
+    if (offline)
+        return false;
+    if (host.services?.some?.((service) => service.id === serviceId && service.status !== "offline"))
+        return true;
+    return hasLiveManagedServiceWindow(host, serviceId);
+}
+function isMetadataServiceOffline(host, serviceId) {
+    return Boolean(host.offlineServices?.some?.((service) => service.id === serviceId));
+}
+function isMetadataServiceRemoved(host, serviceId) {
+    const offline = host.offlineServices?.some?.((service) => service.id === serviceId);
+    if (offline)
+        return false;
+    return !hasLiveManagedServiceWindow(host, serviceId);
+}
+async function settleMetadataPending(host, description, settle, result) {
+    if (!settle)
+        return;
+    try {
+        const settled = await settle(result);
+        if (!settled) {
+            host.debug?.(`metadata pending action did not settle: ${description}`, "dashboard");
+        }
+    }
+    catch (error) {
+        host.debug?.(`metadata pending action settle failed: ${description}: ${error instanceof Error ? error.message : String(error)}`, "dashboard");
+    }
+}
+function clearMetadataSessionPendingAfterSettle(host, sessionId, kind, token, settle, result) {
+    void (async () => {
+        await settleMetadataPending(host, `session ${kind} ${sessionId}`, settle, result);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearSessionActionIfToken?.(sessionId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else if (host.dashboardPendingActions?.getSessionAction?.(sessionId) === kind) {
+            setPendingDashboardSessionAction(host, sessionId, null);
+        }
+    })();
+}
+function clearMetadataServicePendingAfterSettle(host, serviceId, kind, token, settle, result) {
+    void (async () => {
+        await settleMetadataPending(host, `service ${kind} ${serviceId}`, settle, result);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearServiceActionIfToken?.(serviceId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else if (host.dashboardPendingActions?.getServiceAction?.(serviceId) === kind) {
+            setPendingDashboardServiceAction(host, serviceId, null);
+        }
+    })();
+}
+export async function withMetadataSessionPending(host, sessionId, kind, work, sessionSeed, settle) {
+    let token;
+    if (sessionId) {
+        token = setPendingDashboardSessionAction(host, sessionId, kind, { sessionSeed });
+    }
+    try {
+        const result = await work();
+        if (sessionId) {
+            clearMetadataSessionPendingAfterSettle(host, sessionId, kind, token, settle, result);
+        }
+        return result;
+    }
+    catch (error) {
+        if (sessionId) {
+            if (typeof token === "number") {
+                if (host.dashboardPendingActions?.clearSessionActionIfToken?.(sessionId, token)) {
+                    host.reapplyDashboardPendingActions?.();
+                }
+            }
+            else {
+                setPendingDashboardSessionAction(host, sessionId, null);
+            }
+        }
+        throw error;
+    }
+}
+export async function withMetadataServicePending(host, serviceId, kind, work, settle) {
+    const token = setPendingDashboardServiceAction(host, serviceId, kind, {
+        serviceSeed: findDashboardServiceSeed(host, serviceId),
+    });
+    try {
+        const result = await work();
+        clearMetadataServicePendingAfterSettle(host, serviceId, kind, token, settle, result);
+        return result;
+    }
+    catch (error) {
+        if (host.dashboardPendingActions?.clearServiceActionIfToken?.(serviceId, token)) {
+            host.reapplyDashboardPendingActions?.();
+        }
+        throw error;
+    }
+}
+function lifecycleFailureMessage(action, failures) {
+    const noun = failures.length === 1 ? "teammate" : "teammates";
+    const details = failures
+        .map(({ sessionId, error }) => `${sessionId}: ${error instanceof Error ? error.message : String(error)}`)
+        .join("; ");
+    return `Failed to ${action} ${failures.length} ${noun}: ${details}`;
+}
+async function resumeOfflineAgentWithPending(host, sessionId) {
+    return withMetadataSessionPending(host, sessionId, "starting", () => {
+        reconcileSessionsForLifecycleAction(host);
+        const offline = resolveOfflineSessionForAction(host, sessionId);
+        if (!offline) {
+            throw new Error(`Agent "${sessionId}" not found`);
+        }
+        host.resumeOfflineSession(offline);
+        return { sessionId, status: "running" };
+    }, findDashboardSessionSeed(host, sessionId), () => waitForMetadataSessionRunning(host, sessionId));
+}
+async function resumeOfflineAgentWithPendingAndSettle(host, sessionId) {
+    const result = await resumeOfflineAgentWithPending(host, sessionId);
+    await waitForMetadataSessionRunning(host, sessionId);
+    return result;
+}
+async function resumeAgentAndDirectTeammates(host, sessionId) {
+    reconcileSessionsForLifecycleAction(host);
+    const offline = resolveOfflineSessionForAction(host, sessionId);
+    if (!offline) {
+        throw new Error(`Agent "${sessionId}" not found`);
+    }
+    const teammates = isTeammateSession(offline)
+        ? []
+        : selectDirectTeammates(listOfflineSessionsForAction(host), sessionId);
+    const result = await resumeOfflineAgentWithPendingAndSettle(host, sessionId);
+    const teammateFailures = [];
+    for (const teammate of teammates) {
+        try {
+            await resumeOfflineAgentWithPendingAndSettle(host, teammate.id);
+        }
+        catch (error) {
+            teammateFailures.push({ sessionId: teammate.id, error });
+        }
+    }
+    if (teammateFailures.length > 0) {
+        return {
+            ...result,
+            warning: lifecycleFailureMessage("resume", teammateFailures),
+            teammateFailures: teammateFailures.map(({ sessionId, error }) => ({
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            })),
+        };
+    }
+    return result;
+}
 function runProjectServiceUiRefresh(host) {
     host.writeStatuslineFile();
     if (host.mode === "dashboard") {
         host.renderCurrentDashboardView();
     }
 }
+const projectServiceAgentResumeQueues = new WeakMap();
+async function enqueueProjectServiceAgentResume(host, work) {
+    const previous = projectServiceAgentResumeQueues.get(host) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(work);
+    const tracked = current
+        .catch(() => undefined)
+        .finally(() => {
+        if (projectServiceAgentResumeQueues.get(host) === tracked) {
+            projectServiceAgentResumeQueues.delete(host);
+        }
+    });
+    projectServiceAgentResumeQueues.set(host, tracked);
+    return current;
+}
 function scheduleProjectServiceUiRefresh(host) {
     if (host.projectServiceStartupMetadataSettling) {
         host.projectServiceUiRefreshPending = true;
@@ -82,22 +408,28 @@ export function composeDashboardWorktreeGroups(worktreeGroups, dashSessions, das
         };
     }));
 }
-export function applyDashboardModel(host, dashSessions, dashServices, worktreeGroups, mainCheckoutInfo, operationFailures = []) {
+export function applyDashboardModel(host, dashSessions, dashTeammates, dashServices, worktreeGroups, mainCheckoutInfo, operationFailures = []) {
     const snapshotKey = JSON.stringify({
         sessions: dashSessions,
+        teammates: dashTeammates,
         services: dashServices,
         worktreeGroups,
         mainCheckoutInfo,
         operationFailures,
+        pendingActionsVersion: host.dashboardPendingActions.getVersion?.() ?? 0,
     });
     if (snapshotKey === host.dashboardModelSnapshotKey) {
         host.dashboardModelRefreshedAt = Date.now();
         return false;
     }
     host.dashboardModelSnapshotKey = snapshotKey;
+    host.dashboardRawWorktreeGroupsCache = worktreeGroups;
     host.dashboardSessionsCache = host.dashboardPendingActions.applyToSessions(dashSessions);
+    host.dashboardTeammatesCache = host.dashboardPendingActions
+        .applyToSessions(dashTeammates, { includeTeammates: true })
+        .filter((session) => isTeammateSession(session));
     host.dashboardServicesCache = host.dashboardPendingActions.applyToServices(dashServices);
-    host.dashboardWorktreeGroupsCache = composeDashboardWorktreeGroups(host.dashboardPendingActions.applyToWorktrees(worktreeGroups), host.dashboardSessionsCache, host.dashboardServicesCache);
+    host.dashboardWorktreeGroupsCache = host.dashboardUiStateStore.orderWorktreeGroups(composeDashboardWorktreeGroups(host.dashboardPendingActions.applyToWorktrees(worktreeGroups), host.dashboardSessionsCache, host.dashboardServicesCache));
     host.dashboardOperationFailuresCache = operationFailures;
     host.dashboardMainCheckoutInfoCache = mainCheckoutInfo;
     host.dashboardModelVersion = (host.dashboardModelVersion ?? 0) + 1;
@@ -111,7 +443,7 @@ export function invalidateDesktopStateSnapshot(host) {
 export function refreshDesktopStateSnapshot(host) {
     host.desktopStateSnapshot = buildDesktopStateSnapshot(host);
 }
-export function computeDashboardSessions(host) {
+export function computeDashboardSessions(host, options = {}) {
     const lastUsedState = loadLastUsedState(process.cwd());
     const metadata = loadMetadataState().sessions;
     const threadSummaries = listThreadSummaries();
@@ -187,6 +519,7 @@ export function computeDashboardSessions(host) {
             id: session.id,
             command: session.command,
             backendSessionId: session.backendSessionId,
+            team: session.team,
             createdAt: session.startTime ? new Date(session.startTime).toISOString() : undefined,
             status: session.status,
             worktreePath: host.sessionWorktreePaths.get(session.id),
@@ -194,12 +527,12 @@ export function computeDashboardSessions(host) {
         })),
         activeIndex: host.activeIndex,
         offlineSessions: host.offlineSessions,
-        remoteInstances: [],
         hiddenWorktreePaths: listWorktreeGraveyardPaths(),
         mainRepoPath,
+        includeTeammates: options.includeTeammates,
         getSessionLabel: (sessionId) => host.getSessionLabel(sessionId),
         getSessionHeadline: (sessionId) => host.deriveHeadline(sessionId),
-        getSessionTaskDescription: (sessionId) => host.taskDispatcher?.getSessionTask(sessionId),
+        getSessionTaskDescription: () => undefined,
         getSessionRole: (sessionId) => host.sessionRoles.get(sessionId),
         getSessionContext: (sessionId) => metadata[sessionId]?.context,
         getSessionDerived: (sessionId) => metadata[sessionId]?.derived,
@@ -265,6 +598,7 @@ export function computeDashboardSessions(host) {
 export function computeDashboardServices(host, worktrees = host.listDesktopWorktrees()) {
     const hiddenWorktreePaths = listWorktreeGraveyardPaths();
     const lastUsedState = loadLastUsedState(process.cwd());
+    const sessionMetadata = loadMetadataState().sessions;
     const offlineServiceIds = new Set(host.offlineServices.map((service) => service.id));
     const worktreeByPath = new Map(worktrees.map((wt) => [wt.path, wt]));
     const liveServices = host.tmuxRuntimeManager
@@ -275,6 +609,7 @@ export function computeDashboardServices(host, worktrees = host.listDesktopWorkt
         .map(({ target, metadata }) => {
         const worktree = metadata.worktreePath ? worktreeByPath.get(metadata.worktreePath) : undefined;
         const info = readTmuxProcessInfo(host, target);
+        const shellMetadata = sessionMetadata[metadata.sessionId]?.derived;
         return {
             id: metadata.sessionId,
             command: metadata.command,
@@ -291,6 +626,8 @@ export function computeDashboardServices(host, worktrees = host.listDesktopWorkt
             label: metadata.label,
             cwd: host.tmuxRuntimeManager.displayMessage("#{pane_current_path}", target.windowId) ?? metadata.worktreePath,
             foregroundCommand: info.command,
+            shellCommand: shellMetadata?.shellCommand,
+            shellCommandState: shellMetadata?.shellCommandState,
             pid: info.pid,
             previewLine: info.previewLine,
         };
@@ -303,6 +640,7 @@ export function computeDashboardServices(host, worktrees = host.listDesktopWorkt
         const worktree = service.worktreePath ? worktreeByPath.get(service.worktreePath) : undefined;
         const label = service.label ?? host.serviceLabelForCommand(service.launchCommandLine ?? "");
         const previewLine = service.launchCommandLine?.trim() || "Interactive shell";
+        const shellMetadata = sessionMetadata[service.id]?.derived;
         return {
             id: service.id,
             command: service.launchCommandLine?.trim() ?? "",
@@ -317,6 +655,8 @@ export function computeDashboardServices(host, worktrees = host.listDesktopWorkt
             label,
             cwd: service.cwd ?? service.worktreePath,
             foregroundCommand: label,
+            shellCommand: shellMetadata?.shellCommand,
+            shellCommandState: shellMetadata?.shellCommandState,
             previewLine,
         };
     });
@@ -342,7 +682,7 @@ export function readTmuxProcessInfo(host, target) {
     };
 }
 export function buildDesktopStateSnapshot(host) {
-    host.syncSessionsFromState();
+    host.syncSessionsFromTopology();
     const worktrees = host.listDesktopWorktrees();
     const realizedWorktreePaths = new Set(worktrees.filter((worktree) => !worktree.operationFailure).map((worktree) => worktree.path));
     const operationFailures = listDashboardOperationFailures().filter((failure) => !(failure.targetKind === "worktree" &&
@@ -360,6 +700,7 @@ export function buildDesktopStateSnapshot(host) {
     }
     return {
         sessions: computeDashboardSessions(host),
+        teammates: computeDashboardSessions(host, { includeTeammates: true }).filter((session) => isTeammateSession(session)),
         services: computeDashboardServices(host, worktrees),
         worktrees,
         operationFailures,
@@ -383,15 +724,16 @@ export async function refreshDashboardModelFromService(host, force = false) {
             if (endpoint) {
                 try {
                     const { status, json } = await requestJson(`http://${endpoint.host}:${endpoint.port}/desktop-state`, {
-                        timeoutMs: 250,
+                        timeoutMs: force ? 2000 : 750,
                     });
                     if (status >= 200 && status < 300) {
                         const body = json;
                         const dashSessions = body.sessions ?? [];
+                        const dashTeammates = body.teammates ?? [];
                         const dashServices = body.services ?? [];
                         const worktrees = body.worktrees ?? [];
                         const worktreeGroups = buildDashboardWorktreeGroups(host, dashSessions, dashServices, worktrees, body.mainCheckoutPath);
-                        return applyDashboardModel(host, dashSessions, dashServices, worktreeGroups, body.mainCheckoutInfo ?? { name: "Main Checkout", branch: "" }, body.operationFailures ?? []);
+                        return applyDashboardModel(host, dashSessions, dashTeammates, dashServices, worktreeGroups, body.mainCheckoutInfo ?? { name: "Main Checkout", branch: "" }, body.operationFailures ?? []);
                     }
                 }
                 catch {
@@ -416,7 +758,7 @@ export async function refreshDashboardModelFromService(host, force = false) {
 export function refreshLocalDashboardModel(host) {
     const snapshot = buildDesktopStateSnapshot(host);
     const worktreeGroups = buildDashboardWorktreeGroups(host, snapshot.sessions, snapshot.services, snapshot.worktrees, snapshot.mainCheckoutPath);
-    applyDashboardModel(host, snapshot.sessions, snapshot.services, worktreeGroups, snapshot.mainCheckoutInfo, snapshot.operationFailures);
+    applyDashboardModel(host, snapshot.sessions, snapshot.teammates, snapshot.services, worktreeGroups, snapshot.mainCheckoutInfo, snapshot.operationFailures);
 }
 export async function startProjectServices(host) {
     if (host.metadataServer)
@@ -427,20 +769,27 @@ export async function startProjectServices(host) {
         events: { bus: host.eventBus },
         desktop: {
             getState: () => host.buildDesktopState(),
-            listWorktrees: () => host.listDesktopWorktrees(),
+            listWorktrees: () => host.listProjectedDesktopWorktrees(),
             getSessionDisplayContext: (sessionId) => {
                 const session = host.dashboardSessionsCache.find((entry) => entry.id === sessionId) ??
                     host.sessions.find((entry) => entry.id === sessionId);
-                const worktreePath = host.sessionWorktreePaths.get(sessionId) ?? session?.worktreePath;
+                const service = host.dashboardServicesCache.find((entry) => entry.id === sessionId) ??
+                    host.services?.find?.((entry) => entry.id === sessionId) ??
+                    host.offlineServices?.find?.((entry) => entry.id === sessionId);
+                const worktreePath = host.sessionWorktreePaths.get(sessionId) ?? session?.worktreePath ?? service?.worktreePath;
                 const group = worktreePath
                     ? host.dashboardWorktreeGroupsCache.find((entry) => entry.path === worktreePath)
                     : host.dashboardWorktreeGroupsCache.find((entry) => !entry.path);
                 return {
-                    label: host.getSessionLabel(sessionId) ?? session?.label ?? session?.command,
-                    command: session?.command,
+                    label: host.getSessionLabel(sessionId) ??
+                        session?.label ??
+                        service?.label ??
+                        (service ? host.serviceLabelForCommand?.(service.launchCommandLine ?? service.command ?? "") : undefined) ??
+                        session?.command,
+                    command: session?.command ?? service?.command ?? service?.launchCommandLine,
                     worktreePath,
-                    worktreeName: session?.worktreeName ?? group?.name,
-                    branch: session?.worktreeBranch ?? group?.branch,
+                    worktreeName: session?.worktreeName ?? service?.worktreeName ?? group?.name,
+                    branch: session?.worktreeBranch ?? service?.worktreeBranch ?? group?.branch,
                 };
             },
             refreshStatusline: ({ sessionId, force }) => host.refreshProjectStatusline({ sessionId, force }),
@@ -451,17 +800,10 @@ export async function startProjectServices(host) {
             resurrectGraveyardWorktree: ({ path }) => host.resurrectGraveyardWorktree(path),
             deleteGraveyardWorktree: ({ path }) => host.deleteGraveyardWorktree(path),
             createService: ({ command, worktreePath, serviceId }) => host.createService(command ?? "", worktreePath, { serviceId }),
-            stopService: ({ serviceId }) => host.stopService(serviceId),
-            resumeService: ({ serviceId }) => host.resumeOfflineServiceById(serviceId),
-            removeService: ({ serviceId }) => host.removeOfflineService(serviceId),
-            resumeAgent: ({ sessionId }) => {
-                const offline = host.offlineSessions.find((session) => session.id === sessionId);
-                if (!offline) {
-                    throw new Error(`Agent "${sessionId}" not found`);
-                }
-                host.resumeOfflineSession(offline);
-                return { sessionId, status: "running" };
-            },
+            stopService: ({ serviceId }) => withMetadataServicePending(host, serviceId, "stopping", () => host.stopService(serviceId), () => waitForMetadataCondition(host, () => isMetadataServiceOffline(host, serviceId))),
+            resumeService: ({ serviceId }) => withMetadataServicePending(host, serviceId, "starting", () => host.resumeOfflineServiceById(serviceId), () => waitForMetadataCondition(host, () => isMetadataServiceRunning(host, serviceId))),
+            removeService: ({ serviceId }) => withMetadataServicePending(host, serviceId, "removing", () => host.removeOfflineService(serviceId), () => waitForMetadataCondition(host, () => isMetadataServiceRemoved(host, serviceId))),
+            resumeAgent: ({ sessionId }) => enqueueProjectServiceAgentResume(host, () => resumeAgentAndDirectTeammates(host, sessionId)),
             listGraveyard: () => host.listGraveyardEntries(),
             resurrectGraveyard: ({ sessionId }) => host.resurrectGraveyardSession(sessionId),
         },
@@ -472,14 +814,48 @@ export async function startProjectServices(host) {
             sendHandoff: (input) => host.sendHandoffMessage(input),
         },
         lifecycle: {
-            spawnAgent: (input) => host.spawnAgent({
+            spawnAgent: (input) => withMetadataSessionPending(host, input.sessionId, "creating", () => host.spawnAgent({
                 toolConfigKey: input.tool,
                 targetSessionId: input.sessionId,
                 targetWorktreePath: input.worktreePath,
                 open: input.open ?? false,
                 extraArgs: input.extraArgs,
-            }),
-            forkAgent: (input) => host.forkAgent({
+            }), input.sessionId
+                ? buildMetadataPendingSessionSeed({
+                    sessionId: input.sessionId,
+                    tool: input.tool,
+                    worktreePath: input.worktreePath,
+                    pendingAction: "creating",
+                })
+                : undefined, (result) => waitForMetadataSessionRunning(host, result.sessionId)),
+            createTeammateAgent: (input) => withMetadataSessionPending(host, input.sessionId, "creating", () => host.createTeammateAgent({
+                parentSessionId: input.parentSessionId,
+                role: input.role,
+                label: input.label,
+                toolConfigKey: input.tool,
+                targetSessionId: input.sessionId,
+                targetWorktreePath: input.worktreePath,
+                open: input.open ?? false,
+                extraArgs: input.extraArgs,
+                order: input.order,
+            }), input.sessionId
+                ? buildMetadataPendingSessionSeed({
+                    sessionId: input.sessionId,
+                    tool: input.tool,
+                    worktreePath: input.worktreePath,
+                    pendingAction: "creating",
+                    team: {
+                        teamId: `team-${input.parentSessionId}`,
+                        parentSessionId: input.parentSessionId,
+                        role: typeof input.role === "string" && input.role.trim() ? input.role.trim() : undefined,
+                        label: typeof input.label === "string" && input.label.trim() ? input.label.trim() : undefined,
+                        order: typeof input.order === "number" ? input.order : undefined,
+                    },
+                })
+                : undefined, (result) => result?.reused && result.sessionId !== input.sessionId
+                ? true
+                : waitForMetadataSessionRunning(host, result.sessionId)),
+            forkAgent: (input) => withMetadataSessionPending(host, input.targetSessionId, "forking", () => host.forkAgent({
                 sourceSessionId: input.sourceSessionId,
                 targetToolConfigKey: input.tool,
                 targetSessionId: input.targetSessionId,
@@ -487,15 +863,21 @@ export async function startProjectServices(host) {
                 targetWorktreePath: input.worktreePath,
                 open: input.open ?? false,
                 extraArgs: input.extraArgs,
-            }),
-            stopAgent: (input) => host.stopAgent(input.sessionId),
+            }), input.targetSessionId
+                ? buildMetadataPendingSessionSeed({
+                    sessionId: input.targetSessionId,
+                    tool: input.tool,
+                    worktreePath: input.worktreePath,
+                    pendingAction: "forking",
+                })
+                : undefined, (result) => waitForMetadataSessionRunning(host, result.sessionId)),
+            stopAgent: (input) => withMetadataSessionPending(host, input.sessionId, "stopping", () => host.stopAgent(input.sessionId), findDashboardSessionSeed(host, input.sessionId)),
             interruptAgent: (input) => host.interruptAgent(input.sessionId),
             renameAgent: (input) => host.renameAgent(input.sessionId, input.label),
-            migrateAgent: (input) => host.migrateAgent(input.sessionId, input.worktreePath),
-            killAgent: (input) => host.sendAgentToGraveyard(input.sessionId),
-            writeAgentInput: (input) => host.writeAgentInput(input.sessionId, input.data, input.parts, input.clientMessageId, input.submit),
+            migrateAgent: (input) => withMetadataSessionPending(host, input.sessionId, "migrating", () => host.migrateAgent(input.sessionId, input.worktreePath), findDashboardSessionSeed(host, input.sessionId)),
+            killAgent: (input) => withMetadataSessionPending(host, input.sessionId, "graveyarding", () => host.sendAgentToGraveyard(input.sessionId), findDashboardSessionSeed(host, input.sessionId)),
+            sendAgentInput: (input) => host.sendAgentInput(input.sessionId, input.text),
             readAgentOutput: (input) => host.readAgentOutput(input.sessionId, input.startLine),
-            readAgentHistory: (input) => host.readAgentHistory(input.sessionId, input.lastN),
         },
         onChange: () => {
             scheduleProjectServiceUiRefresh(host);