aimux-cli 0.1.16 → 0.1.19

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

@@ -1,11 +1,12 @@
 import type { DashboardSession } from "./index.js";
 import type { SessionState } from "../multiplexer/index.js";
-import type { InstanceInfo } from "../instance-registry.js";
+import type { SessionTeamMetadata } from "../team.js";
 export interface DashboardLocalSession {
     id: string;
     command: string;
     tmuxWindowId?: string;
     backendSessionId?: string;
+    team?: SessionTeamMetadata;
     createdAt?: string;
     status: DashboardSession["status"];
     worktreePath?: string;
@@ -14,9 +15,9 @@ export interface DashboardSessionRegistryOptions {
     sessions: DashboardLocalSession[];
     activeIndex: number;
     offlineSessions: SessionState[];
-    remoteInstances: InstanceInfo[];
     hiddenWorktreePaths?: Set<string>;
     mainRepoPath?: string;
+    includeTeammates?: boolean;
     getSessionLabel: (sessionId: string) => string | undefined;
     getSessionHeadline: (sessionId: string) => string | undefined;
     getSessionTaskDescription: (sessionId: string) => string | undefined;
@@ -44,6 +45,6 @@ export interface DashboardSessionRegistryOptions {
         threadName?: string;
     } | undefined;
 }
-export declare function getRemoteOwnedSessionKeys(remoteInstances: InstanceInfo[]): Set<string>;
 export declare function buildDashboardSessions(options: DashboardSessionRegistryOptions): DashboardSession[];
 export declare function orderDashboardSessionsByVisualWorktree(sessions: DashboardSession[], worktreePaths: Array<string | undefined>, mainRepoPath?: string): DashboardSession[];
+export declare function selectDashboardTeammates(sessions: DashboardSession[], parentSession: Pick<DashboardSession, "id" | "team"> | undefined): DashboardSession[];

package/dist/dashboard/session-registry.js

@@ -1,22 +1,15 @@
 import { existsSync } from "node:fs";
+import { compareTeammateSessions, isTeammateSession } from "../team.js";
 import { listWorktrees as listAllWorktrees } from "../worktree.js";
-export function getRemoteOwnedSessionKeys(remoteInstances) {
-    const owned = new Set();
-    for (const inst of remoteInstances) {
-        for (const session of inst.sessions) {
-            owned.add(session.id);
-            if (session.backendSessionId)
-                owned.add(session.backendSessionId);
-        }
-    }
-    return owned;
-}
 export function buildDashboardSessions(options) {
     const normalizeWtPath = normalizeWorktreePathFactory(options.mainRepoPath);
     const hiddenWorktreePaths = options.hiddenWorktreePaths ?? new Set();
     const seenLocalSessionKeys = new Set();
+    const includeTeammates = options.includeTeammates ?? false;
     const dashSessions = [];
     for (const [index, session] of options.sessions.entries()) {
+        if (!includeTeammates && isTeammateSession(session))
+            continue;
         const normalizedWorktreePath = normalizeWtPath(session.worktreePath);
         if (normalizedWorktreePath && hiddenWorktreePaths.has(normalizedWorktreePath))
             continue;
@@ -30,6 +23,7 @@ export function buildDashboardSessions(options) {
             command: session.command,
             tmuxWindowId: session.tmuxWindowId,
             backendSessionId: session.backendSessionId,
+            team: session.team,
             createdAt: session.createdAt,
             status: session.status,
             active: index === options.activeIndex,
@@ -54,45 +48,9 @@ export function buildDashboardSessions(options) {
             threadName: options.getSessionDerived(session.id)?.threadName,
         });
     }
-    for (const inst of options.remoteInstances) {
-        for (const session of inst.sessions) {
-            const normalizedWorktreePath = normalizeWtPath(session.worktreePath);
-            if (normalizedWorktreePath && hiddenWorktreePaths.has(normalizedWorktreePath))
-                continue;
-            if (dashSessions.some((existing) => existing.id === session.id))
-                continue;
-            dashSessions.push({
-                index: dashSessions.length,
-                id: session.id,
-                command: session.tool,
-                backendSessionId: session.backendSessionId,
-                createdAt: session.createdAt,
-                status: "running",
-                active: false,
-                worktreePath: normalizedWorktreePath,
-                remoteInstancePid: inst.pid,
-                remoteInstanceId: inst.instanceId,
-                remoteBackendSessionId: session.backendSessionId,
-                label: options.getSessionLabel(session.id),
-                headline: options.getSessionHeadline(session.id),
-                cwd: options.getSessionContext(session.id)?.cwd,
-                repoOwner: options.getSessionContext(session.id)?.repo?.owner,
-                repoName: options.getSessionContext(session.id)?.repo?.name,
-                repoRemote: options.getSessionContext(session.id)?.repo?.remote,
-                prNumber: options.getSessionContext(session.id)?.pr?.number,
-                prTitle: options.getSessionContext(session.id)?.pr?.title,
-                prUrl: options.getSessionContext(session.id)?.pr?.url,
-                activity: options.getSessionDerived(session.id)?.activity,
-                attention: options.getSessionDerived(session.id)?.attention,
-                unseenCount: options.getSessionDerived(session.id)?.unseenCount,
-                lastEvent: options.getSessionDerived(session.id)?.lastEvent,
-                services: options.getSessionDerived(session.id)?.services,
-                threadId: options.getSessionDerived(session.id)?.threadId,
-                threadName: options.getSessionDerived(session.id)?.threadName,
-            });
-        }
-    }
     for (const offline of options.offlineSessions) {
+        if (!includeTeammates && isTeammateSession(offline))
+            continue;
         const alreadyShown = dashSessions.some((session) => session.id === offline.id ||
             (offline.backendSessionId && session.backendSessionId === offline.backendSessionId));
         if (alreadyShown)
@@ -108,13 +66,13 @@ export function buildDashboardSessions(options) {
             id: offline.id,
             command: offline.command,
             backendSessionId: offline.backendSessionId,
+            team: offline.team,
             createdAt: offline.createdAt,
             status: "offline",
             active: false,
             worktreePath,
             worktreeName: worktreeInfo?.name,
             worktreeBranch: worktreeInfo?.branch,
-            remoteBackendSessionId: offline.backendSessionId,
             label: offline.label,
             headline: offline.headline,
             cwd: options.getSessionContext(offline.id)?.cwd,
@@ -159,6 +117,14 @@ export function orderDashboardSessionsByVisualWorktree(sessions, worktreePaths,
     }
     return ordered;
 }
+export function selectDashboardTeammates(sessions, parentSession) {
+    if (!parentSession || isTeammateSession(parentSession))
+        return [];
+    return sessions
+        .filter((session) => session.team?.parentSessionId === parentSession.id)
+        .sort(compareTeammateSessions)
+        .map((session, index) => ({ ...session, index }));
+}
 function normalizeWorktreePathFactory(mainRepoPath) {
     return (path) => (path && mainRepoPath && path === mainRepoPath ? undefined : path);
 }
@@ -178,4 +144,3 @@ function resolveWorktreeInfo(worktreePath) {
         return undefined;
     return { name, branch: "unknown" };
 }
-//# sourceMappingURL=session-registry.js.map

package/dist/dashboard/sort.js

@@ -11,4 +11,3 @@ export function dashboardCreatedSortKey(entry) {
 export function sortDashboardEntriesByCreatedAt(entries) {
     return [...entries].sort((a, b) => dashboardCreatedSortKey(b) - dashboardCreatedSortKey(a));
 }
-//# sourceMappingURL=sort.js.map

package/dist/dashboard/state.d.ts

@@ -1,7 +1,7 @@
 import type { DashboardSession, DashboardWorktreeEntry } from "./index.js";
 export type DashboardScreen = "dashboard" | "activity" | "workflow" | "threads" | "notifications" | "plans" | "graveyard" | "help";
 export type DashboardLevel = "worktrees" | "sessions";
-export type DashboardOverlayKind = "none" | "tool-picker" | "tool-options" | "worktree-input" | "service-input" | "label-input" | "orchestration-input" | "orchestration-route-picker" | "worktree-list" | "worktree-remove-confirm" | "migrate-picker" | "thread-reply" | "notification-panel" | "switcher";
+export type DashboardOverlayKind = "none" | "tool-picker" | "tool-options" | "worktree-input" | "service-input" | "label-input" | "orchestration-input" | "orchestration-route-picker" | "worktree-list" | "worktree-remove-confirm" | "migrate-picker" | "thread-reply" | "notification-panel" | "teammate-picker" | "switcher";
 export declare class DashboardState {
     screen: DashboardScreen;
     detailsSidebarVisible: boolean;

package/dist/dashboard/state.js

@@ -56,4 +56,3 @@ export class DashboardOverlayState {
         this.version += 1;
     }
 }
-//# sourceMappingURL=state.js.map

package/dist/dashboard/targets.js

@@ -125,4 +125,3 @@ export function openDashboardTarget(projectRoot, tmux, options = {}) {
     });
     return resolved;
 }
-//# sourceMappingURL=targets.js.map

package/dist/dashboard/ui-state-store.d.ts

@@ -1,12 +1,27 @@
-import type { DashboardSession } from "./index.js";
+import type { DashboardService, DashboardSession, WorktreeGroup } from "./index.js";
+import { type DashboardOrderDirection, type DashboardOrderKind, type DashboardOrderState } from "./order.js";
 import { type DashboardState } from "./state.js";
 export declare class DashboardUiStateStore {
     private preferredSelection;
     private flatSessionId;
     private selectionNeedsRestore;
+    private orderState;
+    loadSharedState(state?: DashboardState): void;
     loadInto(state: DashboardState, clientKey: string): void;
     persist(mode: "dashboard" | "project-service", clientKey: string, state: DashboardState, activeIndex: number, dashSessions: DashboardSession[]): void;
     preferEntrySelection(state: DashboardState, kind: "session" | "service", id: string, worktreePath?: string): void;
     markSelectionDirty(): void;
     consumeSelectionRestore(state: DashboardState, dashSessions: DashboardSession[], hasWorktrees: boolean, activeIndex: number, setActiveIndex: (value: number) => void): void;
+    getOrderState(): DashboardOrderState;
+    orderWorktreeGroups(groups: WorktreeGroup[]): WorktreeGroup[];
+    orderSessionsForWorktree(sessions: DashboardSession[], worktreePath: string | undefined): DashboardSession[];
+    orderServicesForWorktree(services: DashboardService[], worktreePath: string | undefined): DashboardService[];
+    moveEntryWithinWorktree(input: {
+        kind: DashboardOrderKind;
+        worktreePath: string | undefined;
+        selectedId: string;
+        direction: DashboardOrderDirection;
+        sessions: DashboardSession[];
+        services: DashboardService[];
+    }): boolean;
 }

package/dist/dashboard/ui-state-store.js

@@ -1,18 +1,34 @@
 import { readFileSync, writeFileSync } from "node:fs";
+import { dashboardOrderKey, moveDashboardOrder, orderDashboardServicesForWorktree, orderDashboardSessionsForWorktree, orderDashboardWorktreeGroups, } from "./order.js";
 import { getDashboardClientUiStatePath, getDashboardUiStatePath } from "../paths.js";
 export class DashboardUiStateStore {
     preferredSelection = null;
     flatSessionId = null;
     selectionNeedsRestore = true;
-    loadInto(state, clientKey) {
+    orderState = {
+        agentOrderByWorktreeKey: {},
+        serviceOrderByWorktreeKey: {},
+    };
+    loadSharedState(state) {
+        this.orderState = {
+            agentOrderByWorktreeKey: {},
+            serviceOrderByWorktreeKey: {},
+        };
         try {
             const raw = readFileSync(getDashboardUiStatePath(), "utf-8");
             const snapshot = JSON.parse(raw);
-            if (typeof snapshot.detailsSidebarVisible === "boolean") {
+            if (state && typeof snapshot.detailsSidebarVisible === "boolean") {
                 state.detailsSidebarVisible = snapshot.detailsSidebarVisible;
             }
+            this.orderState = {
+                agentOrderByWorktreeKey: sanitizeOrderMap(snapshot.agentOrderByWorktreeKey),
+                serviceOrderByWorktreeKey: sanitizeOrderMap(snapshot.serviceOrderByWorktreeKey),
+            };
         }
         catch { }
+    }
+    loadInto(state, clientKey) {
+        this.loadSharedState(state);
         try {
             const raw = readFileSync(getDashboardClientUiStatePath(clientKey), "utf-8");
             const snapshot = JSON.parse(raw);
@@ -44,6 +60,12 @@ export class DashboardUiStateStore {
             return;
         const sharedSnapshot = {
             detailsSidebarVisible: state.detailsSidebarVisible,
+            ...(hasOrderEntries(this.orderState.agentOrderByWorktreeKey)
+                ? { agentOrderByWorktreeKey: this.orderState.agentOrderByWorktreeKey }
+                : {}),
+            ...(hasOrderEntries(this.orderState.serviceOrderByWorktreeKey)
+                ? { serviceOrderByWorktreeKey: this.orderState.serviceOrderByWorktreeKey }
+                : {}),
         };
         const clientSnapshot = {
             screen: state.screen,
@@ -111,5 +133,53 @@ export class DashboardUiStateStore {
         }
         this.selectionNeedsRestore = false;
     }
+    getOrderState() {
+        return {
+            agentOrderByWorktreeKey: { ...this.orderState.agentOrderByWorktreeKey },
+            serviceOrderByWorktreeKey: { ...this.orderState.serviceOrderByWorktreeKey },
+        };
+    }
+    orderWorktreeGroups(groups) {
+        return orderDashboardWorktreeGroups(groups, this.orderState);
+    }
+    orderSessionsForWorktree(sessions, worktreePath) {
+        return orderDashboardSessionsForWorktree(sessions, worktreePath, this.orderState);
+    }
+    orderServicesForWorktree(services, worktreePath) {
+        return orderDashboardServicesForWorktree(services, worktreePath, this.orderState);
+    }
+    moveEntryWithinWorktree(input) {
+        const key = dashboardOrderKey(input.worktreePath);
+        if (input.kind === "session") {
+            const result = moveDashboardOrder(input.sessions, this.orderState.agentOrderByWorktreeKey[key], input.selectedId, input.direction);
+            this.orderState.agentOrderByWorktreeKey = {
+                ...this.orderState.agentOrderByWorktreeKey,
+                [key]: result.order,
+            };
+            return result.moved;
+        }
+        const result = moveDashboardOrder(input.services, this.orderState.serviceOrderByWorktreeKey[key], input.selectedId, input.direction);
+        this.orderState.serviceOrderByWorktreeKey = {
+            ...this.orderState.serviceOrderByWorktreeKey,
+            [key]: result.order,
+        };
+        return result.moved;
+    }
+}
+function sanitizeOrderMap(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const output = {};
+    for (const [key, ids] of Object.entries(value)) {
+        if (!Array.isArray(ids))
+            continue;
+        const cleanIds = ids.filter((id) => typeof id === "string" && id.length > 0);
+        if (cleanIds.length > 0) {
+            output[key] = cleanIds;
+        }
+    }
+    return output;
+}
+function hasOrderEntries(value) {
+    return Object.values(value).some((ids) => ids.length > 0);
 }
-//# sourceMappingURL=ui-state-store.js.map

package/dist/debug-state.d.ts

@@ -0,0 +1,97 @@
+import { type ReadOnlyProjectPaths } from "./paths.js";
+import { type TmuxWindowMetadata, type TmuxTarget } from "./tmux/runtime-manager.js";
+import { type WorktreeInfo } from "./worktree.js";
+type SourceStatus = "found" | "missing" | "unavailable" | "error";
+type SourceRole = "authority" | "projection" | "cache" | "substrate" | "legacy" | "unavailable";
+type TargetResolutionStatus = "matched" | "missing" | "ambiguous";
+type TargetKind = "session" | "service" | "worktree" | "backend-session" | "notification" | "operation-failure" | "tmux-window";
+type DebugStateSourceKey = "savedState" | "runtimeTopology" | "metadata" | "tmux" | "gitWorktrees" | "graveyard" | "worktreeGraveyard" | "notifications" | "operationFailures" | "runtimeRows" | "pendingActions" | "dashboardSnapshot";
+export interface SourceResult<T> {
+    status: SourceStatus;
+    path?: string;
+    reason?: string;
+    error?: string;
+    value?: T;
+}
+export interface SourceRoleDescriptor {
+    role: SourceRole;
+    authority?: string;
+    note: string;
+}
+export interface TargetMatch {
+    canonicalKey: string;
+    kind: TargetKind;
+    source: string;
+    id?: string;
+    backendSessionId?: string;
+    worktreePath?: string;
+    worktreeName?: string;
+    label?: string;
+    raw: unknown;
+}
+export interface DebugStateReport {
+    version: 1;
+    target: string;
+    project: {
+        repoRoot: string;
+        projectId: string;
+        projectStateDir: string;
+        localAimuxDir: string;
+    };
+    targetResolution: {
+        status: TargetResolutionStatus;
+        entityCount: number;
+        matches: TargetMatch[];
+    };
+    sourceRoles: Record<DebugStateSourceKey, SourceRoleDescriptor>;
+    sources: {
+        savedState: SourceResult<{
+            services: unknown[];
+        }>;
+        runtimeTopology: SourceResult<{
+            sessions: unknown[];
+            services: unknown[];
+            worktrees: unknown[];
+        }>;
+        metadata: SourceResult<{
+            sessions: unknown[];
+        }>;
+        tmux: SourceResult<{
+            windows: Array<{
+                target: TmuxTarget;
+                metadata: TmuxWindowMetadata;
+            }>;
+        }>;
+        gitWorktrees: SourceResult<{
+            worktrees: WorktreeInfo[];
+        }>;
+        graveyard: SourceResult<{
+            entries: unknown[];
+        }>;
+        worktreeGraveyard: SourceResult<{
+            entries: unknown[];
+        }>;
+        notifications: SourceResult<{
+            notifications: unknown[];
+        }>;
+        operationFailures: SourceResult<{
+            failures: unknown[];
+        }>;
+        runtimeRows: SourceResult<never>;
+        pendingActions: SourceResult<never>;
+        dashboardSnapshot: SourceResult<never>;
+    };
+}
+export interface BuildDebugStateReportOptions {
+    cwd?: string;
+    target: string;
+    paths?: ReadOnlyProjectPaths;
+    tmuxWindows?: Array<{
+        target: TmuxTarget;
+        metadata: TmuxWindowMetadata;
+    }> | Error;
+    worktrees?: WorktreeInfo[] | Error;
+}
+export declare function buildDebugStateReport(options: BuildDebugStateReportOptions): DebugStateReport;
+export declare function renderDebugStateReport(report: DebugStateReport): string;
+export {};