aimux-cli 0.1.16 → 0.1.19

package/dist/session-bootstrap.js

@@ -5,27 +5,57 @@ import { getContextDir, getHistoryDir, getPlansDir, getStatusDir } from "./paths
 import { readHistory } from "./context/history.js";
 import { debug, debugPreamble } from "./debug.js";
 import { listWorktrees as listAllWorktrees } from "./worktree.js";
-import { deliverTmuxPrompt } from "./agent-prompt-delivery.js";
+export function buildAimuxAgentInstructions(opts = {}) {
+    const sessionLine = opts.sessionId ? `Your aimux session ID is ${opts.sessionId}.\n` : "";
+    const sessionPath = opts.sessionId ?? "{session-id}";
+    const includeTeammates = opts.includeTeammateCreationInstructions !== false;
+    const teamCoordinationLine = includeTeammates
+        ? "- Do not directly spawn or control other agents unless the user gives an explicit aimux CLI command.\n" +
+            "- Do not call aimux metadata APIs from inside an agent unless the user gives an explicit CLI/API command.\n"
+        : "- This session is already a teammate; do not create nested teammate teams.\n";
+    const delegationProtocol = includeTeammates
+        ? "When the user specifically asks for delegation, handoff, or teammate coordination, use explicit aimux CLI/API commands so the runtime exchange records the work. " +
+            'For generic delegation or handoff records, create them with `aimux task assign` or the project service task endpoint with `status: "pending"`, `assignedBy`, `description`, `prompt`, and timestamps. '
+        : 'For generic delegation or handoff records, create them with `aimux task assign` or the project service task endpoint with `status: "pending"`, `assignedBy`, `description`, `prompt`, and timestamps. ';
+    return ("You are running inside aimux, an agent multiplexer for this repository. " +
+        "Aimux keeps long-lived Claude, Codex, and shell sessions in the main checkout and git worktrees so the user can switch between them, stop/restart them, and coordinate work.\n" +
+        sessionLine +
+        "\n" +
+        "## Aimux Model\n" +
+        "- The user controls aimux from the dashboard and tmux status/footer UI.\n" +
+        "- Agents are normal tool processes running inside aimux-managed tmux windows.\n" +
+        "- Broad cross-agent coordination uses aimux task, handoff, and thread commands backed by the runtime exchange.\n" +
+        teamCoordinationLine +
+        "\n" +
+        "## Shared Context Files\n" +
+        `- .aimux/context/${sessionPath}/live.md — recent conversation for this session\n` +
+        `- .aimux/context/${sessionPath}/summary.md — compacted history for this session\n` +
+        `- .aimux/plans/${sessionPath}.md — optional shared plan for long-running or delegated work\n` +
+        `- .aimux/status/${sessionPath}.md — optional brief status note for long-running or delegated work\n` +
+        "- .aimux/context/{other-session-id}/ — other agents' context when needed\n" +
+        "- .aimux/history/ — full raw conversation history (JSONL)\n" +
+        "\n" +
+        "Do not proactively create or edit `.aimux/plans/*` or `.aimux/status/*` for simple questions, read-only inspections, or one-shot tasks. " +
+        "Only update those files when the user asks for coordination/delegation, when the task is explicitly long-running, or when state would materially help another agent continue the work.\n" +
+        "\n" +
+        "## Delegation Protocol\n" +
+        delegationProtocol +
+        "Optional fields are `assignedTo` for a specific session ID and `tool` for coordination metadata. Treat tasks as shared handoff records for explicit manual coordination flows.\n" +
+        "When you accept a task, complete it and mark the task `done` with `result`, or `failed` with `error`.");
+}
 export class SessionBootstrapService {
     deps;
     constructor(deps) {
         this.deps = deps;
     }
     buildSessionPreamble(opts) {
-        const { sessionId, worktreePath, extraPreamble, includeAimuxPreamble = true } = opts;
+        const { sessionId, worktreePath, extraPreamble, includeAimuxPreamble = true, team } = opts;
         let preamble = "";
         if (includeAimuxPreamble) {
-            preamble =
-                "You are running inside aimux, an agent multiplexer. " +
-                    "Other agents may be working on this codebase simultaneously.\n" +
-                    `Your session ID is ${sessionId}.\n` +
-                    `- .aimux/context/${sessionId}/live.md — your recent conversation history\n` +
-                    `- .aimux/context/${sessionId}/summary.md — your compacted history\n` +
-                    `- .aimux/plans/${sessionId}.md — your shared working plan\n` +
-                    "- .aimux/sessions.json — all running agents\n" +
-                    "- Other agent contexts are in .aimux/context/{their-session-id}/. Check sessions.json for the list.\n" +
-                    "- Other agent plans are in .aimux/plans/{their-session-id}.md.\n" +
-                    "- .aimux/history/ — full raw conversation history (JSONL)";
+            preamble = buildAimuxAgentInstructions({
+                sessionId,
+                includeTeammateCreationInstructions: !team?.parentSessionId,
+            });
         }
         if (includeAimuxPreamble) {
             const globalAimuxMd = join(homedir(), "AIMUX.md");
@@ -64,78 +94,11 @@ export class SessionBootstrapService {
                 preamble += `\n\nYou are working in a git worktree at ${worktreePath}. Stay in this directory.`;
             }
         }
-        if (includeAimuxPreamble) {
-            preamble +=
-                "\n\n## Planning\n" +
-                    "Maintain a plan file at .aimux/plans/" +
-                    sessionId +
-                    ".md.\n" +
-                    "Keep it current enough that other agents can audit, annotate, or continue your work.\n" +
-                    "Use this structure:\n" +
-                    "- Goal\n" +
-                    "- Current Status\n" +
-                    "- Steps\n" +
-                    "- Notes\n" +
-                    "Update it when your plan materially changes or when you complete a step.";
-            preamble +=
-                "\n\n## Status\n" +
-                    "Maintain a status file at .aimux/status/" +
-                    sessionId +
-                    ".md (3-5 lines max).\n" +
-                    "Update it whenever your focus changes. Include:\n" +
-                    "- What you're currently working on\n" +
-                    "- Key files involved\n" +
-                    "- Current state (investigating, implementing, testing, blocked, etc.)";
-            preamble +=
-                "\n\n## Aimux Cross-Agent Delegation\n" +
-                    "IMPORTANT: This is the aimux delegation system for coordinating work across agents in this multiplexer. " +
-                    "It is separate from any built-in task/todo features in your own tool.\n\n" +
-                    "### Delegating work to another agent\n" +
-                    "When asked to delegate, hand off, or assign work to another agent, create a JSON file:\n" +
-                    "```\n" +
-                    ".aimux/tasks/{short-descriptive-name}.json\n" +
-                    "```\n" +
-                    "Contents:\n" +
-                    "```json\n" +
-                    '{\n  "id": "{same as filename without .json}",\n  "status": "pending",\n' +
-                    '  "assignedBy": "' +
-                    sessionId +
-                    '",\n' +
-                    '  "description": "Brief summary of the task",\n' +
-                    '  "prompt": "Detailed instructions for the other agent",\n' +
-                    '  "createdAt": "{ISO timestamp}",\n  "updatedAt": "{ISO timestamp}"\n}\n' +
-                    "```\n" +
-                    "Optional fields: `assignedTo` (target session ID), `tool` (preferred tool type).\n" +
-                    "Aimux will automatically dispatch pending tasks to idle agents and inject the prompt.\n" +
-                    "Check .aimux/sessions.json for available agents and their session IDs.\n\n" +
-                    "### Receiving a delegated task\n" +
-                    "When you see `[AIMUX TASK ...]` in your input, another agent delegated work to you.\n" +
-                    "Complete the work, then update the task file:\n" +
-                    '- Success: set `status` to `"done"` and add a `result` field with a summary\n' +
-                    '- Failure: set `status` to `"failed"` and add an `error` field\n' +
-                    "The delegating agent will be notified automatically.";
-        }
         if (extraPreamble) {
             preamble += (preamble ? "\n" : "") + extraPreamble;
         }
         return preamble;
     }
-    buildInitialKickoffPrompt(sessionId, preamble) {
-        const summaryPath = join(getContextDir(), sessionId, "summary.md");
-        const livePath = join(getContextDir(), sessionId, "live.md");
-        const planPath = join(getPlansDir(), `${sessionId}.md`);
-        const statusPath = join(getStatusDir(), `${sessionId}.md`);
-        return [
-            `This is an aimux-managed session with session ID ${sessionId}.`,
-            `Your shared session files live at ${summaryPath}, ${livePath}, ${planPath}, and ${statusPath}.`,
-            "Read and follow these operating instructions for this session before continuing.",
-            "Treat them as standing session rules and coordination context, not as a user request.",
-            "",
-            preamble.trim(),
-        ]
-            .filter(Boolean)
-            .join("\n");
-    }
     ensurePlanFile(sessionId, command, worktreePath) {
         try {
             const plansDir = getPlansDir();
@@ -172,7 +135,9 @@ export class SessionBootstrapService {
         return [...baseArgs, ...actionArgs, ...trailingArgs];
     }
     canResumeWithBackendSessionId(toolCfg, backendSessionId) {
-        return Boolean(backendSessionId && toolCfg?.resumeArgs && toolCfg.resumeByBackendSessionId !== false);
+        return Boolean(backendSessionId &&
+            toolCfg?.resumeArgs?.some((arg) => arg.includes("{sessionId}")) &&
+            toolCfg.resumeByBackendSessionId !== false);
     }
     readForkSourceSnapshot(sourceSessionId) {
         const historyTurns = readHistory(sourceSessionId, { lastN: 20 });
@@ -293,7 +258,7 @@ export class SessionBootstrapService {
             .filter(Boolean)
             .join("\n");
     }
-    buildCodexForkKickoffPrompt(sourceSessionId, targetSessionId, snapshot, instruction) {
+    buildCodexForkContinuityPreamble(sourceSessionId, targetSessionId, snapshot, instruction) {
         const activitySummary = this.summarizeForkSourceActivity(snapshot);
         const summaryPath = join(getContextDir(), targetSessionId, "summary.md");
         const livePath = join(getContextDir(), targetSessionId, "live.md");
@@ -310,7 +275,7 @@ export class SessionBootstrapService {
             .filter(Boolean)
             .join(" ");
     }
-    buildCodexMigrationKickoffPrompt(sessionId, sourceWorktreePath, targetWorktreePath, snapshot, instruction) {
+    buildCodexMigrationContinuityPreamble(sessionId, sourceWorktreePath, targetWorktreePath, snapshot, instruction) {
         const activitySummary = this.summarizeForkSourceActivity(snapshot);
         const summaryPath = join(getContextDir(), sessionId, "summary.md");
         const livePath = join(getContextDir(), sessionId, "live.md");
@@ -329,65 +294,6 @@ export class SessionBootstrapService {
             .filter(Boolean)
             .join(" ");
     }
-    deliverDetachedCodexKickoffPrompt(targetSessionId, kickoff, delayMs = 1800) {
-        return new Promise((resolve) => {
-            setTimeout(async () => {
-                try {
-                    const target = this.deps.getSessionTmuxTarget(targetSessionId);
-                    if (target) {
-                        const ready = await this.waitForDetachedCodexInputReady(targetSessionId, target);
-                        if (!ready) {
-                            debug(`codex kickoff input prompt not ready for ${targetSessionId}; attempting best-effort delivery`, "fork");
-                        }
-                        await deliverTmuxPrompt({
-                            tmuxRuntimeManager: this.deps.tmuxRuntimeManager,
-                            target,
-                            prompt: kickoff,
-                            submit: true,
-                            isTargetCurrent: () => {
-                                const currentTarget = this.deps.getSessionTmuxTarget(targetSessionId);
-                                return Boolean(currentTarget && currentTarget.windowId === target.windowId);
-                            },
-                        });
-                    }
-                }
-                catch {
-                    // Continue even if kickoff automation fails; user can still recover manually.
-                }
-                finally {
-                    resolve();
-                }
-            }, delayMs);
-        });
-    }
-    waitForDetachedCodexInputReady(targetSessionId, target) {
-        return new Promise((resolve) => {
-            const poll = (attempt = 1) => {
-                if (attempt > 80) {
-                    resolve(false);
-                    return;
-                }
-                setTimeout(() => {
-                    try {
-                        const currentTarget = this.deps.getSessionTmuxTarget(targetSessionId);
-                        if (!currentTarget || currentTarget.windowId !== target.windowId) {
-                            resolve(false);
-                            return;
-                        }
-                        if (this.paneLooksLikeCodexInputReady(target)) {
-                            resolve(true);
-                            return;
-                        }
-                    }
-                    catch {
-                        // Keep polling; tmux capture can fail briefly while the window is starting.
-                    }
-                    poll(attempt + 1);
-                }, attempt === 1 ? 150 : 250);
-            };
-            poll();
-        });
-    }
     seedForkArtifacts(sourceSessionId, targetSessionId, targetToolConfigKey) {
         const snapshot = this.readForkSourceSnapshot(sourceSessionId);
         const activitySummary = this.summarizeForkSourceActivity(snapshot);
@@ -458,26 +364,12 @@ export class SessionBootstrapService {
             normalized.includes("# Current Status\n\nTBD") &&
             normalized.includes("# Steps\n\n- [ ] TBD"));
     }
-    paneLooksLikeCodexInputReady(target) {
-        const pane = this.deps.tmuxRuntimeManager.captureTarget(target, { startLine: -40 });
-        const lines = pane
-            .split("\n")
-            .map((line) => line.trim())
-            .filter(Boolean);
-        if (lines.length === 0)
-            return false;
-        const text = lines.join("\n");
-        const hasCodexHeader = text.includes("OpenAI Codex") || /\bgpt-[\w.-]+\b/.test(text);
-        if (!hasCodexHeader)
-            return false;
-        const recentLines = lines.slice(-12);
-        return recentLines.some((line) => /^([›>]\s*$|[›>]\s+\S)/.test(line));
-    }
 }
 export function getToolResumeArgs(toolCfg, backendSessionId) {
-    if (!backendSessionId || !toolCfg?.resumeArgs || toolCfg.resumeByBackendSessionId === false) {
+    if (!backendSessionId ||
+        !toolCfg?.resumeArgs?.some((arg) => arg.includes("{sessionId}")) ||
+        toolCfg.resumeByBackendSessionId === false) {
         return undefined;
     }
     return toolCfg.resumeArgs.map((arg) => arg.replace("{sessionId}", backendSessionId));
 }
-//# sourceMappingURL=session-bootstrap.js.map

package/dist/session-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { SessionStatus } from "./status-detector.js";
+import type { SessionTeamMetadata } from "./team.js";
 export interface SessionTransport {
     id: string;
     command: string;
@@ -27,6 +28,7 @@ export declare class SessionRuntime {
     readonly transport: SessionTransport;
     private hooks;
     private readonly startedAt?;
+    team?: SessionTeamMetadata;
     constructor(transport: SessionTransport, startTime: number | undefined, hooks?: SessionRuntimeHooks);
     get id(): string;
     get command(): string;

package/dist/session-runtime.js

@@ -2,6 +2,7 @@ export class SessionRuntime {
     transport;
     hooks;
     startedAt;
+    team;
     constructor(transport, startTime, hooks = {}) {
         this.transport = transport;
         this.hooks = hooks;
@@ -53,4 +54,3 @@ export class SessionRuntime {
         this.transport.destroy();
     }
 }
-//# sourceMappingURL=session-runtime.js.map

package/dist/session-semantics.d.ts

@@ -1,6 +1,9 @@
 import type { AgentActivityState, AgentAttentionState } from "./agent-events.js";
-import type { DashboardSessionStatus } from "./dashboard/index.js";
 import type { NotificationRecord } from "./notifications.js";
+import type { PendingSessionActionKind } from "./pending-actions.js";
+import type { SessionStatus } from "./status-detector.js";
+export type SessionRawStatus = SessionStatus;
+export type SessionPendingAction = PendingSessionActionKind;
 export type SessionLifecycleState = "creating" | "starting" | "running" | "idle" | "offline" | "stopping" | "graveyarding" | "error";
 export type SessionUserLabel = "working" | "needs_input" | "blocked" | "error" | "idle" | "offline" | "starting" | "stopping" | "graveyarding" | "done" | "interrupted";
 export type SessionUserAttention = "none" | "needs_input" | "blocked" | "error";
@@ -50,8 +53,8 @@ export interface SessionSemanticState {
     familyCount: number;
 }
 export interface DeriveSessionSemanticsInput {
-    status: DashboardSessionStatus;
-    pendingAction?: "creating" | "forking" | "migrating" | "starting" | "stopping" | "graveyarding" | "renaming";
+    status: SessionRawStatus;
+    pendingAction?: SessionPendingAction;
     activity?: AgentActivityState;
     attention?: AgentAttentionState;
     unseenCount?: number;
@@ -67,6 +70,11 @@ export interface DeriveSessionSemanticsInput {
     hasActiveTask?: boolean;
 }
 export declare function deriveSessionSemantics(input: DeriveSessionSemanticsInput): SessionSemanticState;
-export declare function sessionSemanticStatusLabel(semantic: SessionSemanticState, _fallbackStatus: DashboardSessionStatus): string;
+export declare function sessionSemanticStatusLabel(semantic: SessionSemanticState, _fallbackStatus: SessionRawStatus): string;
+export declare function sessionDisplayStatusLabel(input: {
+    status: SessionRawStatus;
+    pendingAction?: SessionPendingAction;
+    semantic?: SessionSemanticState;
+}): string;
 export declare function sessionSemanticAttentionScore(semantic: SessionSemanticState): number;
 export declare function sessionSemanticCompactHint(semantic: SessionSemanticState): string | null;

package/dist/session-semantics.js

@@ -199,10 +199,23 @@ function sessionSemanticCompactHintFromParts(input) {
 export function sessionSemanticStatusLabel(semantic, _fallbackStatus) {
     return semantic.presentation.statusLabel;
 }
+const RAW_STATUS_LABELS = {
+    running: "running",
+    idle: "idle",
+    waiting: "thinking",
+    exited: "exited",
+    offline: "offline",
+};
+export function sessionDisplayStatusLabel(input) {
+    if (input.pendingAction)
+        return input.pendingAction;
+    if (input.semantic)
+        return sessionSemanticStatusLabel(input.semantic, input.status);
+    return RAW_STATUS_LABELS[input.status];
+}
 export function sessionSemanticAttentionScore(semantic) {
     return semantic.presentation.attentionScore;
 }
 export function sessionSemanticCompactHint(semantic) {
     return semantic.presentation.compactHint;
 }
-//# sourceMappingURL=session-semantics.js.map

package/dist/shell-args.js

@@ -54,4 +54,3 @@ export function parseShellArgs(input) {
     }
     return args;
 }
-//# sourceMappingURL=shell-args.js.map

package/dist/shell-hooks.js

@@ -33,20 +33,29 @@ function buildZshIntegration() {
         '  printf "%s" "$endpoint"',
         "}",
         "",
+        "_aimux_json_escape() {",
+        '  printf "%s" "$1" | sed -e \'s/\\\\/\\\\\\\\/g\' -e \'s/"/\\\\"/g\'',
+        "}",
+        "",
         "_aimux_report_shell_state() {",
         '  [ -n "$AIMUX_SESSION_ID" ] || return 0',
         '  [ -n "$AIMUX_TOOL" ] || AIMUX_TOOL="shell"',
-        '  [ "${AIMUX_LAST_SHELL_STATE:-}" = "$1" ] && return 0',
-        '  local endpoint="" payload=""',
+        '  local state_key="$1:${2:-}"',
+        '  [ "${AIMUX_LAST_SHELL_STATE:-}" = "$state_key" ] && return 0',
+        '  local endpoint="" payload="" command_json="" escaped_command=""',
         '  endpoint="$(_aimux_read_endpoint)" || return 0',
-        '  payload=$(printf \'{"state":"%s","sessionId":"%s","tool":"%s"}\' "$1" "$AIMUX_SESSION_ID" "$AIMUX_TOOL")',
-        '  AIMUX_LAST_SHELL_STATE="$1"',
+        '  if [ -n "${2:-}" ]; then',
+        '    escaped_command="$(_aimux_json_escape "$2")"',
+        '    command_json=$(printf \',"command":"%s"\' "$escaped_command")',
+        "  fi",
+        '  payload=$(printf \'{"state":"%s","sessionId":"%s","tool":"%s"%s}\' "$1" "$AIMUX_SESSION_ID" "$AIMUX_TOOL" "$command_json")',
+        '  AIMUX_LAST_SHELL_STATE="$state_key"',
         "  command -v curl >/dev/null 2>&1 || return 0",
         '  { command nohup curl --silent --show-error --fail --max-time 1 --output /dev/null -H "content-type: application/json" --data "$payload" "$endpoint/shell-state" >/dev/null 2>&1 </dev/null || true; } &! ',
         "}",
         "",
         "_aimux_preexec() {",
-        "  _aimux_report_shell_state running",
+        '  _aimux_report_shell_state running "$1"',
         "}",
         "",
         "_aimux_precmd() {",
@@ -86,14 +95,23 @@ function buildBashIntegration() {
         '  printf "%s" "$endpoint"',
         "}",
         "",
+        "_aimux_json_escape() {",
+        '  printf "%s" "$1" | sed -e \'s/\\\\/\\\\\\\\/g\' -e \'s/"/\\\\"/g\'',
+        "}",
+        "",
         "_aimux_report_shell_state() {",
         '  [ -n "$AIMUX_SESSION_ID" ] || return 0',
         '  [ -n "$AIMUX_TOOL" ] || AIMUX_TOOL="shell"',
-        '  [ "${AIMUX_LAST_SHELL_STATE:-}" = "$1" ] && return 0',
-        '  local endpoint="" payload=""',
+        '  local state_key="$1:${2:-}"',
+        '  [ "${AIMUX_LAST_SHELL_STATE:-}" = "$state_key" ] && return 0',
+        '  local endpoint="" payload="" command_json="" escaped_command=""',
         '  endpoint="$(_aimux_read_endpoint)" || return 0',
-        '  payload=$(printf \'{"state":"%s","sessionId":"%s","tool":"%s"}\' "$1" "$AIMUX_SESSION_ID" "$AIMUX_TOOL")',
-        '  AIMUX_LAST_SHELL_STATE="$1"',
+        '  if [ -n "${2:-}" ]; then',
+        '    escaped_command="$(_aimux_json_escape "$2")"',
+        '    command_json=$(printf \',"command":"%s"\' "$escaped_command")',
+        "  fi",
+        '  payload=$(printf \'{"state":"%s","sessionId":"%s","tool":"%s"%s}\' "$1" "$AIMUX_SESSION_ID" "$AIMUX_TOOL" "$command_json")',
+        '  AIMUX_LAST_SHELL_STATE="$state_key"',
         "  command -v curl >/dev/null 2>&1 || return 0",
         '  command nohup curl --silent --show-error --fail --max-time 1 --output /dev/null -H "content-type: application/json" --data "$payload" "$endpoint/shell-state" >/dev/null 2>&1 </dev/null &',
         "  disown $! 2>/dev/null || true",
@@ -101,7 +119,11 @@ function buildBashIntegration() {
         "",
         "_aimux_preexec_command() {",
         '  [ -n "$COMP_LINE" ] && return',
-        "  _aimux_report_shell_state running",
+        '  [ -n "${AIMUX_SHELL_HOOK_ACTIVE:-}" ] && return',
+        '  case "$BASH_COMMAND" in _aimux_*|trap\\ *) return ;; esac',
+        "  AIMUX_SHELL_HOOK_ACTIVE=1",
+        '  _aimux_report_shell_state running "$BASH_COMMAND"',
+        "  AIMUX_SHELL_HOOK_ACTIVE=",
         "}",
         "",
         "_aimux_prompt_command() {",
@@ -173,4 +195,3 @@ export function wrapInteractiveShellWithIntegration(opts) {
         env: opts.env,
     });
 }
-//# sourceMappingURL=shell-hooks.js.map

package/dist/shell-state.d.ts

@@ -5,6 +5,7 @@ export interface ApplyShellStateInput {
     state: string;
     sessionId: string;
     tool?: string;
+    command?: string;
     tracker: AgentTracker;
     projectRoot?: string;
     emitAlert: (input: {
@@ -24,5 +25,6 @@ export interface ApplyShellStateResult {
     previousActivity?: AgentActivityState;
     nextActivity: AgentActivityState;
     notified: boolean;
+    command?: string;
 }
 export declare function applyShellStateTransition(input: ApplyShellStateInput): ApplyShellStateResult;

package/dist/shell-state.js

@@ -1,15 +1,32 @@
 import { loadConfig } from "./config.js";
-import { loadMetadataState } from "./metadata-store.js";
+import { loadMetadataState, updateSessionMetadata } from "./metadata-store.js";
 import { clearNotifications } from "./notifications.js";
+function normalizeShellCommand(command) {
+    const trimmed = command?.replace(/\s+/g, " ").trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > 500 ? `${trimmed.slice(0, 497)}...` : trimmed;
+}
 export function applyShellStateTransition(input) {
     const state = input.state.trim();
     const sessionId = input.sessionId.trim();
     const tool = input.tool?.trim() || "shell";
+    const command = normalizeShellCommand(input.command);
     const previousActivity = loadMetadataState(input.projectRoot).sessions[sessionId]?.derived?.activity;
     let nextActivity;
     let notified = false;
     if (state === "running" || state === "command" || state === "busy") {
         nextActivity = "running";
+        if (command) {
+            updateSessionMetadata(sessionId, (current) => ({
+                ...current,
+                derived: {
+                    ...(current.derived ?? {}),
+                    shellCommand: command,
+                    shellCommandState: "running",
+                },
+            }), input.projectRoot);
+        }
         if (previousActivity !== "running") {
             clearNotifications({ sessionId });
             input.tracker.setActivity(sessionId, "running", input.projectRoot);
@@ -19,6 +36,13 @@ export function applyShellStateTransition(input) {
     }
     else if (state === "prompt" || state === "idle") {
         nextActivity = "idle";
+        updateSessionMetadata(sessionId, (current) => ({
+            ...current,
+            derived: {
+                ...(current.derived ?? {}),
+                shellCommandState: "prompt",
+            },
+        }), input.projectRoot);
         if (previousActivity !== "idle") {
             input.tracker.setActivity(sessionId, "idle", input.projectRoot);
             input.tracker.setAttention(sessionId, "normal", input.projectRoot);
@@ -46,6 +70,6 @@ export function applyShellStateTransition(input) {
         previousActivity,
         nextActivity,
         notified,
+        command,
     };
 }
-//# sourceMappingURL=shell-state.js.map

package/dist/status-detector.js

@@ -64,4 +64,3 @@ export class StatusDetector {
         }
     }
 }
-//# sourceMappingURL=status-detector.js.map

package/dist/statusline-model.d.ts

@@ -1,10 +1,12 @@
 import type { AgentActivityState, AgentAttentionState } from "./agent-events.js";
 import type { SessionSemanticState } from "./session-semantics.js";
+import type { SessionTeamMetadata } from "./team.js";
 export interface StatuslineSession {
     id: string;
     kind?: "agent" | "service";
     tool: string;
     label?: string;
+    launchCommandLine?: string;
     tmuxWindowId?: string;
     tmuxWindowIndex?: number;
     windowName?: string;
@@ -14,8 +16,9 @@ export interface StatuslineSession {
     active?: boolean;
     worktreePath?: string;
     semantic?: SessionSemanticState;
+    team?: SessionTeamMetadata;
 }
-export declare function compactSessionTitle(session: Pick<StatuslineSession, "kind" | "tool" | "label" | "role" | "id">): string;
+export declare function compactSessionTitle(session: Pick<StatuslineSession, "kind" | "tool" | "label" | "launchCommandLine" | "role" | "id">): string;
 export interface StatuslineMetadataEntry {
     status?: {
         text: string;
@@ -78,6 +81,7 @@ export interface StatuslineData {
     project?: string;
     dashboardScreen?: "dashboard" | "plans" | "graveyard" | "activity" | "threads" | "notifications" | "workflow" | "help";
     sessions?: StatuslineSession[];
+    teammates?: StatuslineSession[];
     metadata?: Record<string, StatuslineMetadataEntry>;
     controlPlane?: {
         daemonAlive?: boolean;
@@ -101,7 +105,8 @@ export declare const DASHBOARD_SCREEN_TABS: Array<{
 }>;
 export declare function trim(text: string, max: number): string;
 export declare function normalizePath(path: string | undefined, projectRoot: string): string;
-export declare function sessionIdentity(session: Pick<StatuslineSession, "id" | "tool" | "label" | "role">): string;
+export declare function findStatuslineSession(data: StatuslineData, sessionId: string | undefined): StatuslineSession | undefined;
+export declare function sessionIdentity(session: Pick<StatuslineSession, "id" | "tool" | "label" | "launchCommandLine" | "role">): string;
 export declare function renderSemanticBadge(semantic: SessionSemanticState | undefined): string | null;
 export declare function renderSessionCompactHint(session: {
     semantic?: SessionSemanticState;
@@ -115,5 +120,8 @@ export declare function currentPathContext(currentPath: string | undefined): {
 export declare function resolveCurrentSessionId(data: StatuslineData, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string, projectRoot?: string): string | undefined;
 export declare function resolveExactCurrentSessionId(data: StatuslineData, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string, projectRoot?: string): string | undefined;
 export declare function resolveScopedSessions(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): ResolvedStatuslineSession[];
+export declare function resolveFocusedTeammate(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): ResolvedStatuslineSession | null;
+export declare function resolveFocusedTeammateGroup(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): ResolvedStatuslineSession[];
+export declare function resolveCurrentTeammates(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): ResolvedStatuslineSession[];
 export declare function resolveSessionMetadata(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): StatuslineMetadataEntry | undefined;
 export declare function resolveExactSessionMetadata(data: StatuslineData, projectRoot: string, currentSession?: string, currentWindow?: string, currentWindowId?: string, currentPath?: string): StatuslineMetadataEntry | undefined;