aimux-cli 0.1.16 → 0.1.19

package/dist/metadata-store.d.ts

@@ -32,6 +32,7 @@ export interface SessionContextMetadata {
     worktreePath?: string;
     worktreeName?: string;
     branch?: string;
+    transcriptPath?: string;
     pr?: SessionPrMetadata;
     repo?: SessionRepoMetadata;
 }
@@ -57,9 +58,10 @@ export interface SessionDerivedMetadata extends SessionDerivedState {
     lastEvent?: AgentEvent;
     events?: AgentEvent[];
     services?: SessionServiceMetadata[];
+    shellCommand?: string;
+    shellCommandState?: "running" | "prompt";
 }
 export interface SessionMetadata {
-    label?: string;
     status?: SessionStatusMetadata;
     progress?: SessionProgressMetadata;
     logs?: SessionLogEntry[];
@@ -82,6 +84,7 @@ export declare function loadMetadataState(projectRoot?: string): MetadataState;
 export declare function saveMetadataState(state: MetadataState, projectRoot?: string): void;
 export declare function updateSessionMetadata(sessionId: string, updater: (current: SessionMetadata) => SessionMetadata, projectRoot?: string): MetadataState;
 export declare function clearSessionLogs(sessionId: string, projectRoot?: string): MetadataState;
+export declare function clearSessionTranscriptPath(sessionId: string, projectRoot?: string): MetadataState;
 export declare function loadMetadataEndpoint(projectRoot?: string): MetadataApiEndpoint | null;
 export declare function resolveProjectServiceEndpoint(projectRoot?: string): {
     host: string;

package/dist/metadata-store.js

@@ -27,11 +27,24 @@ function loadJson(path, fallback) {
 function saveJson(path, value) {
     writeJsonAtomic(path, value);
 }
+function scrubProjectionAuthorityFields(state) {
+    const sessions = state.sessions;
+    if (!sessions || typeof sessions !== "object")
+        return state;
+    for (const session of Object.values(sessions)) {
+        if (session && typeof session === "object") {
+            delete session.backendSessionId;
+            delete session.label;
+        }
+    }
+    return state;
+}
 export function loadMetadataState(projectRoot) {
-    return loadJson(metadataPathFor(projectRoot), { version: 1, sessions: {} });
+    const state = loadJson(metadataPathFor(projectRoot), { version: 1, sessions: {} });
+    return scrubProjectionAuthorityFields(state);
 }
 export function saveMetadataState(state, projectRoot) {
-    saveJson(metadataPathFor(projectRoot), state);
+    saveJson(metadataPathFor(projectRoot), scrubProjectionAuthorityFields(state));
 }
 export function updateSessionMetadata(sessionId, updater, projectRoot) {
     const state = loadMetadataState(projectRoot);
@@ -50,6 +63,21 @@ export function clearSessionLogs(sessionId, projectRoot) {
         return next;
     }, projectRoot);
 }
+export function clearSessionTranscriptPath(sessionId, projectRoot) {
+    const state = loadMetadataState(projectRoot);
+    const current = state.sessions[sessionId];
+    if (!current?.context?.transcriptPath)
+        return state;
+    const context = { ...current.context };
+    delete context.transcriptPath;
+    state.sessions[sessionId] = {
+        ...current,
+        context,
+        updatedAt: new Date().toISOString(),
+    };
+    saveMetadataState(state, projectRoot);
+    return state;
+}
 export function loadMetadataEndpoint(projectRoot) {
     return loadJson(endpointPathFor(projectRoot), null);
 }
@@ -82,4 +110,3 @@ export function removeMetadataEndpoint(projectRoot) {
     }
     catch { }
 }
-//# sourceMappingURL=metadata-store.js.map

package/dist/multiplexer/agent-io-methods.d.ts

@@ -1,7 +1,6 @@
 import type { DashboardSession } from "../dashboard/index.js";
-import { type MessageKind } from "../threads.js";
+import type { MessageKind } from "../threads.js";
 export declare const agentIoMethods: {
-    composeOrchestrationPrompt(this: any, threadId: string, from: string, body: string, kind: MessageKind, title?: string): string;
     orchestrationWorkflowPressure(this: any, sessionId: string, status?: DashboardSession["status"]): number;
     deliverOrchestrationMessage(this: any, recipients: string[], threadId: string, from: string, body: string, kind: MessageKind, title?: string, messageId?: string): string[];
     sendOrchestrationMessage(this: any, input: any): {
@@ -24,17 +23,10 @@ export declare const agentIoMethods: {
     readStatusHeadline(this: any, sessionId: string): string | undefined;
     deriveHeadline(this: any, sessionId: string): string | undefined;
     resolveRunningSession(this: any, sessionId: string): any;
-    writeTmuxAgentInput(this: any, sessionId: string, transport: any, data: string): void;
-    normalizeAgentInput(this: any, data: string, submit: boolean, sessionId?: string): string;
-    paneStillContainsAgentDraft(this: any, target: any, draft: string): boolean;
-    scheduleTmuxAgentSubmit(this: any, sessionId: string, target: any, draft: string): void;
-    writeAgentInput(this: any, sessionId: string, data?: string, parts?: any[], clientMessageId?: string, submit?: boolean): Promise<{
-        sessionId: string;
-    }>;
-    readAgentHistory(this: any, sessionId: string, lastN?: number): Promise<any>;
     interruptAgent(this: any, sessionId: string): Promise<{
         sessionId: string;
     }>;
+    sendAgentInput(this: any, sessionId: string, text: string): Promise<any>;
     readAgentOutput(this: any, sessionId: string, startLine?: number): Promise<any>;
 };
 export type AgentIoMethods = typeof agentIoMethods;

package/dist/multiplexer/agent-io-methods.js

@@ -1,18 +1,9 @@
 import { sendDirectMessage, sendThreadMessage } from "../orchestration.js";
 import { sendHandoff } from "../orchestration-actions.js";
 import { resolveOrchestrationRecipients } from "../orchestration-routing.js";
-import { markMessageDelivered } from "../threads.js";
 import { stopProjectServices as stopProjectServicesImpl } from "./dashboard-model.js";
-import { applyDashboardSessionLabel as applyDashboardSessionLabelImpl, applySessionLabel as applySessionLabelImpl, deriveHeadline as deriveHeadlineImpl, getSessionLabel as getSessionLabelImpl, interruptAgent as interruptAgentImpl, normalizeAgentInput as normalizeAgentInputImpl, paneStillContainsAgentDraft as paneStillContainsAgentDraftImpl, readAgentHistory as readAgentHistoryImpl, readAgentOutput as readAgentOutputImpl, readStatusHeadline as readStatusHeadlineImpl, resolveRunningSession as resolveRunningSessionImpl, scheduleTmuxAgentSubmit as scheduleTmuxAgentSubmitImpl, updateSessionLabel as updateSessionLabelImpl, writeAgentInput as writeAgentInputImpl, writeTmuxAgentInput as writeTmuxAgentInputImpl, } from "./session-runtime-core.js";
+import { applyDashboardSessionLabel as applyDashboardSessionLabelImpl, applySessionLabel as applySessionLabelImpl, deriveHeadline as deriveHeadlineImpl, getSessionLabel as getSessionLabelImpl, readAgentOutput as readAgentOutputImpl, sendAgentInput as sendAgentInputImpl, readStatusHeadline as readStatusHeadlineImpl, resolveRunningSession as resolveRunningSessionImpl, updateSessionLabel as updateSessionLabelImpl, interruptAgent as interruptAgentImpl, } from "./session-runtime-core.js";
 export const agentIoMethods = {
-    composeOrchestrationPrompt(threadId, from, body, kind, title) {
-        const prefix = `[AIMUX MESSAGE ${threadId} from ${from}]`;
-        const headline = title ? `${title}\n\n` : "";
-        return (`${prefix} ${headline}${body}\n\n` +
-            `Read .aimux/threads/${threadId}.json and .aimux/threads/${threadId}.jsonl for context. ` +
-            `This is a ${kind} message delivered by aimux. ` +
-            `Check the thread now, then either reply in-thread or briefly acknowledge that no action is needed.`);
-    },
     orchestrationWorkflowPressure(sessionId, status) {
         const semantic = this.deriveSessionSemanticState(sessionId, status);
         return (semantic.waitingOnMeCount * 5 +
@@ -22,21 +13,14 @@ export const agentIoMethods = {
             semantic.waitingOnThemCount);
     },
     deliverOrchestrationMessage(recipients, threadId, from, body, kind, title, messageId) {
-        const delivered = [];
-        for (const recipient of recipients) {
-            const session = this.sessions.find((candidate) => candidate.id === recipient && !candidate.exited);
-            if (!session)
-                continue;
-            const runtime = this.deriveSessionSemanticState(session.id, session.status).runtime;
-            if (!runtime.canReceiveInput)
-                continue;
-            void this.writeAgentInput(recipient, this.composeOrchestrationPrompt(threadId, from, body, kind, title), undefined, undefined, true);
-            if (messageId) {
-                markMessageDelivered(threadId, messageId, recipient);
-            }
-            delivered.push(recipient);
-        }
-        return delivered;
+        void recipients;
+        void threadId;
+        void from;
+        void body;
+        void kind;
+        void title;
+        void messageId;
+        return [];
     },
     sendOrchestrationMessage(input) {
         const from = input.from?.trim() || "user";
@@ -156,29 +140,13 @@ export const agentIoMethods = {
     resolveRunningSession(sessionId) {
         return resolveRunningSessionImpl(this, sessionId);
     },
-    writeTmuxAgentInput(sessionId, transport, data) {
-        writeTmuxAgentInputImpl(this, sessionId, transport, data);
-    },
-    normalizeAgentInput(data, submit, sessionId) {
-        return normalizeAgentInputImpl(this, data, submit, sessionId);
-    },
-    paneStillContainsAgentDraft(target, draft) {
-        return paneStillContainsAgentDraftImpl(this, target, draft);
-    },
-    scheduleTmuxAgentSubmit(sessionId, target, draft) {
-        scheduleTmuxAgentSubmitImpl(this, sessionId, target, draft);
-    },
-    async writeAgentInput(sessionId, data = "", parts, clientMessageId, submit = false) {
-        return writeAgentInputImpl(this, sessionId, data, parts, clientMessageId, submit);
-    },
-    async readAgentHistory(sessionId, lastN) {
-        return readAgentHistoryImpl(this, sessionId, lastN);
-    },
     async interruptAgent(sessionId) {
         return interruptAgentImpl(this, sessionId);
     },
+    async sendAgentInput(sessionId, text) {
+        return sendAgentInputImpl(this, sessionId, text);
+    },
     async readAgentOutput(sessionId, startLine) {
         return readAgentOutputImpl(this, sessionId, startLine);
     },
 };
-//# sourceMappingURL=agent-io-methods.js.map

package/dist/multiplexer/archives.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
-import { getGraveyardPath, getPlansDir } from "../paths.js";
+import { getPlansDir } from "../paths.js";
 import { debug } from "../debug.js";
 import { parseKeys } from "../key-parser.js";
 import { loadLastUsedState } from "../last-used.js";
@@ -11,6 +11,7 @@ import { postToProjectService } from "./dashboard-control.js";
 import { requestJson } from "../http-client.js";
 import { resolveProjectServiceEndpoint } from "../metadata-store.js";
 import { buildGraveyardViewModel, } from "./graveyard-view-model.js";
+import { listTopologySessionStates } from "../runtime-core/topology-sessions.js";
 export function showGraveyard(host) {
     host.clearDashboardSubscreens();
     loadGraveyardEntries(host);
@@ -118,7 +119,9 @@ export function resurrectGraveyardEntry(host, idx) {
         ? host.mode === "dashboard"
             ? postToProjectService(host, "/graveyard/worktrees/resurrect", { path: item.entry.path }, { timeoutMs: 10_000 })
             : host.resurrectGraveyardWorktree(item.entry.path)
-        : host.resurrectGraveyardSession(item.entry.id);
+        : host.mode === "dashboard"
+            ? postToProjectService(host, "/graveyard/resurrect", { sessionId: item.entry.id }, { timeoutMs: 10_000 })
+            : host.resurrectGraveyardSession(item.entry.id);
     void promise
         .then(() => {
         host.graveyardEntries = host.listGraveyardEntries();
@@ -147,6 +150,8 @@ function refreshGraveyardViewModel(host) {
     const viewModel = buildGraveyardViewModel({
         worktrees: host.worktreeGraveyardEntries ?? [],
         agents: host.graveyardEntries ?? [],
+        parentSessions: [...(host.dashboardSessionsCache ?? []), ...(host.sessions ?? []), ...(host.offlineSessions ?? [])],
+        teammates: [...(host.dashboardTeammatesCache ?? []), ...(host.sessions ?? []), ...(host.offlineSessions ?? [])],
         lastUsedById: lastUsedState.items,
     });
     host.graveyardViewModel = viewModel;
@@ -190,13 +195,7 @@ async function deleteSelectedGraveyardWorktree(host) {
     }
 }
 function loadGraveyardEntries(host) {
-    const graveyardPath = getGraveyardPath();
-    try {
-        host.graveyardEntries = JSON.parse(readFileSync(graveyardPath, "utf-8"));
-    }
-    catch {
-        host.graveyardEntries = [];
-    }
+    host.graveyardEntries = listTopologySessionStates({ statuses: ["graveyard"] });
     host.worktreeGraveyardEntries = listWorktreeGraveyardEntries();
     refreshGraveyardViewModel(host);
 }
@@ -385,4 +384,3 @@ export function openPlanInEditor(host, path) {
         host.renderDashboardErrorOverlay();
     }
 }
-//# sourceMappingURL=archives.js.map

package/dist/multiplexer/dashboard-actions-methods.js

@@ -184,4 +184,3 @@ export const dashboardActionMethods = {
         handleToolOptionsKeyImpl(this, data);
     },
 };
-//# sourceMappingURL=dashboard-actions-methods.js.map

package/dist/multiplexer/dashboard-control.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { updateNotificationContext } from "../notification-context.js";
 import { requestJson } from "../http-client.js";
 import { markLastUsed } from "../last-used.js";
-import { loadMetadataState, resolveProjectServiceEndpoint } from "../metadata-store.js";
+import { loadMetadataState, removeMetadataEndpoint, resolveProjectServiceEndpoint } from "../metadata-store.js";
 import { parseKeys } from "../key-parser.js";
 import { ensureDaemonRunning, ensureProjectService } from "../daemon.js";
 import { getProjectStateDir } from "../paths.js";
@@ -13,7 +13,7 @@ import { loadStatusline, renderTmuxStatuslineFromData } from "../tmux/statusline
 import { openManagedServiceWindow, openManagedSessionWindow } from "../tmux/window-open.js";
 import { resolveOrchestrationRecipients } from "../orchestration-routing.js";
 import { sortDashboardEntriesByCreatedAt } from "../dashboard/sort.js";
-import { buildDashboardBusyOverlayOutput, buildDashboardErrorOverlayOutput, buildLabelInputOverlayOutput, buildMigratePickerOverlayOutput, buildNotificationPanelOverlayOutput, buildServiceInputOverlayOutput, buildSwitcherOverlayOutput, buildWorktreeListOverlayOutput, buildWorktreeRemoveConfirmOverlayOutput, } from "../tui/screens/overlay-renderers.js";
+import { buildDashboardBusyOverlayOutput, buildDashboardErrorOverlayOutput, buildLabelInputOverlayOutput, buildMigratePickerOverlayOutput, buildNotificationPanelOverlayOutput, buildServiceInputOverlayOutput, buildSwitcherOverlayOutput, buildTeammatePickerOverlayOutput, buildWorktreeListOverlayOutput, buildWorktreeRemoveConfirmOverlayOutput, } from "../tui/screens/overlay-renderers.js";
 import { buildWorktreeInputOverlayOutput } from "./worktrees.js";
 import { buildToolOptionsOverlayOutput, buildToolPickerOverlayOutput } from "./tool-picker.js";
 import { buildThreadReplyOverlayOutput } from "./subscreens.js";
@@ -48,13 +48,13 @@ function primeLiveTmuxFooter(host, target) {
 }
 export function updateWorktreeSessions(host) {
     const allDash = host.getDashboardSessions();
-    host.dashboardState.worktreeSessions = sortDashboardEntriesByCreatedAt(allDash.filter((s) => {
+    host.dashboardState.worktreeSessions = host.dashboardUiStateStore.orderSessionsForWorktree(sortDashboardEntriesByCreatedAt(allDash.filter((s) => {
         return (s.worktreePath ?? undefined) === host.dashboardState.focusedWorktreePath;
-    }));
+    })), host.dashboardState.focusedWorktreePath);
     const filteredServices = host.getDashboardServices().filter((service) => {
         return (service.worktreePath ?? undefined) === host.dashboardState.focusedWorktreePath;
     });
-    const worktreeServices = sortDashboardEntriesByCreatedAt(filteredServices);
+    const worktreeServices = host.dashboardUiStateStore.orderServicesForWorktree(sortDashboardEntriesByCreatedAt(filteredServices), host.dashboardState.focusedWorktreePath);
     host.dashboardState.worktreeEntries = [
         ...host.dashboardState.worktreeSessions.map((session) => ({ kind: "session", id: session.id })),
         ...worktreeServices.map((service) => ({ kind: "service", id: service.id })),
@@ -109,6 +109,9 @@ export function handleActiveDashboardOverlayKey(host, data) {
         case "notification-panel":
             host.handleNotificationPanelKey(data);
             return true;
+        case "teammate-picker":
+            host.handleTeammatePickerKey(data);
+            return true;
         case "worktree-remove-confirm":
             host.handleWorktreeRemoveConfirmKey(data);
             return true;
@@ -165,6 +168,9 @@ export function buildActiveDashboardOverlayOutput(host) {
     if (host.dashboardOverlayState.kind === "notification-panel") {
         return buildNotificationPanelOverlayOutput(host);
     }
+    if (host.dashboardOverlayState.kind === "teammate-picker") {
+        return buildTeammatePickerOverlayOutput(host);
+    }
     if (host.dashboardOverlayState.kind === "thread-reply") {
         return buildThreadReplyOverlayOutput(host);
     }
@@ -372,7 +378,7 @@ export function showOrchestrationRoutePicker(host, mode) {
             exited: session.exited,
         };
     });
-    if (selected && !selected.remoteInstancePid) {
+    if (selected) {
         options.push({
             label: `${selected.label ?? selected.command ?? selected.id} (${selected.id})`,
             sessionId: selected.id,
@@ -527,10 +533,15 @@ export function renderOrchestrationRoutePicker(host) {
         process.stdout.write(output);
 }
 export async function postToProjectService(host, path, body, opts) {
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const endpoint = resolveProjectServiceEndpoint(process.cwd());
+    const projectRoot = process.cwd();
+    const timeoutMs = opts?.timeoutMs ?? 1000;
+    const deadline = Date.now() + timeoutMs;
+    let lastError = null;
+    for (let attempt = 0; Date.now() <= deadline; attempt += 1) {
+        const endpoint = resolveProjectServiceEndpoint(projectRoot);
         if (!endpoint) {
             await ensureDashboardControlPlane(host);
+            await sleepProjectServiceRetry(attempt);
             continue;
         }
         try {
@@ -538,26 +549,47 @@ export async function postToProjectService(host, path, body, opts) {
                 method: "POST",
                 headers: { "content-type": "application/json" },
                 body,
-                timeoutMs: opts?.timeoutMs ?? 1000,
+                timeoutMs: Math.max(1, deadline - Date.now()),
             });
             if (status >= 200 && status < 300 && json?.ok !== false) {
                 return json;
             }
-            if (attempt === 0) {
+            lastError = new Error(json?.error || `request failed: ${status}`);
+            if (isProjectServiceRetryableStatus(status) && Date.now() < deadline) {
                 await ensureDashboardControlPlane(host);
+                await sleepProjectServiceRetry(attempt);
                 continue;
             }
-            throw new Error(json?.error || `request failed: ${status}`);
+            throw lastError;
         }
         catch (error) {
-            if (attempt === 0) {
+            lastError = error;
+            if (isProjectServiceConnectionError(error) && Date.now() < deadline) {
+                removeMetadataEndpoint(projectRoot);
                 await ensureDashboardControlPlane(host);
+                await sleepProjectServiceRetry(attempt);
                 continue;
             }
             throw error;
         }
     }
-    throw new Error("no live project service endpoint");
+    throw lastError instanceof Error ? lastError : new Error("no live project service endpoint");
+}
+function isProjectServiceConnectionError(error) {
+    const code = typeof error?.code === "string" ? error.code : "";
+    const message = error instanceof Error ? error.message : String(error);
+    return (code === "ECONNREFUSED" ||
+        code === "ECONNRESET" ||
+        code === "EPIPE" ||
+        message.includes("ECONNREFUSED") ||
+        message.includes("ECONNRESET") ||
+        message.includes("socket hang up"));
+}
+function isProjectServiceRetryableStatus(status) {
+    return status === 502 || status === 503 || status === 504;
+}
+async function sleepProjectServiceRetry(attempt) {
+    await new Promise((resolve) => setTimeout(resolve, Math.min(250, 50 + attempt * 25)));
 }
 export async function ensureDashboardControlPlane(host) {
     if (host.dashboardServiceRecovery) {
@@ -641,4 +673,3 @@ export function handleOrchestrationRoutePickerKey(host, data) {
         showOrchestrationInput(host, mode, target);
     }
 }
-//# sourceMappingURL=dashboard-control.js.map

package/dist/multiplexer/dashboard-interaction.d.ts

@@ -12,10 +12,16 @@ export declare const dashboardInteractionMethods: {
     handleDashboardKey(this: any, data: Buffer): void;
     activateDashboardEntryByNumber(this: any, index: number): Promise<void>;
     activateDashboardService(this: any, service: DashboardService): Promise<void>;
-    activateDashboardEntry(this: any, entry: DashboardSession): Promise<void>;
+    activateDashboardEntry(this: any, entry: DashboardSession, options?: {
+        preserveDashboardSelection?: boolean;
+    }): Promise<void>;
+    getTeammatePickerEntries(this: any): DashboardSession[];
+    showTeammatePicker(this: any): void;
+    renderTeammatePicker(this: any): void;
+    handleTeammatePickerKey(this: any, data: Buffer): void;
     handleServiceInputKey(this: any, data: Buffer): void;
     handleLabelInputKey(this: any, data: Buffer): void;
-    handleReviewRequest(this: any): void;
+    handleReviewRequest(this: any): Promise<void>;
     formatRoutePreview(this: any, recipientIds: string[]): string;
     submitDashboardOrchestrationAction(this: any, mode: "message" | "handoff" | "task", target: any, body: string): Promise<void>;
 };