aimux-cli 0.1.16 → 0.1.19

package/dist/tmux/statusline.js

@@ -2,16 +2,28 @@ import { basename } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { getProjectStateDirFor } from "../paths.js";
 import { isDashboardWindowName } from "./runtime-manager.js";
-import { compactSessionTitle, currentPathContext, renderDashboardScreens, renderSemanticBadge, renderSessionCompactHint, resolveExactCurrentSessionId, resolveExactSessionMetadata, resolveScopedSessions, trim, } from "../statusline-model.js";
+import { compactSessionTitle, currentPathContext, findStatuslineSession, renderDashboardScreens, renderSemanticBadge, renderSessionCompactHint, resolveCurrentTeammates, resolveExactCurrentSessionId, resolveExactSessionMetadata, resolveFocusedTeammateGroup, resolveFocusedTeammate, resolveScopedSessions, trim, } from "../statusline-model.js";
 function renderStatusRange(range, label) {
     return `#[range=user|${range}]${label}#[norange]`;
 }
+function sanitizeStatuslineProjection(data) {
+    const sessions = Array.isArray(data.sessions) ? data.sessions : [];
+    const teammates = Array.isArray(data.teammates) ? data.teammates : [];
+    const knownSessionIds = new Set([...sessions, ...teammates].map((session) => session.id).filter(Boolean));
+    const metadata = Object.fromEntries(Object.entries(data.metadata ?? {}).filter(([sessionId]) => knownSessionIds.has(sessionId)));
+    return {
+        ...data,
+        sessions,
+        teammates,
+        metadata,
+    };
+}
 export function loadStatusline(projectRoot) {
     try {
         const path = `${getProjectStateDirFor(projectRoot)}/statusline.json`;
         if (!existsSync(path))
             return null;
-        return JSON.parse(readFileSync(path, "utf-8"));
+        return sanitizeStatuslineProjection(JSON.parse(readFileSync(path, "utf-8")));
     }
     catch {
         return null;
@@ -99,7 +111,7 @@ function renderExactHeadline(data, projectRoot, currentSession, currentWindow, c
     const activeSessionId = resolveExactCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot);
     if (!activeSessionId)
         return null;
-    const session = (data.sessions ?? []).find((entry) => entry.id === activeSessionId);
+    const session = findStatuslineSession(data, activeSessionId);
     const headline = session?.headline?.trim();
     if (!headline)
         return null;
@@ -109,9 +121,7 @@ function renderActiveMetadata(data, projectRoot, currentSession, currentWindow,
     if (currentWindow && isDashboardWindowName(currentWindow))
         return null;
     const activeSessionId = resolveExactCurrentSessionId(data, currentSession, currentWindow, currentWindowId, currentPath, projectRoot);
-    const activeSession = activeSessionId
-        ? (data.sessions ?? []).find((entry) => entry.id === activeSessionId)
-        : undefined;
+    const activeSession = findStatuslineSession(data, activeSessionId);
     const metadata = resolveExactSessionMetadata(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath);
     if (!metadata)
         return null;
@@ -159,6 +169,27 @@ function renderSessionChip(session) {
     const label = trim(`${identity}${hint ? ` ${hint}` : ""}${badge ? ` ${badge}` : ""}`, 28);
     return session.isCurrent ? `#[fg=black,bg=yellow] ${label} #[default]` : label;
 }
+function teammateLabel(session) {
+    return (session.team?.label?.trim() || session.label?.trim() || session.team?.role?.trim() || compactSessionTitle(session));
+}
+function renderTeammateChip(session) {
+    const identity = trim(teammateLabel(session), 18);
+    const hint = renderSessionCompactHint(session);
+    const badge = hint?.includes(" unread") || hint?.includes(" new") ? null : renderSemanticBadge(session.semantic);
+    const label = trim(`${identity}${hint ? ` ${hint}` : ""}${badge ? ` ${badge}` : ""}`, 28);
+    return session.isCurrent ? `#[fg=black,bg=cyan] ${label} #[default]` : `#[fg=cyan]${label}#[default]`;
+}
+function renderTeammateSegment(teammates) {
+    if (teammates.length === 0)
+        return null;
+    const labels = teammates.slice(0, 3).map((teammate) => {
+        const identity = teammateLabel(teammate);
+        const hint = renderSessionCompactHint(teammate) ?? teammate.semantic?.presentation.statusLabel ?? teammate.status;
+        return trim(`${identity}${hint ? ` ${hint}` : ""}`, 24);
+    });
+    const more = teammates.length > labels.length ? ` +${teammates.length - labels.length}` : "";
+    return `team: ${labels.join(", ")}${more}`;
+}
 function visibleSegmentLength(segment) {
     return segment.replace(/#\[[^\]]*]/g, "").length;
 }
@@ -179,21 +210,30 @@ function renderBottomLine(data, projectRoot, currentWindow, currentWindowId, cur
         }
         return chosen.join(separator);
     }
-    const chips = resolveScopedSessions(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath).map(renderSessionChip);
+    const focusedTeammate = resolveFocusedTeammate(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath);
+    const teammateChips = focusedTeammate
+        ? resolveFocusedTeammateGroup(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath)
+        : [];
+    const chips = focusedTeammate
+        ? teammateChips
+        : resolveScopedSessions(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath);
     const headline = renderExactHeadline(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath);
+    const teammateSegment = focusedTeammate
+        ? `#[fg=cyan]team plane#[default]`
+        : renderTeammateSegment(resolveCurrentTeammates(data, projectRoot, currentSession, currentWindow, currentWindowId, currentPath));
     const pluginSegments = renderPluginSegments(data, projectRoot, "bottom", currentSession, currentWindow, currentWindowId, currentPath);
     const chipSeparator = "  ·  ";
     const detailSeparator = "  |  ";
     const chosenChips = [];
     let used = 0;
-    for (const chip of chips) {
+    for (const chip of chips.map(focusedTeammate ? renderTeammateChip : renderSessionChip)) {
         const next = visibleSegmentLength(chip) + (chosenChips.length > 0 ? chipSeparator.length : 0);
         if (used + next > maxWidth)
             break;
         chosenChips.push(chip);
         used += next;
     }
-    const detailParts = [headline, ...pluginSegments].filter((segment) => Boolean(segment));
+    const detailParts = [headline, teammateSegment, ...pluginSegments].filter((segment) => Boolean(segment));
     const detail = detailParts.join("  ·  ");
     if (detail) {
         const headlineWidth = visibleSegmentLength(detail);
@@ -212,4 +252,3 @@ export function renderTmuxStatuslineFromData(data, projectRoot, line, options =
 export function renderTmuxStatusline(projectRoot, line, options = {}) {
     return renderTmuxStatuslineFromData(loadStatusline(projectRoot), projectRoot, line, options);
 }
-//# sourceMappingURL=statusline.js.map

package/dist/tmux/switcher.js

@@ -112,4 +112,3 @@ export async function runTmuxSwitcher(options) {
         process.stdin.on("data", onData);
     });
 }
-//# sourceMappingURL=switcher.js.map

package/dist/tmux/window-open.js

@@ -52,8 +52,7 @@ export function openManagedSessionWindow(tmux, projectRoot, entry) {
         .listProjectManagedWindows(projectRoot)
         .find((candidate) => candidate.metadata.kind === "agent" &&
         ((entry.tmuxWindowId && candidate.target.windowId === entry.tmuxWindowId) ||
-            candidate.metadata.sessionId === entry.id ||
-            (entry.backendSessionId && candidate.metadata.backendSessionId === entry.backendSessionId))) ?? null;
+            candidate.metadata.sessionId === entry.id)) ?? null;
     if (!match)
         return null;
     selectLinkedOrOpenTarget(tmux, match.target);
@@ -68,4 +67,3 @@ export function openManagedServiceWindow(tmux, projectRoot, serviceId) {
     selectLinkedOrOpenTarget(tmux, match.target);
     return match.target;
 }
-//# sourceMappingURL=window-open.js.map

package/dist/tool-output-watchers.d.ts

@@ -1,14 +1,3 @@
-import type { AgentObservation, AgentWatcherContext } from "./agent-watcher.js";
-import type { AimuxPluginInstance } from "./plugin-runtime.js";
-import type { SessionServiceMetadata } from "./metadata-store.js";
-interface PaneSnapshot {
-    fingerprint: string;
-    promptVisible: boolean;
-    errorVisible: boolean;
-    lastObservedAt: number;
-    lastAppliedActivity?: import("./agent-events.js").AgentActivityState;
-    lastAppliedAttention?: import("./agent-events.js").AgentAttentionState;
-}
 export declare function classifyToolPane(tool: string, text: string): {
     promptVisible: boolean;
     errorVisible: boolean;
@@ -16,10 +5,3 @@ export declare function classifyToolPane(tool: string, text: string): {
     updatePromptVisible: boolean;
     blockedMessage?: string;
 };
-export declare function deriveObservation(sessionId: string, tool: string, text: string, previous: PaneSnapshot | undefined): {
-    snapshot: PaneSnapshot;
-    observation?: AgentObservation;
-};
-export declare function extractLocalServices(text: string): SessionServiceMetadata[];
-export declare function createToolOutputWatcher(context: AgentWatcherContext): AimuxPluginInstance;
-export {};

package/dist/tool-output-watchers.js

@@ -1,9 +1,3 @@
-import { createHash } from "node:crypto";
-import { isDashboardWindowName, TmuxRuntimeManager } from "./tmux/runtime-manager.js";
-import { OscNotificationParser } from "./osc-notifications.js";
-function fingerprint(text) {
-    return createHash("sha1").update(text).digest("hex");
-}
 function tailLines(text, count = 12) {
     return text.split("\n").slice(-count);
 }
@@ -88,320 +82,3 @@ export function classifyToolPane(tool, text) {
     const promptVisible = !updatePromptVisible && tracksPromptReadiness(tool) && hasToolInputPrompt(tool, text, lastLine);
     return { promptVisible, errorVisible, interruptedVisible, updatePromptVisible, blockedMessage };
 }
-export function deriveObservation(sessionId, tool, text, previous) {
-    const now = Date.now();
-    const nextFingerprint = fingerprint(text);
-    const { promptVisible, errorVisible, interruptedVisible, updatePromptVisible, blockedMessage } = classifyToolPane(tool, text);
-    const next = {
-        fingerprint: nextFingerprint,
-        promptVisible,
-        errorVisible,
-        lastObservedAt: now,
-        lastAppliedActivity: previous?.lastAppliedActivity,
-        lastAppliedAttention: previous?.lastAppliedAttention,
-    };
-    if (!previous || previous.fingerprint !== nextFingerprint) {
-        if (updatePromptVisible && previous?.lastAppliedAttention !== "blocked") {
-            next.lastAppliedActivity = "waiting";
-            next.lastAppliedAttention = "blocked";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "waiting",
-                    attention: "blocked",
-                    event: {
-                        kind: "blocked",
-                        message: blockedMessage ?? "Tool update required",
-                        source: tool,
-                        tone: "warn",
-                    },
-                },
-            };
-        }
-        if (errorVisible && previous?.errorVisible !== true) {
-            next.lastAppliedActivity = "error";
-            next.lastAppliedAttention = "error";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "error",
-                    attention: "error",
-                    event: {
-                        kind: interruptedVisible ? "interrupted" : "notify",
-                        message: interruptedVisible ? "Conversation interrupted" : "Tool error",
-                        source: tool,
-                        tone: "error",
-                    },
-                },
-            };
-        }
-        if (!errorVisible && previous?.lastAppliedAttention === "error") {
-            if (tracksPromptReadiness(tool)) {
-                if (promptVisible) {
-                    next.lastAppliedActivity = "waiting";
-                    next.lastAppliedAttention = "needs_input";
-                    return {
-                        snapshot: next,
-                        observation: {
-                            sessionId,
-                            tool,
-                            activity: "waiting",
-                            attention: "needs_input",
-                        },
-                    };
-                }
-                next.lastAppliedActivity = "running";
-                next.lastAppliedAttention = "normal";
-                return {
-                    snapshot: next,
-                    observation: {
-                        sessionId,
-                        tool,
-                        activity: "running",
-                        attention: "normal",
-                    },
-                };
-            }
-            next.lastAppliedActivity = previous.lastAppliedActivity === "error" ? undefined : previous.lastAppliedActivity;
-            next.lastAppliedAttention = "normal";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    attention: "normal",
-                },
-            };
-        }
-        if (!updatePromptVisible && previous?.lastAppliedAttention === "blocked") {
-            if (promptVisible) {
-                next.lastAppliedActivity = "waiting";
-                next.lastAppliedAttention = "needs_input";
-                return {
-                    snapshot: next,
-                    observation: {
-                        sessionId,
-                        tool,
-                        activity: "waiting",
-                        attention: "needs_input",
-                    },
-                };
-            }
-            next.lastAppliedActivity = "running";
-            next.lastAppliedAttention = "normal";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "running",
-                    attention: "normal",
-                },
-            };
-        }
-        if (!promptVisible && previous?.promptVisible && previous.lastAppliedAttention === "needs_input") {
-            next.lastAppliedActivity = "running";
-            next.lastAppliedAttention = "normal";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "running",
-                    attention: "normal",
-                },
-            };
-        }
-        if (promptVisible) {
-            next.lastAppliedActivity = "waiting";
-            next.lastAppliedAttention = "needs_input";
-            if (!previous?.promptVisible) {
-                return {
-                    snapshot: next,
-                    observation: {
-                        sessionId,
-                        tool,
-                        activity: "waiting",
-                        attention: "needs_input",
-                        event: {
-                            kind: "needs_input",
-                            message: "Ready for input",
-                            source: tool,
-                            tone: "warn",
-                        },
-                    },
-                };
-            }
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "waiting",
-                    attention: "needs_input",
-                },
-            };
-        }
-        if (tracksPromptReadiness(tool)) {
-            next.lastAppliedActivity = "running";
-            next.lastAppliedAttention = "normal";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "running",
-                    attention: "normal",
-                },
-            };
-        }
-        if (!previous) {
-            next.lastAppliedActivity = "running";
-            next.lastAppliedAttention = "normal";
-            return {
-                snapshot: next,
-                observation: {
-                    sessionId,
-                    tool,
-                    activity: "running",
-                    attention: "normal",
-                },
-            };
-        }
-        next.lastAppliedActivity = previous?.lastAppliedActivity;
-        next.lastAppliedAttention = previous?.lastAppliedAttention;
-        return { snapshot: next };
-    }
-    if (promptVisible && previous?.lastAppliedActivity !== "waiting") {
-        next.lastAppliedActivity = "waiting";
-        next.lastAppliedAttention = "needs_input";
-        return {
-            snapshot: next,
-            observation: {
-                sessionId,
-                tool,
-                activity: "waiting",
-                attention: "needs_input",
-            },
-        };
-    }
-    if (updatePromptVisible && previous?.lastAppliedAttention !== "blocked") {
-        next.lastAppliedActivity = "waiting";
-        next.lastAppliedAttention = "blocked";
-        return {
-            snapshot: next,
-            observation: {
-                sessionId,
-                tool,
-                activity: "waiting",
-                attention: "blocked",
-                event: {
-                    kind: "blocked",
-                    message: blockedMessage ?? "Tool update required",
-                    source: tool,
-                    tone: "warn",
-                },
-            },
-        };
-    }
-    if (errorVisible && previous?.lastAppliedActivity !== "error") {
-        next.lastAppliedActivity = "error";
-        next.lastAppliedAttention = "error";
-        return {
-            snapshot: next,
-            observation: {
-                sessionId,
-                tool,
-                activity: "error",
-                attention: "error",
-            },
-        };
-    }
-    next.lastAppliedActivity = previous?.lastAppliedActivity;
-    next.lastAppliedAttention = previous?.lastAppliedAttention;
-    return { snapshot: next };
-}
-export function extractLocalServices(text) {
-    const services = new Map();
-    const urlMatches = text.match(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+(?:[^\s)]*)?/g) ?? [];
-    for (const url of urlMatches) {
-        const portMatch = url.match(/:(\d+)(?:\/|$)/);
-        const port = portMatch ? Number(portMatch[1]) : undefined;
-        services.set(url, { url, port });
-    }
-    return Array.from(services.values()).slice(0, 3);
-}
-export function createToolOutputWatcher(context) {
-    const snapshots = new Map();
-    const oscParsers = new Map();
-    const rawPaneTexts = new Map();
-    let timer = null;
-    const poll = () => {
-        const tmux = new TmuxRuntimeManager();
-        const sessionName = tmux.getProjectSession(context.api.projectRoot).sessionName;
-        let windows = [];
-        try {
-            windows = tmux.listManagedWindows(sessionName);
-        }
-        catch {
-            return;
-        }
-        for (const { target, metadata } of windows) {
-            if (!metadata.sessionId || isDashboardWindowName(target.windowName))
-                continue;
-            let rawText = "";
-            try {
-                rawText = tmux.captureTarget(target, { startLine: -80, includeEscapes: true });
-            }
-            catch {
-                continue;
-            }
-            const parser = oscParsers.get(metadata.sessionId) ?? new OscNotificationParser();
-            oscParsers.set(metadata.sessionId, parser);
-            const previousRaw = rawPaneTexts.get(metadata.sessionId) ?? "";
-            const delta = rawText.startsWith(previousRaw) ? rawText.slice(previousRaw.length) : rawText;
-            rawPaneTexts.set(metadata.sessionId, rawText);
-            const deltaParsed = parser.parseChunk(delta);
-            for (const notification of deltaParsed.notifications) {
-                context.api.metadata.emitEvent(metadata.sessionId, {
-                    kind: "notify",
-                    message: notification.body || notification.title || "Notification",
-                    source: metadata.command,
-                    tone: "info",
-                });
-            }
-            const text = new OscNotificationParser().parseChunk(rawText).cleaned;
-            context.api.metadata.setServices(metadata.sessionId, extractLocalServices(text));
-            const previous = snapshots.get(metadata.sessionId);
-            const { snapshot, observation } = deriveObservation(metadata.sessionId, metadata.command, text, previous);
-            snapshots.set(metadata.sessionId, snapshot);
-            if (!observation)
-                continue;
-            if (observation.activity)
-                context.api.metadata.setActivity(observation.sessionId, observation.activity);
-            if (observation.attention)
-                context.api.metadata.setAttention(observation.sessionId, observation.attention);
-            if (observation.event)
-                context.api.metadata.emitEvent(observation.sessionId, observation.event);
-        }
-    };
-    return {
-        start() {
-            poll();
-            timer = setInterval(poll, 2000);
-            timer.unref?.();
-        },
-        async stop() {
-            if (timer)
-                clearInterval(timer);
-            timer = null;
-            oscParsers.clear();
-            rawPaneTexts.clear();
-        },
-    };
-}
-//# sourceMappingURL=tool-output-watchers.js.map

package/dist/tui/render/box.js

@@ -36,4 +36,3 @@ export function renderOverlayBox(lines, cols, rows, style = "blue") {
     output += "\x1b8";
     return output;
 }
-//# sourceMappingURL=box.js.map

package/dist/tui/render/text.js

@@ -89,4 +89,3 @@ export function composeTwoPane(left, right, cols) {
     }
     return out;
 }
-//# sourceMappingURL=text.js.map

package/dist/tui/screens/dashboard-renderers.js

@@ -66,6 +66,15 @@ function colorSessionHint(value) {
         return `\x1b[35m${value}\x1b[0m`;
     return `\x1b[2m${value}\x1b[0m`;
 }
+function summarizeTeammate(session, derivedStatusLabel) {
+    const identity = session.team?.label ?? session.label ?? session.command;
+    const role = session.team?.role ?? session.role;
+    const status = derivedStatusLabel(session);
+    const hint = session.semantic?.presentation.compactHint;
+    return [role ? `${identity}(${role})` : identity, status, hint && hint !== status ? hint : undefined]
+        .filter(Boolean)
+        .join(" · ");
+}
 export function renderDashboardFrame(state, cols, rows) {
     const contentWidth = Math.max(72, cols);
     const padBlockLine = (line) => line;
@@ -112,17 +121,6 @@ export function renderDashboardFrame(state, cols, rows) {
             ? ` \x1b[2;33m→ ${truncate(session.workflowNextAction, 24)}\x1b[0m`
             : "";
         const lastUsedHint = session.lastUsedAt ? ` \x1b[2m· ${formatRelativeRecency(session.lastUsedAt)}\x1b[0m` : "";
-        if (session.remoteInstancePid) {
-            const icon = "\x1b[2;36m◈\x1b[0m";
-            const ownerTag = `\x1b[2mother tab (PID ${session.remoteInstancePid})\x1b[0m`;
-            const identity = session.label ?? session.command;
-            const headlineText = session.headline ? ` \x1b[2m· ${truncate(session.headline, 40)}\x1b[0m` : "";
-            const remoteRoleTag = session.role ? ` \x1b[2;36m(${session.role})\x1b[0m` : "";
-            const notificationBadge = session.semantic && session.semantic.notifications.unreadCount > 0
-                ? ` \x1b[36m${Math.min(session.semantic.notifications.unreadCount, 99)}\x1b[0m`
-                : "";
-            return `${indent}${prefix}${icon} ${numberBadge}${identity}${remoteRoleTag}${headlineText}${threadBadge}${pendingBadge}${workflowBadge}${workflowHint}${notificationBadge}${lastUsedHint} — ${ownerTag}`;
-        }
         const icon = colorSessionIcon(session);
         const statusLabel = state.derivedStatusLabel(session);
         const coloredStatusLabel = colorSessionStatus(session, statusLabel);
@@ -147,7 +145,11 @@ export function renderDashboardFrame(state, cols, rows) {
         const numberBadge = quickDigit ? `[${quickDigit}] ` : "";
         const identity = service.label ?? service.command;
         const statusLabel = service.pendingAction ?? service.status;
-        const commandHint = service.foregroundCommand ? ` \x1b[2m· ${truncate(service.foregroundCommand, 22)}\x1b[0m` : "";
+        const commandHint = service.shellCommand
+            ? ` \x1b[2m· ${truncate(service.shellCommand, 36)}\x1b[0m`
+            : service.foregroundCommand
+                ? ` \x1b[2m· ${truncate(service.foregroundCommand, 22)}\x1b[0m`
+                : "";
         const pidHint = service.pid ? ` \x1b[2m(pid ${service.pid})\x1b[0m` : "";
         const previewHint = service.previewLine ? ` \x1b[2m· ${truncate(service.previewLine, 40)}\x1b[0m` : "";
         const lastUsedHint = service.lastUsedAt ? ` \x1b[2m· ${formatRelativeRecency(service.lastUsedAt)}\x1b[0m` : "";
@@ -214,32 +216,29 @@ export function renderDashboardFrame(state, cols, rows) {
             ? "[x] stop"
             : selectedSession?.status === "offline"
                 ? "[x] kill"
-                : selectedSession?.remoteInstancePid
-                    ? ""
-                    : selectedSession
-                        ? "[x] stop"
-                        : "";
-        const rLabel = selectedSession && !selectedSession.remoteInstancePid ? "  [r] name" : "";
+                : selectedSession
+                    ? "[x] stop"
+                    : "";
+        const rLabel = selectedSession ? "  [r] name" : "";
+        const teamLabel = selectedSession && state.selectedTeammates.length > 0 ? "  [e] team" : "";
         const enterLabel = selectedService
             ? "Enter open"
-            : selectedSession?.remoteInstancePid
-                ? "Enter takeover"
-                : selectedSession?.status === "offline"
-                    ? "Enter resume"
-                    : "Enter focus";
+            : selectedSession?.status === "offline"
+                ? "Enter resume"
+                : "Enter focus";
         if (state.sessions.length === 0 && !state.hasWorktrees) {
             return " [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply  [p] plans  [g] graveyard  [?] help  [q] quit ";
         }
         if (state.hasWorktrees && state.navLevel === "sessions") {
             const xPart = xLabel ? `  ${xLabel}` : "";
-            return ` ↑↓ items  1-9/12 jump  ${enterLabel}  Esc back  [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply  [m] migrate${xPart}${rLabel}  [p] plans  [g] graveyard  [?] help  [q] quit `;
+            return ` ↑↓ items  Shift+↑↓ reorder  1-9/12 jump  ${enterLabel}  Esc back  [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply${teamLabel}  [m] migrate${xPart}${rLabel}  [p] plans  [g] graveyard  [?] help  [q] quit `;
         }
         if (state.hasWorktrees) {
             return ` ↑↓ worktrees  1-9/12 jump  Enter step in  [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork(step in)  [w] worktree  [p] plans  [g] graveyard  [?] help  [q] quit `;
         }
         if (state.sessions.length > 0) {
             const xPart = xLabel ? `  ${xLabel}` : "";
-            return ` ↑↓ select  ${enterLabel}  [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply  [w] worktree${xPart}${rLabel}  [p] plans  [g] graveyard  [?] help  [q] quit `;
+            return ` ↑↓ select  ${enterLabel}  [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply${teamLabel}  [w] worktree${xPart}${rLabel}  [p] plans  [g] graveyard  [?] help  [q] quit `;
         }
         return " [u] attention  [a] activity  [t] threads  [i] inbox  [Tab] details  [c] new agent  [v] service  [f] fork  [S] msg  [H] handoff  [T] task  [o] thread  [R] reply  [w] worktree  [p] plans  [g] graveyard  [?] help  [q] quit ";
     };
@@ -321,6 +320,9 @@ export function renderDashboardFrame(state, cols, rows) {
         if (selectedService) {
             lines.push(...wrapKeyValue("Service", `${selectedService.label ?? selectedService.command} (${selectedService.id})`, width));
             lines.push(...wrapKeyValue("Command", selectedService.command, width));
+            if (selectedService.shellCommand) {
+                lines.push(...wrapKeyValue(selectedService.shellCommandState === "running" ? "Running" : "Last command", selectedService.shellCommand, width));
+            }
             if (selectedService.foregroundCommand)
                 lines.push(...wrapKeyValue("Foreground", selectedService.foregroundCommand, width));
             if (selectedService.pid)
@@ -406,6 +408,16 @@ export function renderDashboardFrame(state, cols, rows) {
         if ((selected.services?.length ?? 0) > 0) {
             lines.push(...wrapKeyValue("Services", selected.services.map((s) => s.url ?? `:${s.port}`).join(", "), width));
         }
+        if (state.selectedTeammates.length > 0) {
+            lines.push("");
+            lines.push("\x1b[1mTeam\x1b[0m");
+            for (const teammate of state.selectedTeammates.slice(0, 5)) {
+                lines.push(...wrapKeyValue("-", summarizeTeammate(teammate, state.derivedStatusLabel), width));
+            }
+            if (state.selectedTeammates.length > 5) {
+                lines.push(...wrapKeyValue("-", `${state.selectedTeammates.length - 5} more`, width));
+            }
+        }
         while (lines.length < height)
             lines.push("");
         return lines.slice(0, height);
@@ -479,4 +491,3 @@ export function renderDashboardFrame(state, cols, rows) {
         scrollOffset,
     };
 }
-//# sourceMappingURL=dashboard-renderers.js.map

package/dist/tui/screens/overlay-renderers.d.ts

@@ -12,6 +12,8 @@ export declare function buildDashboardErrorOverlayOutput(ctx: any): string | nul
 export declare function renderDashboardErrorOverlay(ctx: any): void;
 export declare function buildNotificationPanelOverlayOutput(ctx: any): string | null;
 export declare function renderNotificationPanel(ctx: any): void;
+export declare function buildTeammatePickerOverlayOutput(ctx: any): string | null;
+export declare function renderTeammatePickerOverlay(ctx: any): void;
 export declare function buildHelpOverlayOutput(_ctx: any): string;
 export declare function renderHelpOverlay(ctx: any): void;
 export declare function buildSwitcherOverlayOutput(ctx: any): string;