aimux-cli 0.1.16 → 0.1.19

package/dist/dashboard/index.d.ts

@@ -1,9 +1,10 @@
-import type { SessionStatus } from "../status-detector.js";
 import type { AgentActivityState, AgentAttentionState, AgentEvent } from "../agent-events.js";
 import type { SessionServiceMetadata } from "../metadata-store.js";
-import type { SessionSemanticState } from "../session-semantics.js";
+import type { PendingDashboardActionKind, PendingWorktreeActionKind } from "../pending-actions.js";
+import type { SessionPendingAction, SessionRawStatus, SessionSemanticState } from "../session-semantics.js";
+import type { SessionTeamMetadata } from "../team.js";
 import type { DashboardOperationFailure } from "./operation-failures.js";
-export type DashboardSessionStatus = SessionStatus;
+export type DashboardSessionStatus = SessionRawStatus;
 export interface DashboardSession {
     index: number;
     id: string;
@@ -13,15 +14,12 @@ export interface DashboardSession {
     lastUsedAt?: string;
     createdAt?: string;
     backendSessionId?: string;
+    team?: SessionTeamMetadata;
     status: DashboardSessionStatus;
     active: boolean;
     worktreePath?: string;
     worktreeName?: string;
     worktreeBranch?: string;
-    /** If set, this session belongs to another aimux instance */
-    remoteInstancePid?: number;
-    remoteInstanceId?: string;
-    remoteBackendSessionId?: string;
     /** Active task description assigned to this session */
     taskDescription?: string;
     /** Auto-derived or user-set label for offline agents */
@@ -60,7 +58,8 @@ export interface DashboardSession {
     notificationUnreadCount?: number;
     latestNotificationText?: string;
     semantic?: SessionSemanticState;
-    pendingAction?: "creating" | "forking" | "migrating" | "starting" | "stopping" | "graveyarding" | "renaming";
+    pendingAction?: SessionPendingAction;
+    pending?: boolean;
     optimistic?: boolean;
 }
 export interface DashboardService {
@@ -79,9 +78,12 @@ export interface DashboardService {
     label?: string;
     cwd?: string;
     foregroundCommand?: string;
+    shellCommand?: string;
+    shellCommandState?: "running" | "prompt";
     pid?: number;
     previewLine?: string;
-    pendingAction?: "creating" | "forking" | "migrating" | "starting" | "stopping" | "graveyarding" | "renaming" | "removing";
+    pendingAction?: PendingDashboardActionKind;
+    pending?: boolean;
     optimistic?: boolean;
 }
 export type DashboardWorktreeEntry = {
@@ -99,7 +101,7 @@ export interface WorktreeGroup {
     status: "active" | "offline";
     pending?: boolean;
     removing?: boolean;
-    pendingAction?: "removing" | "creating" | "graveyarding";
+    pendingAction?: PendingWorktreeActionKind;
     operationFailure?: DashboardOperationFailure;
     optimistic?: boolean;
     sessions: DashboardSession[];
@@ -124,6 +126,7 @@ export interface DashboardViewModel {
     navLevel: "worktrees" | "sessions";
     selectedSessionId?: string;
     selectedServiceId?: string;
+    selectedTeammates: DashboardSession[];
     runtimeLabel?: string;
     mainCheckout: MainCheckoutInfo;
     worktreeRemoval?: DashboardWorktreeRemovalInfo;

package/dist/dashboard/index.js

@@ -1,31 +1,7 @@
-import { sessionSemanticStatusLabel } from "../session-semantics.js";
+import { sessionDisplayStatusLabel } from "../session-semantics.js";
 import { renderDashboardFrame } from "../tui/screens/dashboard-renderers.js";
-const STATUS_LABELS = {
-    running: "running",
-    idle: "idle",
-    waiting: "thinking",
-    exited: "exited",
-    offline: "offline",
-};
 export function derivedStatusLabel(session) {
-    if (session.pendingAction === "creating")
-        return "creating";
-    if (session.pendingAction === "forking")
-        return "forking";
-    if (session.pendingAction === "migrating")
-        return "migrating";
-    if (session.pendingAction === "starting")
-        return "starting";
-    if (session.pendingAction === "stopping")
-        return "stopping";
-    if (session.pendingAction === "graveyarding")
-        return "graveyarding";
-    if (session.pendingAction === "renaming")
-        return "renaming";
-    if (session.semantic) {
-        return sessionSemanticStatusLabel(session.semantic, session.status);
-    }
-    return STATUS_LABELS[session.status];
+    return sessionDisplayStatusLabel(session);
 }
 export class Dashboard {
     viewModel = {
@@ -37,6 +13,7 @@ export class Dashboard {
         navLevel: "sessions",
         selectedSessionId: undefined,
         selectedServiceId: undefined,
+        selectedTeammates: [],
         runtimeLabel: undefined,
         mainCheckout: { name: "Main Checkout", branch: "" },
         worktreeRemoval: undefined,
@@ -69,4 +46,3 @@ export class Dashboard {
         this.viewModel.detailsPaneVisible = this.detailsPaneVisible;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/dashboard/operation-failures.js

@@ -83,4 +83,3 @@ export function clearDashboardOperationFailures(match) {
         saveState(state);
     return changed;
 }
-//# sourceMappingURL=operation-failures.js.map

package/dist/dashboard/order.d.ts

@@ -0,0 +1,22 @@
+import type { DashboardService, DashboardSession, WorktreeGroup } from "./index.js";
+export declare const MAIN_CHECKOUT_ORDER_KEY = "__main__";
+export interface DashboardOrderState {
+    agentOrderByWorktreeKey: Record<string, string[]>;
+    serviceOrderByWorktreeKey: Record<string, string[]>;
+}
+export type DashboardOrderKind = "session" | "service";
+export type DashboardOrderDirection = "up" | "down";
+export declare function dashboardOrderKey(worktreePath: string | undefined): string;
+export declare function normalizeDashboardOrder(currentIds: string[], savedOrder: string[] | undefined): string[];
+export declare function applyDashboardOrder<T extends {
+    id: string;
+}>(items: T[], savedOrder: string[] | undefined): T[];
+export declare function moveDashboardOrder<T extends {
+    id: string;
+}>(items: T[], savedOrder: string[] | undefined, selectedId: string, direction: DashboardOrderDirection): {
+    moved: boolean;
+    order: string[];
+};
+export declare function orderDashboardWorktreeGroups(groups: WorktreeGroup[], orderState: DashboardOrderState): WorktreeGroup[];
+export declare function orderDashboardSessionsForWorktree(sessions: DashboardSession[], worktreePath: string | undefined, orderState: DashboardOrderState): DashboardSession[];
+export declare function orderDashboardServicesForWorktree(services: DashboardService[], worktreePath: string | undefined, orderState: DashboardOrderState): DashboardService[];

package/dist/dashboard/order.js

@@ -0,0 +1,54 @@
+export const MAIN_CHECKOUT_ORDER_KEY = "__main__";
+export function dashboardOrderKey(worktreePath) {
+    return worktreePath ?? MAIN_CHECKOUT_ORDER_KEY;
+}
+export function normalizeDashboardOrder(currentIds, savedOrder) {
+    const current = new Set(currentIds);
+    const normalized = [];
+    const seen = new Set();
+    for (const id of savedOrder ?? []) {
+        if (!current.has(id) || seen.has(id))
+            continue;
+        normalized.push(id);
+        seen.add(id);
+    }
+    for (const id of currentIds) {
+        if (seen.has(id))
+            continue;
+        normalized.push(id);
+        seen.add(id);
+    }
+    return normalized;
+}
+export function applyDashboardOrder(items, savedOrder) {
+    const order = normalizeDashboardOrder(items.map((item) => item.id), savedOrder);
+    const byId = new Map(items.map((item) => [item.id, item]));
+    return order.map((id) => byId.get(id)).filter((item) => Boolean(item));
+}
+export function moveDashboardOrder(items, savedOrder, selectedId, direction) {
+    const order = normalizeDashboardOrder(items.map((item) => item.id), savedOrder);
+    const index = order.indexOf(selectedId);
+    if (index < 0)
+        return { moved: false, order };
+    const nextIndex = direction === "up" ? index - 1 : index + 1;
+    if (nextIndex < 0 || nextIndex >= order.length)
+        return { moved: false, order };
+    [order[index], order[nextIndex]] = [order[nextIndex], order[index]];
+    return { moved: true, order };
+}
+export function orderDashboardWorktreeGroups(groups, orderState) {
+    return groups.map((group) => {
+        const key = dashboardOrderKey(group.path);
+        return {
+            ...group,
+            sessions: applyDashboardOrder(group.sessions, orderState.agentOrderByWorktreeKey[key]),
+            services: applyDashboardOrder(group.services, orderState.serviceOrderByWorktreeKey[key]),
+        };
+    });
+}
+export function orderDashboardSessionsForWorktree(sessions, worktreePath, orderState) {
+    return applyDashboardOrder(sessions, orderState.agentOrderByWorktreeKey[dashboardOrderKey(worktreePath)]);
+}
+export function orderDashboardServicesForWorktree(services, worktreePath, orderState) {
+    return applyDashboardOrder(services, orderState.serviceOrderByWorktreeKey[dashboardOrderKey(worktreePath)]);
+}

package/dist/dashboard/pending-actions.d.ts

@@ -1,24 +1,53 @@
 import type { DashboardService, DashboardSession, WorktreeGroup } from "./index.js";
-export type PendingDashboardActionKind = "creating" | "forking" | "migrating" | "starting" | "stopping" | "graveyarding" | "renaming" | "removing";
+import type { PendingServiceActionKind, PendingSessionActionKind, PendingWorktreeActionKind } from "../pending-actions.js";
+type PendingActionTarget = "session" | "service" | "worktree";
+interface PendingActionOptions {
+    timeoutMs?: number;
+    onTimeout?: () => void;
+}
+interface PendingSessionActionOptions extends PendingActionOptions {
+    sessionSeed?: DashboardSession;
+}
+interface PendingServiceActionOptions extends PendingActionOptions {
+    serviceSeed?: DashboardService;
+}
+interface PendingWorktreeActionOptions extends PendingActionOptions {
+    worktreeSeed?: WorktreeGroup;
+}
+interface ApplyPendingSessionOptions {
+    includeTeammates?: boolean;
+}
 export declare class DashboardPendingActions {
     private readonly onChange;
     private actions;
     private version;
+    private nextEntryToken;
     constructor(onChange: () => void);
     static worktreeKey(path?: string): string;
-    set(sessionId: string, kind: PendingDashboardActionKind | null, opts?: {
-        timeoutMs?: number;
-        onTimeout?: () => void;
-        sessionSeed?: DashboardSession;
-        serviceSeed?: DashboardService;
-    }): void;
-    get(sessionId: string): PendingDashboardActionKind | undefined;
+    private static actionKey;
+    setSessionAction(sessionId: string, kind: PendingSessionActionKind, opts?: PendingSessionActionOptions): number;
+    clearSessionAction(sessionId: string): void;
+    clearSessionActionIfToken(sessionId: string, token: number): boolean;
+    setServiceAction(serviceId: string, kind: PendingServiceActionKind, opts?: PendingServiceActionOptions): number;
+    clearServiceAction(serviceId: string): void;
+    clearServiceActionIfToken(serviceId: string, token: number): boolean;
+    clearWorktreeActionIfToken(path: string | undefined, token: number): boolean;
+    setWorktreeAction(path: string | undefined, kind: PendingWorktreeActionKind, opts?: PendingWorktreeActionOptions): number;
+    clearWorktreeAction(path: string | undefined): void;
+    getSessionAction(sessionId: string): PendingSessionActionKind | undefined;
+    getServiceAction(serviceId: string): PendingServiceActionKind | undefined;
+    getWorktreeAction(path: string | undefined): PendingWorktreeActionKind | undefined;
+    private setEntry;
+    private clearEntry;
+    private clearEntryIfToken;
     getVersion(): number;
-    applyToSessions(sessions: DashboardSession[]): DashboardSession[];
+    applyToSessions(sessions: DashboardSession[], opts?: ApplyPendingSessionOptions): DashboardSession[];
     applyToServices(services: DashboardService[]): DashboardService[];
     applyToWorktrees(worktrees: WorktreeGroup[]): WorktreeGroup[];
-    settleCreatePending(itemId: string, onSettled: () => void, opts?: {
+    settleCreatePending(target: PendingActionTarget, itemId: string, onSettled: () => void, opts?: {
         isSettled?: () => boolean | Promise<boolean>;
         timeoutMs?: number;
+        expectedToken?: number;
     }): void;
 }
+export {};

package/dist/dashboard/pending-actions.js

@@ -1,76 +1,178 @@
+function isTeammateSessionSeed(session) {
+    return Boolean(session?.team?.parentSessionId);
+}
+function visibleEntryKey(entry) {
+    if (!entry)
+        return "";
+    return JSON.stringify({
+        target: entry.target,
+        kind: entry.kind,
+        sessionSeed: entry.sessionSeed,
+        serviceSeed: entry.serviceSeed,
+        worktreeSeed: entry.worktreeSeed,
+    });
+}
 function canSynthesizeMissingSession(kind) {
-    return (kind === "creating" || kind === "forking" || kind === "migrating" || kind === "starting" || kind === "stopping");
+    return kind === "creating" || kind === "forking";
 }
 function canSynthesizeMissingService(kind) {
     return kind === "creating" || kind === "starting" || kind === "stopping";
 }
+function canSynthesizeMissingWorktree(kind) {
+    return kind === "creating";
+}
 export class DashboardPendingActions {
     onChange;
     actions = new Map();
     version = 0;
+    nextEntryToken = 0;
     constructor(onChange) {
         this.onChange = onChange;
     }
     static worktreeKey(path) {
         return `worktree:${path ?? "__main__"}`;
     }
-    set(sessionId, kind, opts) {
-        const existing = this.actions.get(sessionId);
-        const previousKind = existing?.kind;
+    static actionKey(target, id) {
+        return `${target}:${id}`;
+    }
+    setSessionAction(sessionId, kind, opts) {
+        return this.setEntry("session", sessionId, kind, opts);
+    }
+    clearSessionAction(sessionId) {
+        this.clearEntry("session", sessionId);
+    }
+    clearSessionActionIfToken(sessionId, token) {
+        return this.clearEntryIfToken("session", sessionId, token);
+    }
+    setServiceAction(serviceId, kind, opts) {
+        return this.setEntry("service", serviceId, kind, opts);
+    }
+    clearServiceAction(serviceId) {
+        this.clearEntry("service", serviceId);
+    }
+    clearServiceActionIfToken(serviceId, token) {
+        return this.clearEntryIfToken("service", serviceId, token);
+    }
+    clearWorktreeActionIfToken(path, token) {
+        return this.clearEntryIfToken("worktree", DashboardPendingActions.worktreeKey(path), token);
+    }
+    setWorktreeAction(path, kind, opts) {
+        return this.setEntry("worktree", DashboardPendingActions.worktreeKey(path), kind, opts);
+    }
+    clearWorktreeAction(path) {
+        this.clearEntry("worktree", DashboardPendingActions.worktreeKey(path));
+    }
+    getSessionAction(sessionId) {
+        const entry = this.actions.get(DashboardPendingActions.actionKey("session", sessionId));
+        return entry?.target === "session" ? entry.kind : undefined;
+    }
+    getServiceAction(serviceId) {
+        const entry = this.actions.get(DashboardPendingActions.actionKey("service", serviceId));
+        return entry?.target === "service" ? entry.kind : undefined;
+    }
+    getWorktreeAction(path) {
+        const entry = this.actions.get(DashboardPendingActions.actionKey("worktree", DashboardPendingActions.worktreeKey(path)));
+        return entry?.target === "worktree" ? entry.kind : undefined;
+    }
+    setEntry(target, id, kind, opts) {
+        const key = DashboardPendingActions.actionKey(target, id);
+        const existing = this.actions.get(key);
+        const previousVisibleKey = visibleEntryKey(existing);
         if (existing?.timeoutId) {
             clearTimeout(existing.timeoutId);
         }
-        if (kind) {
-            let timeoutId;
-            if (opts?.timeoutMs && opts.timeoutMs > 0) {
-                timeoutId = setTimeout(() => {
-                    const current = this.actions.get(sessionId);
-                    if (current?.kind !== kind)
-                        return;
-                    this.actions.delete(sessionId);
+        const token = ++this.nextEntryToken;
+        let timeoutId;
+        if (opts?.timeoutMs && opts.timeoutMs > 0) {
+            timeoutId = setTimeout(() => {
+                const current = this.actions.get(key);
+                if (current?.target !== target || current.kind !== kind || current.token !== token)
+                    return;
+                this.actions.delete(key);
+                this.version += 1;
+                try {
                     opts.onTimeout?.();
+                }
+                finally {
                     this.onChange();
-                }, opts.timeoutMs);
-            }
-            this.actions.set(sessionId, { kind, timeoutId, sessionSeed: opts?.sessionSeed, serviceSeed: opts?.serviceSeed });
+                }
+            }, opts.timeoutMs);
         }
-        else {
-            this.actions.delete(sessionId);
+        this.actions.set(key, {
+            target,
+            kind,
+            token,
+            timeoutId,
+            sessionSeed: opts?.sessionSeed,
+            serviceSeed: opts?.serviceSeed,
+            worktreeSeed: opts?.worktreeSeed,
+        });
+        const changed = previousVisibleKey !== visibleEntryKey(this.actions.get(key));
+        if (changed) {
+            this.version += 1;
+            this.onChange();
+        }
+        return token;
+    }
+    clearEntry(target, id) {
+        const key = DashboardPendingActions.actionKey(target, id);
+        const existing = this.actions.get(key);
+        const previousVisibleKey = visibleEntryKey(existing);
+        if (existing?.timeoutId) {
+            clearTimeout(existing.timeoutId);
         }
-        if (previousKind !== kind) {
+        this.actions.delete(key);
+        const changed = previousVisibleKey !== visibleEntryKey(this.actions.get(key));
+        if (changed) {
             this.version += 1;
+            this.onChange();
         }
-        this.onChange();
     }
-    get(sessionId) {
-        return this.actions.get(sessionId)?.kind;
+    clearEntryIfToken(target, id, token) {
+        const key = DashboardPendingActions.actionKey(target, id);
+        const existing = this.actions.get(key);
+        if (!existing || existing.target !== target || existing.token !== token)
+            return false;
+        this.clearEntry(target, id);
+        return true;
     }
     getVersion() {
         return this.version;
     }
-    applyToSessions(sessions) {
+    applyToSessions(sessions, opts = {}) {
         if (this.actions.size === 0)
             return sessions;
         const seen = new Set();
         const applied = sessions.map((session) => {
             seen.add(session.id);
-            const pendingAction = this.actions.get(session.id)?.kind;
-            if (pendingAction === "removing")
-                return session;
+            const pendingAction = this.getSessionAction(session.id);
             if (!pendingAction)
                 return session;
-            return { ...session, pendingAction, optimistic: true };
+            return {
+                ...session,
+                pending: true,
+                pendingAction,
+                optimistic: true,
+            };
         });
-        for (const [sessionId, entry] of this.actions.entries()) {
+        for (const [entryKey, entry] of this.actions.entries()) {
+            if (entry.target !== "session")
+                continue;
+            const sessionId = entryKey.slice("session:".length);
             if (seen.has(sessionId))
                 continue;
             if (!entry.sessionSeed)
                 continue;
+            if (isTeammateSessionSeed(entry.sessionSeed) && !opts.includeTeammates)
+                continue;
+            if (!isTeammateSessionSeed(entry.sessionSeed) && opts.includeTeammates)
+                continue;
             if (!canSynthesizeMissingSession(entry.kind))
                 continue;
             applied.push({
                 ...entry.sessionSeed,
                 id: sessionId,
+                pending: true,
                 pendingAction: entry.kind,
                 optimistic: true,
             });
@@ -83,14 +185,15 @@ export class DashboardPendingActions {
         const seen = new Set();
         const applied = services.map((service) => {
             seen.add(service.id);
-            const pendingAction = this.actions.get(service.id)?.kind;
-            if (pendingAction === "removing")
-                return service;
+            const pendingAction = this.getServiceAction(service.id);
             if (!pendingAction)
                 return service;
-            return { ...service, pendingAction, optimistic: true };
+            return { ...service, pending: true, pendingAction, optimistic: true };
         });
-        for (const [serviceId, entry] of this.actions.entries()) {
+        for (const [entryKey, entry] of this.actions.entries()) {
+            if (entry.target !== "service")
+                continue;
+            const serviceId = entryKey.slice("service:".length);
             if (seen.has(serviceId))
                 continue;
             if (!entry.serviceSeed)
@@ -100,6 +203,7 @@ export class DashboardPendingActions {
             applied.push({
                 ...entry.serviceSeed,
                 id: serviceId,
+                pending: true,
                 pendingAction: entry.kind,
                 optimistic: true,
             });
@@ -109,8 +213,10 @@ export class DashboardPendingActions {
     applyToWorktrees(worktrees) {
         if (this.actions.size === 0)
             return worktrees;
-        return worktrees.map((worktree) => {
-            const pendingAction = this.actions.get(DashboardPendingActions.worktreeKey(worktree.path))?.kind;
+        const seen = new Set();
+        const applied = worktrees.map((worktree) => {
+            seen.add(DashboardPendingActions.worktreeKey(worktree.path));
+            const pendingAction = this.getWorktreeAction(worktree.path);
             if (!pendingAction)
                 return worktree;
             return {
@@ -123,11 +229,30 @@ export class DashboardPendingActions {
                 optimistic: true,
             };
         });
+        for (const [entryKey, entry] of this.actions.entries()) {
+            if (entry.target !== "worktree")
+                continue;
+            const worktreeKey = entryKey.slice("worktree:".length);
+            if (seen.has(worktreeKey))
+                continue;
+            if (!entry.worktreeSeed)
+                continue;
+            if (!canSynthesizeMissingWorktree(entry.kind))
+                continue;
+            applied.push({
+                ...entry.worktreeSeed,
+                pending: true,
+                pendingAction: entry.kind,
+                optimistic: true,
+            });
+        }
+        return applied;
     }
-    settleCreatePending(itemId, onSettled, opts) {
+    settleCreatePending(target, itemId, onSettled, opts) {
         const minVisibleMs = 250;
         const timeoutMs = opts?.timeoutMs ?? 10_000;
         const startedAt = Date.now();
+        const expectedToken = opts?.expectedToken ?? this.actions.get(DashboardPendingActions.actionKey(target, itemId))?.token;
         void (async () => {
             const remaining = minVisibleMs - (Date.now() - startedAt);
             if (remaining > 0) {
@@ -141,9 +266,13 @@ export class DashboardPendingActions {
                     await new Promise((resolve) => setTimeout(resolve, 100));
                 }
             }
-            this.set(itemId, null);
+            if (expectedToken !== undefined && !this.clearEntryIfToken(target, itemId, expectedToken)) {
+                return;
+            }
+            if (expectedToken === undefined) {
+                this.clearEntry(target, itemId);
+            }
             onSettled();
         })();
     }
 }
-//# sourceMappingURL=pending-actions.js.map

package/dist/dashboard/quick-jump.d.ts

@@ -1,5 +1,6 @@
 import type { DashboardService, DashboardSession, MainCheckoutInfo, WorktreeGroup } from "./index.js";
 import type { DashboardOperationFailure } from "./operation-failures.js";
+import type { PendingWorktreeActionKind } from "../pending-actions.js";
 export declare const DASHBOARD_QUICK_JUMP_TIMEOUT_MS = 1000;
 export declare const DASHBOARD_QUICK_JUMP_LIMIT = 9;
 export interface DashboardQuickJumpEntry {
@@ -14,7 +15,7 @@ export interface DashboardQuickJumpWorktree {
     branch: string;
     pending?: boolean;
     removing?: boolean;
-    pendingAction?: "creating" | "removing" | "graveyarding";
+    pendingAction?: PendingWorktreeActionKind;
     operationFailure?: DashboardOperationFailure;
     sessions: DashboardSession[];
     services: DashboardService[];

package/dist/dashboard/quick-jump.js

@@ -20,6 +20,9 @@ function buildEntryList(sessions, services) {
     }
     return entries;
 }
+function entriesForGroup(orderedGroupEntries, fallbackEntries) {
+    return orderedGroupEntries.length > 0 ? orderedGroupEntries : (fallbackEntries ?? []);
+}
 export function buildDashboardQuickJumpWorktrees(input) {
     const wtSessionMap = new Map();
     const wtServiceMap = new Map();
@@ -70,8 +73,8 @@ export function buildDashboardQuickJumpWorktrees(input) {
             removing: mainGroup.removing,
             pendingAction: mainGroup.pendingAction,
             operationFailure: mainGroup.operationFailure,
-            sessions: sortDashboardEntriesByCreatedAt(mainSessions),
-            services: sortDashboardEntriesByCreatedAt(mainServices),
+            sessions: entriesForGroup(mainGroup.sessions, sortDashboardEntriesByCreatedAt(mainSessions)),
+            services: entriesForGroup(mainGroup.services, sortDashboardEntriesByCreatedAt(mainServices)),
         });
     }
     else {
@@ -95,8 +98,8 @@ export function buildDashboardQuickJumpWorktrees(input) {
             removing: group.removing,
             pendingAction: group.pendingAction,
             operationFailure: group.operationFailure,
-            sessions: wtSessionMap.get(group.path) ?? [],
-            services: wtServiceMap.get(group.path) ?? [],
+            sessions: entriesForGroup(group.sessions, wtSessionMap.get(group.path)),
+            services: entriesForGroup(group.services, wtServiceMap.get(group.path)),
         });
         renderedPaths.add(group.path);
     }
@@ -140,4 +143,3 @@ export function resolveDashboardQuickJumpTarget(worktrees, digits) {
     }
     return { kind: "entry", worktree, entry: worktree.entries[entryIndex], entryIndex };
 }
-//# sourceMappingURL=quick-jump.js.map

package/dist/dashboard/runtime-evidence.js

@@ -19,4 +19,3 @@ export function isLiveDashboardServiceRuntimeEntry(entry) {
         return true;
     return hasRuntimeEvidence(entry);
 }
-//# sourceMappingURL=runtime-evidence.js.map

package/dist/dashboard/session-actions.d.ts

@@ -1,4 +1,4 @@
-import type { PendingDashboardActionKind } from "./pending-actions.js";
+import type { PendingSessionActionKind } from "../pending-actions.js";
 import type { SessionRuntime } from "../session-runtime.js";
 export interface DashboardOfflineEntryLike {
     id: string;
@@ -7,9 +7,9 @@ export interface DashboardOfflineEntryLike {
 }
 interface DashboardActionDeps {
     getSessionLabel(sessionId: string): string | undefined;
-    getPendingAction(sessionId: string): PendingDashboardActionKind | undefined;
-    setPendingAction(sessionId: string, kind: PendingDashboardActionKind | null): void;
-    stopSessionToOffline(session: SessionRuntime): void;
+    getPendingAction(sessionId: string): PendingSessionActionKind | undefined;
+    setPendingAction(sessionId: string, kind: PendingSessionActionKind | null): void;
+    stopSessionToOffline(session: SessionRuntime): void | Promise<void>;
     isGraveyardAfterStop(sessionId: string): boolean;
     sendAgentToGraveyard(sessionId: string): Promise<void>;
     resumeOfflineSession(session: DashboardOfflineEntryLike): void | Promise<void>;

package/dist/dashboard/session-actions.js

@@ -24,7 +24,7 @@ export async function stopSessionToOfflineWithFeedback(deps, session) {
     const label = deps.getSessionLabel(session.id) ?? session.command;
     deps.setPendingAction(session.id, "stopping");
     try {
-        deps.stopSessionToOffline(session);
+        await deps.stopSessionToOffline(session);
         await waitForSessionExit(session);
         if (!deps.isGraveyardAfterStop(session.id)) {
             deps.setPendingAction(session.id, null);
@@ -81,4 +81,3 @@ export async function resumeOfflineSessionWithFeedback(deps, session) {
         deps.renderDashboard();
     }
 }
-//# sourceMappingURL=session-actions.js.map