aimux-cli 0.1.19 → 0.1.20

package/dist/mobile-push-throttle.js

@@ -0,0 +1,53 @@
+const DEDUPE_TTL_MS = 60_000;
+const SESSION_WINDOW_MS = 60_000;
+const SESSION_LIMIT = 5;
+/**
+ * In-memory guard for outbound mobile pushes. Collapses identical alerts
+ * re-emitted within a TTL window (chatty idle/needs_input polling) and caps the
+ * push rate per session so one runaway agent cannot flood the device.
+ */
+export class MobilePushThrottle {
+    dedupeTtlMs;
+    sessionLimit;
+    sessionWindowMs;
+    now;
+    lastByKey = new Map();
+    sessionHits = new Map();
+    constructor(dedupeTtlMs = DEDUPE_TTL_MS, sessionLimit = SESSION_LIMIT, sessionWindowMs = SESSION_WINDOW_MS, now = () => Date.now()) {
+        this.dedupeTtlMs = dedupeTtlMs;
+        this.sessionLimit = sessionLimit;
+        this.sessionWindowMs = sessionWindowMs;
+        this.now = now;
+    }
+    allow(input) {
+        const ts = this.now();
+        this.prune(ts);
+        const key = input.dedupeKey?.trim() || [input.sessionId, input.kind, input.title, input.body].map((p) => p ?? "").join("|");
+        const last = this.lastByKey.get(key);
+        if (last !== undefined && ts - last < this.dedupeTtlMs)
+            return false;
+        const session = input.sessionId?.trim() || "_global";
+        const hits = (this.sessionHits.get(session) ?? []).filter((t) => ts - t < this.sessionWindowMs);
+        if (hits.length >= this.sessionLimit) {
+            this.sessionHits.set(session, hits);
+            return false;
+        }
+        hits.push(ts);
+        this.sessionHits.set(session, hits);
+        this.lastByKey.set(key, ts);
+        return true;
+    }
+    prune(ts) {
+        for (const [key, t] of this.lastByKey) {
+            if (ts - t >= this.dedupeTtlMs)
+                this.lastByKey.delete(key);
+        }
+        for (const [session, hits] of this.sessionHits) {
+            const fresh = hits.filter((t) => ts - t < this.sessionWindowMs);
+            if (fresh.length === 0)
+                this.sessionHits.delete(session);
+            else
+                this.sessionHits.set(session, fresh);
+        }
+    }
+}

package/dist/multiplexer/dashboard-model.js

@@ -819,7 +819,7 @@ export async function startProjectServices(host) {
                 targetSessionId: input.sessionId,
                 targetWorktreePath: input.worktreePath,
                 open: input.open ?? false,
-                extraArgs: input.extraArgs,
+                launchOverride: input.launchOverride,
             }), input.sessionId
                 ? buildMetadataPendingSessionSeed({
                     sessionId: input.sessionId,
@@ -862,7 +862,7 @@ export async function startProjectServices(host) {
                 instruction: input.instruction,
                 targetWorktreePath: input.worktreePath,
                 open: input.open ?? false,
-                extraArgs: input.extraArgs,
+                launchOverride: input.launchOverride,
             }), input.targetSessionId
                 ? buildMetadataPendingSessionSeed({
                     sessionId: input.targetSessionId,
@@ -876,6 +876,7 @@ export async function startProjectServices(host) {
             renameAgent: (input) => host.renameAgent(input.sessionId, input.label),
             migrateAgent: (input) => withMetadataSessionPending(host, input.sessionId, "migrating", () => host.migrateAgent(input.sessionId, input.worktreePath), findDashboardSessionSeed(host, input.sessionId)),
             killAgent: (input) => withMetadataSessionPending(host, input.sessionId, "graveyarding", () => host.sendAgentToGraveyard(input.sessionId), findDashboardSessionSeed(host, input.sessionId)),
+            recordBackendSessionId: (input) => host.recordSessionBackendSessionId(input.sessionId, input.backendSessionId),
             sendAgentInput: (input) => host.sendAgentInput(input.sessionId, input.text),
             readAgentOutput: (input) => host.readAgentOutput(input.sessionId, input.startLine),
         },

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

@@ -1,12 +1,13 @@
 import type { DashboardService, DashboardSession } from "../dashboard/index.js";
 import type { PendingServiceActionKind, PendingSessionActionKind } from "../pending-actions.js";
+import type { LaunchOverride } from "../shell-args.js";
 type DashboardOpsHost = any;
 export declare function runDashboardOperation<T>(host: DashboardOpsHost, title: string, lines: string[], work: () => Promise<T> | T, errorTitle?: string): Promise<T | undefined>;
 export declare function spawnDashboardAgentWithFeedback(host: DashboardOpsHost, input: {
     sessionId: string;
     tool: string;
     worktreePath?: string;
-    extraArgs?: string[];
+    launchOverride?: LaunchOverride;
 }): Promise<void>;
 export declare function forkDashboardAgentWithFeedback(host: DashboardOpsHost, input: {
     sourceSessionId: string;
@@ -14,7 +15,7 @@ export declare function forkDashboardAgentWithFeedback(host: DashboardOpsHost, i
     tool: string;
     instruction?: string;
     worktreePath?: string;
-    extraArgs?: string[];
+    launchOverride?: LaunchOverride;
 }): Promise<void>;
 export declare function setPendingDashboardSessionAction(host: DashboardOpsHost, sessionId: string, kind: PendingSessionActionKind | null, opts?: {
     sessionSeed?: DashboardSession;

package/dist/multiplexer/dashboard-ops.js

@@ -300,7 +300,7 @@ export async function spawnDashboardAgentWithFeedback(host, input) {
                 tool: input.tool,
                 sessionId: input.sessionId,
                 worktreePath: input.worktreePath,
-                extraArgs: input.extraArgs,
+                launchOverride: input.launchOverride,
                 open: false,
             }, { timeoutMs: 10_000 });
         },
@@ -330,7 +330,7 @@ export async function forkDashboardAgentWithFeedback(host, input) {
                 tool: input.tool,
                 instruction: input.instruction,
                 worktreePath: input.worktreePath,
-                extraArgs: input.extraArgs,
+                launchOverride: input.launchOverride,
                 open: false,
             }, { timeoutMs: 10_000 });
         },

package/dist/multiplexer/dashboard-tail-methods.d.ts

@@ -3,6 +3,7 @@ import type { Multiplexer, SessionState } from "./index.js";
 import { dashboardSessionActionDeps as dashboardSessionActionDepsImpl } from "./dashboard-ops.js";
 import type { PendingServiceActionKind, PendingSessionActionKind } from "../pending-actions.js";
 import type { SessionRuntime } from "../session-runtime.js";
+import type { LaunchOverride } from "../shell-args.js";
 export type DashboardTailMethods = {
     forkAgent(this: Multiplexer, opts: {
         sourceSessionId: string;
@@ -11,7 +12,7 @@ export type DashboardTailMethods = {
         instruction?: string;
         targetWorktreePath?: string;
         open?: boolean;
-        extraArgs?: string[];
+        launchOverride?: LaunchOverride;
     }): Promise<{
         sessionId: string;
         threadId: string;
@@ -21,7 +22,7 @@ export type DashboardTailMethods = {
         targetSessionId?: string;
         targetWorktreePath?: string;
         open?: boolean;
-        extraArgs?: string[];
+        launchOverride?: LaunchOverride;
     }): Promise<{
         sessionId: string;
     }>;

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

@@ -55,7 +55,7 @@ function refreshLifecycleViews(host) {
 }
 export const dashboardTailMethods = {
     async forkAgent(opts) {
-        const result = await this.forkSessionFromSource(opts.sourceSessionId, opts.targetToolConfigKey, opts.targetSessionId, opts.instruction, opts.targetWorktreePath, opts.extraArgs ?? []);
+        const result = await this.forkSessionFromSource(opts.sourceSessionId, opts.targetToolConfigKey, opts.targetSessionId, opts.instruction, opts.targetWorktreePath, opts.launchOverride);
         if (!result) {
             throw new Error(`Unable to fork agent "${opts.sourceSessionId}"`);
         }
@@ -71,7 +71,7 @@ export const dashboardTailMethods = {
             throw new Error(`Unknown tool config: ${opts.toolConfigKey}`);
         }
         const sessionId = opts.targetSessionId ?? this.generateDashboardSessionId?.(tool.command);
-        const transport = this.createSession(tool.command, [...tool.args, ...(opts.extraArgs ?? [])], tool.preambleFlag, opts.toolConfigKey, undefined, tool.sessionIdFlag, opts.targetWorktreePath, undefined, sessionId, !opts.open);
+        const transport = this.createSession(opts.launchOverride?.command ?? tool.command, opts.launchOverride?.args ?? tool.args, tool.preambleFlag, opts.toolConfigKey, undefined, tool.sessionIdFlag, opts.targetWorktreePath, undefined, sessionId, !opts.open, false, undefined, opts.launchOverride?.env);
         if (opts.open) {
             this.openLiveTmuxWindowForEntry({ id: transport.id });
         }

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

@@ -2,6 +2,7 @@ import { closeNotificationPanel as closeNotificationPanelImpl, handleNotificatio
 import { beginWorktreeRemoval as beginWorktreeRemovalImpl, finishWorktreeRemoval as finishWorktreeRemovalImpl, handleWorktreeInputKey as handleWorktreeInputKeyImpl, handleWorktreeRemoveConfirmKey as handleWorktreeRemoveConfirmKeyImpl, handleWorktreeListKey as handleWorktreeListKeyImpl, renderWorktreeInput as renderWorktreeInputImpl, renderWorktreeList as renderWorktreeListImpl, renderWorktreeRemoveConfirm as renderWorktreeRemoveConfirmImpl, showWorktreeCreatePrompt as showWorktreeCreatePromptImpl, showWorktreeList as showWorktreeListImpl, } from "./worktrees.js";
 import { createService as createServiceImpl, removeOfflineService as removeOfflineServiceImpl, resumeOfflineService as resumeOfflineServiceImpl, resumeOfflineServiceById as resumeOfflineServiceByIdImpl, serviceLabelForCommand as serviceLabelForCommandImpl, stopService as stopServiceImpl, } from "./services.js";
 import { derivedStatusLabel } from "../dashboard/index.js";
+import { isDevelopmentRuntime } from "../connection-targets.js";
 import { selectDashboardTeammates } from "../dashboard/session-registry.js";
 import { hasRuntimeEvidence, isAttachableDashboardSessionEntry } from "../dashboard/runtime-evidence.js";
 export const dashboardViewMethods = {
@@ -113,6 +114,7 @@ export const dashboardViewMethods = {
                 selectedServiceId: selectedService,
                 selectedTeammates: selectDashboardTeammates(dashTeammates, selectedSessionEntry),
                 runtimeLabel: "tmux",
+                isDevRuntime: isDevelopmentRuntime(),
                 mainCheckout: mainCheckoutInfo,
                 operationFailures: this.dashboardOperationFailuresCache ?? [],
                 worktreeRemoval: this.worktreeRemovalJob

package/dist/multiplexer/index.d.ts

@@ -185,7 +185,7 @@ export declare class Multiplexer {
      * Starts fresh sessions but with context from the previous conversation.
      */
     restoreSessions(toolFilter?: string): Promise<number>;
-    createSession(command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean, team?: SessionTeamMetadata): SessionTransport;
+    createSession(command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean, team?: SessionTeamMetadata, launchEnv?: Record<string, string>): SessionTransport;
     recordSessionBackendSessionId(sessionId: string, backendSessionId: string): {
         sessionId: string;
         backendSessionId: string;

package/dist/multiplexer/index.js

@@ -317,8 +317,8 @@ export class Multiplexer {
     async restoreSessions(toolFilter) {
         return restoreSessionsImpl(this, toolFilter);
     }
-    createSession(command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux = false, suppressStartupPreamble = false, team) {
-        return createSessionImpl(this, command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux, suppressStartupPreamble, team);
+    createSession(command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux = false, suppressStartupPreamble = false, team, launchEnv) {
+        return createSessionImpl(this, command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux, suppressStartupPreamble, team, launchEnv);
     }
     recordSessionBackendSessionId(sessionId, backendSessionId) {
         return runtimeLifecycleMethods.recordSessionBackendSessionId.call(this, sessionId, backendSessionId);
@@ -348,7 +348,7 @@ export class Multiplexer {
     handleAction(action) {
         handleActionImpl(this, action);
     }
-    async forkSessionFromSource(sourceSessionId, targetToolConfigKey, requestedTargetSessionId, instruction, targetWorktreePath, extraArgs = []) {
+    async forkSessionFromSource(sourceSessionId, targetToolConfigKey, requestedTargetSessionId, instruction, targetWorktreePath, launchOverride) {
         const sourceSession = this.sessions.find((session) => session.id === sourceSessionId);
         if (!sourceSession) {
             this.showDashboardError("Cannot fork missing session", [`Source session ${sourceSessionId} not found.`]);
@@ -402,7 +402,7 @@ export class Multiplexer {
         ]
             .filter(Boolean)
             .join("\n\n");
-        const transport = this.createSession(toolCfg.command, [...toolCfg.args, ...extraArgs], toolCfg.preambleFlag, targetToolConfigKey, extraPreamble, toolCfg.sessionIdFlag, targetWorktree, undefined, targetSessionId, !toolCfg.preambleFlag);
+        const transport = this.createSession(launchOverride?.command ?? toolCfg.command, launchOverride?.args ?? toolCfg.args, toolCfg.preambleFlag, targetToolConfigKey, extraPreamble, toolCfg.sessionIdFlag, targetWorktree, undefined, targetSessionId, !toolCfg.preambleFlag, false, undefined, launchOverride?.env);
         this.agentTracker.emit(sourceSessionId, {
             kind: "status",
             message: `Forked ${targetSessionId} from this session`,

package/dist/multiplexer/persistence-methods.js

@@ -5,6 +5,7 @@ import { addDashboardOperationFailure, clearDashboardOperationFailures, listDash
 import { composeDashboardWorktreeGroups } from "./dashboard-model.js";
 import { loadDaemonInfo } from "../daemon.js";
 import { getProjectStateDir, getStatePath } from "../paths.js";
+import { writeJsonAtomic } from "../atomic-write.js";
 import { loadMetadataState } from "../metadata-store.js";
 import { createRuntimeExchangeStore } from "../runtime-core/exchange-store.js";
 import { renderCurrentDashboardView as renderCurrentDashboardViewImpl } from "./runtime-state.js";
@@ -855,7 +856,7 @@ function removePersistedServicesForWorktree(path) {
         const nextServices = (state.services ?? []).filter((service) => service.worktreePath !== path);
         if (nextServices.length === (state.services ?? []).length)
             return;
-        writeFileSync(statePath, JSON.stringify({ ...state, services: nextServices }, null, 2) + "\n");
+        writeJsonAtomic(statePath, { ...state, services: nextServices });
     }
     catch { }
 }

package/dist/multiplexer/runtime-lifecycle-methods.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { closeDebug, debug } from "../debug.js";
 import { loadConfig } from "../config.js";
 import { getStatePath } from "../paths.js";
+import { quarantineCorruptFile, writeJsonAtomic } from "../atomic-write.js";
 import { buildAimuxAgentInstructions } from "../session-bootstrap.js";
 import { listTopologySessionStates, saveRuntimeTopologySessions } from "../runtime-core/topology-sessions.js";
 import { adjustAfterRemove as adjustAfterRemoveImpl, buildLiveServiceStates as buildLiveServiceStatesImpl, evictZombieSession as evictZombieSessionImpl, graveyardSession as graveyardSessionImpl, isSessionRuntimeLive as isSessionRuntimeLiveImpl, loadOfflineServices as loadOfflineServicesImpl, loadOfflineTopologySessions as loadOfflineTopologySessionsImpl, restoreTmuxSessionsFromTopology as restoreTmuxSessionsFromTopologyImpl, recordSessionBackendSessionId as recordSessionBackendSessionIdImpl, resumeOfflineSession as resumeOfflineSessionImpl, startHeartbeat as startHeartbeatImpl, startProjectServiceRefresh as startProjectServiceRefreshImpl, startStatusRefresh as startStatusRefreshImpl, stopHeartbeat as stopHeartbeatImpl, stopProjectServiceRefresh as stopProjectServiceRefreshImpl, stopSessionToOffline as stopSessionToOfflineImpl, stopStatusRefresh as stopStatusRefreshImpl, syncSessionsFromTopology as syncSessionsFromTopologyImpl, } from "./runtime-state.js";
@@ -92,6 +93,7 @@ export function loadStateStatic() {
         };
     }
     catch {
+        quarantineCorruptFile(statePath);
         return null;
     }
 }
@@ -261,7 +263,9 @@ export const runtimeLifecycleMethods = {
                 });
                 mergedServices = [...otherServices, ...myServices];
             }
-            catch { }
+            catch {
+                quarantineCorruptFile(statePath);
+            }
         }
         saveRuntimeTopologySessions({ sessions: mergedSessions });
         unpreservedExitedIds.clear();
@@ -270,7 +274,7 @@ export const runtimeLifecycleMethods = {
             cwd: process.cwd(),
             services: mergedServices,
         };
-        writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
+        writeJsonAtomic(statePath, state);
         this.invalidateDesktopStateSnapshot();
     },
     teardown() {

package/dist/multiplexer/runtime-state.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { discoverBackendSessionId } from "../backend-session-discovery.js";
 import { loadConfig } from "../config.js";
 import { loadMetadataState, updateSessionMetadata } from "../metadata-store.js";
 import { isToolInternalWorktree, listWorktrees as listAllWorktrees } from "../worktree.js";
@@ -419,7 +420,18 @@ export function resumeOfflineSession(host, session) {
         return;
     const derived = loadMetadataState().sessions[session.id]?.derived;
     const relaunchFresh = derived?.activity === "error" || derived?.attention === "error";
-    const backendSessionId = session.backendSessionId;
+    let backendSessionId = session.backendSessionId;
+    if (!backendSessionId && !relaunchFresh) {
+        // The durable backend id can be lost if a crash killed the tmux pane before
+        // it was captured. Recover it from the tool's on-disk session store so the
+        // agent stays resumable instead of being stranded.
+        const discovered = discoverBackendSessionId(session.toolConfigKey, session.worktreePath);
+        if (discovered) {
+            backendSessionId = discovered;
+            session.backendSessionId = discovered;
+            host.debug?.(`reconciled backend session id for ${session.id} from disk: ${discovered}`, "session");
+        }
+    }
     const useBackendResume = !relaunchFresh && host.sessionBootstrap.canResumeWithBackendSessionId(toolCfg, backendSessionId);
     let actionArgs;
     if (useBackendResume) {

package/dist/multiplexer/service-state-snapshot.js

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { getStatePath } from "../paths.js";
+import { quarantineCorruptFile, writeJsonAtomic } from "../atomic-write.js";
 import { buildServiceStateFromMetadata } from "./services.js";
 import { listWorktreeGraveyardPaths } from "./worktree-graveyard.js";
 function isAvailableSnapshotWorktree(worktreePath, graveyardPaths = listWorktreeGraveyardPaths()) {
@@ -61,11 +62,12 @@ export function persistProjectRuntimeSnapshotsBeforeTmuxStop(projectRoot, tmux)
             existing = JSON.parse(readFileSync(statePath, "utf-8"));
         }
         catch {
+            quarantineCorruptFile(statePath);
             existing = null;
         }
     }
     const nextState = mergeRuntimeSnapshots(existing, { services }, projectRoot);
-    writeFileSync(statePath, JSON.stringify(nextState, null, 2) + "\n");
+    writeJsonAtomic(statePath, nextState);
     return { sessions: [], services };
 }
 export function persistProjectServiceSnapshotsBeforeRuntimeStop(projectRoot, tmux) {

package/dist/multiplexer/services.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { findMainRepo } from "../worktree.js";
 import { getStatePath } from "../paths.js";
+import { writeJsonAtomic } from "../atomic-write.js";
 import { wrapCommandWithShellIntegration, wrapInteractiveShellWithIntegration } from "../shell-hooks.js";
 import { markLastUsed } from "../last-used.js";
 import { removeTopologyService, upsertTopologyService, } from "../runtime-core/topology-services.js";
@@ -119,7 +120,7 @@ export function createService(host, commandLine, worktreePath, opts) {
     const command = wrapped.command;
     const args = wrapped.args;
     const label = serviceLabelForCommand(trimmed);
-    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(process.cwd());
+    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(projectRoot);
     const shouldRenderPending = host.startedInDashboard && host.mode === "dashboard";
     if (shouldRenderPending) {
         host.setPendingDashboardServiceAction(serviceId, "creating", {
@@ -237,7 +238,7 @@ export function removeOfflineService(host, serviceId) {
         try {
             const state = JSON.parse(readFileSync(statePath, "utf-8"));
             state.services = (state.services ?? []).filter((service) => service.id !== serviceId);
-            writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
+            writeJsonAtomic(statePath, state);
         }
         catch { }
     }
@@ -299,7 +300,7 @@ export function resumeOfflineService(host, service) {
     const command = wrapped.command;
     const args = wrapped.args;
     const label = service.label ?? serviceLabelForCommand(launchCommandLine);
-    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(process.cwd());
+    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(projectRoot);
     const retainedTarget = service.tmuxTarget && host.tmuxRuntimeManager.hasWindow?.(service.tmuxTarget) ? service.tmuxTarget : undefined;
     const target = retainedTarget ??
         host.tmuxRuntimeManager.createWindow(tmuxSession.sessionName, label, resumeCwd, command, args, {

package/dist/multiplexer/session-launch.d.ts

@@ -10,7 +10,7 @@ export declare function runDashboard(host: SessionLaunchHost): Promise<number>;
 export declare function runProjectService(host: SessionLaunchHost): Promise<number>;
 export declare function resumeSessions(host: SessionLaunchHost, toolFilter?: string): Promise<number>;
 export declare function restoreSessions(host: SessionLaunchHost, toolFilter?: string): Promise<number>;
-export declare function createSession(host: SessionLaunchHost, command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean, team?: SessionTeamMetadata): any;
+export declare function createSession(host: SessionLaunchHost, command: string, args: string[], preambleFlag?: string[], toolConfigKey?: string, extraPreamble?: string, sessionIdFlag?: string[], worktreePath?: string, backendSessionIdOverride?: string, sessionIdOverride?: string, detachedInTmux?: boolean, suppressStartupPreamble?: boolean, team?: SessionTeamMetadata, launchEnv?: Record<string, string>): any;
 export declare function migrateAgent(host: SessionLaunchHost, sessionId: string, targetWorktreePath: string): Promise<void>;
 export declare function getSessionWorktreePath(host: SessionLaunchHost, sessionId: string): string | undefined;
 export declare function getSessionsByWorktree(host: SessionLaunchHost): Map<string | undefined, any[]>;

package/dist/multiplexer/session-launch.js

@@ -306,7 +306,7 @@ export async function restoreSessions(host, toolFilter) {
     host.openTmuxDashboardTarget();
     return 0;
 }
-export function createSession(host, command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux = false, suppressStartupPreamble = false, team) {
+export function createSession(host, command, args, preambleFlag, toolConfigKey, extraPreamble, sessionIdFlag, worktreePath, backendSessionIdOverride, sessionIdOverride, detachedInTmux = false, suppressStartupPreamble = false, team, launchEnv) {
     const cols = process.stdout.columns ?? 80;
     const sessionId = sessionIdOverride ?? `${command}-${Math.random().toString(36).slice(2, 8)}`;
     if (host.sessions.some((session) => session.id === sessionId)) {
@@ -314,6 +314,8 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
     }
     const config = loadConfig();
     const toolCfg = toolConfigKey ? config.tools[toolConfigKey] : undefined;
+    // A launch override may swap the binary; aimux flags/preamble only apply to the tool's own command.
+    const isConfiguredToolCommand = Boolean(toolCfg && toolCfg.command === command);
     const isClaudeResumeStyleLaunch = Boolean(toolCfg && toolConfigKey === "claude" && toolCfg.command === command) &&
         shouldSkipClaudeSessionIdInjection(args);
     const explicitClaudeBackendSessionId = toolCfg && toolConfigKey === "claude" && toolCfg.command === command
@@ -323,7 +325,7 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
         ? extractCodexBackendSessionIdFromArgs(args)
         : undefined;
     const effectiveSuppressStartupPreamble = suppressStartupPreamble;
-    const effectiveSessionIdFlag = isClaudeResumeStyleLaunch ? undefined : sessionIdFlag;
+    const effectiveSessionIdFlag = isConfiguredToolCommand && !isClaudeResumeStyleLaunch ? sessionIdFlag : undefined;
     const backendSessionId = backendSessionIdOverride ??
         explicitClaudeBackendSessionId ??
         explicitCodexBackendSessionId ??
@@ -339,7 +341,7 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
             includeAimuxPreamble: automaticPreambleEnabled,
             team,
         });
-    const shouldInjectLaunchPreamble = Boolean(!effectiveSuppressStartupPreamble && preambleFlag && preamble.trim());
+    const shouldInjectLaunchPreamble = Boolean(isConfiguredToolCommand && !effectiveSuppressStartupPreamble && preambleFlag && preamble.trim());
     const shouldInjectCodexDeveloperInstructions = Boolean(!effectiveSuppressStartupPreamble &&
         toolCfg?.command === command &&
         command === "codex" &&
@@ -375,6 +377,7 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
             command: launchCommand,
             args: finalArgs,
             extraEnv: {
+                ...(launchEnv ?? {}),
                 AIMUX_SESSION_ID: sessionId,
                 AIMUX_TOOL: toolConfigKey ?? command,
             },
@@ -382,13 +385,23 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
         launchCommand = wrapped.command;
         finalArgs = wrapped.args;
     }
-    else if (toolCfg && toolCfg.command === command) {
+    else if (isConfiguredToolCommand) {
         const wrapped = wrapCommandWithShellIntegration({
             projectRoot,
             sessionId,
             tool: toolConfigKey ?? command,
             command: launchCommand,
             args: finalArgs,
+            extraEnv: launchEnv,
+        });
+        launchCommand = wrapped.command;
+        finalArgs = wrapped.args;
+    }
+    else if (launchEnv && Object.keys(launchEnv).length > 0) {
+        const wrapped = wrapCommandWithManagedLaunchEnv({
+            command: launchCommand,
+            args: finalArgs,
+            extraEnv: launchEnv,
         });
         launchCommand = wrapped.command;
         finalArgs = wrapped.args;
@@ -399,7 +412,7 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
     debug(`creating session: ${command} (configKey=${toolConfigKey ?? "cli"}, backendId=${backendSessionId ?? "none"}, cwd=${worktreePath ?? process.cwd()}, args=${finalArgs.length})`, "session");
     debug(`spawn args: ${JSON.stringify(summarizeLaunchArgs(finalArgs))}`, "session");
     const sessionStartTime = Date.now();
-    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(process.cwd());
+    const tmuxSession = host.tmuxRuntimeManager.ensureProjectSession(projectRoot);
     const target = host.tmuxRuntimeManager.createWindow(tmuxSession.sessionName, host.getSessionLabel(sessionId) ?? command, worktreePath ?? process.cwd(), launchCommand, finalArgs, { detached: detachedInTmux });
     const tmuxTransport = new TmuxSessionTransport(sessionId, command, target, host.tmuxRuntimeManager, cols, process.stdout.rows ?? 24);
     host.sessionTmuxTargets.set(sessionId, target);
@@ -409,7 +422,6 @@ export function createSession(host, command, args, preambleFlag, toolConfigKey,
     if (session instanceof TmuxSessionTransport) {
         host.syncTmuxWindowMetadata(sessionId);
     }
-    void projectRoot;
     host.activeIndex = host.sessions.length - 1;
     if (host.startedInDashboard && host.mode === "dashboard") {
         host.invalidateDesktopStateSnapshot();

package/dist/multiplexer/session-runtime-core.js

@@ -8,6 +8,7 @@ import { SessionRuntime } from "../session-runtime.js";
 import { TmuxSessionTransport } from "../tmux/session-transport.js";
 import { loadMetadataState } from "../metadata-store.js";
 import { parseAgentOutput } from "../agent-output-parser.js";
+import { normalizeSubmittedPrompt, waitForTmuxPromptSubmit } from "../agent-prompt-delivery.js";
 import { captureGitContext } from "../context/context-bridge.js";
 export function getSessionLabel(host, sessionId) {
     return (host.sessionLabels.get(sessionId) ?? host.offlineSessions.find((session) => session.id === sessionId)?.label);
@@ -166,8 +167,14 @@ export async function sendAgentInput(host, sessionId, text) {
         if (!target)
             throw new Error(`Session "${sessionId}" does not have a live tmux target`);
         session.transport.retarget(target);
-        session.transport.write(text);
-        session.transport.write("\r");
+        const prompt = normalizeSubmittedPrompt(host.sessionToolKeys.get(sessionId), text, true);
+        session.transport.write(prompt);
+        await waitForTmuxPromptSubmit({
+            tmuxRuntimeManager: host.tmuxRuntimeManager,
+            target,
+            draft: prompt,
+            isTargetCurrent: () => resolveLiveSessionTmuxTarget(host, sessionId, target)?.windowId === target.windowId,
+        });
     }
     else {
         session.write(text);

package/dist/multiplexer/tool-picker.d.ts

@@ -1,10 +1,11 @@
 import { type ToolConfig } from "../config.js";
+import { type LaunchOverride } from "../shell-args.js";
 type ToolPickerHost = any;
 export declare function buildToolPickerOverlayOutput(host: ToolPickerHost): string;
 export declare function buildToolOptionsOverlayOutput(host: ToolPickerHost): string;
 export declare function renderToolPicker(host: ToolPickerHost): void;
 export declare function runSelectedTool(host: ToolPickerHost, toolKey: string, tool: ToolConfig, opts?: {
-    extraArgs?: string[];
+    override?: LaunchOverride;
 }): void;
 export declare function showToolPicker(host: ToolPickerHost, sourceSessionId?: string): void;
 export declare function handleToolPickerKey(host: ToolPickerHost, data: Buffer): void;

package/dist/multiplexer/tool-picker.js

@@ -1,6 +1,6 @@
 import { loadConfig } from "../config.js";
 import { parseKeys } from "../key-parser.js";
-import { parseShellArgs } from "../shell-args.js";
+import { parseLaunchCommandLine } from "../shell-args.js";
 import { forkDashboardAgentWithFeedback, spawnDashboardAgentWithFeedback } from "./dashboard-ops.js";
 function enabledTools() {
     const config = loadConfig();
@@ -67,28 +67,37 @@ export function buildToolOptionsOverlayOutput(host) {
     }
     const [toolKey, tool] = selected;
     const buffer = host.toolOptionsBuffer ?? "";
-    let parsedExtraArgs = [];
+    let override;
     let parseError = host.toolOptionsError;
     if (!parseError) {
         try {
-            parsedExtraArgs = parseShellArgs(buffer);
+            override = parseLaunchCommandLine(buffer);
         }
         catch (error) {
             parseError = error instanceof Error ? error.message : String(error);
         }
     }
-    const defaultArgs = tool.args.length ? tool.args.map(quoteShellArg).join(" ") : "(none)";
-    const preview = commandPreview(tool.command, [...tool.args, ...parsedExtraArgs]);
     const lines = [
         host.pickerMode === "fork" && host.forkSourceSessionId
-            ? `Fork ${toolKey}: launch options`
-            : `${toolKey}: launch options`,
+            ? `Fork ${toolKey}: launch command`
+            : `${toolKey}: launch command`,
         "",
-        `  Default args: ${defaultArgs}`,
-        `  Extra args:   ${buffer}_`,
-        "",
-        `  Command: ${preview}`,
+        `  ${buffer}_`,
     ];
+    if (override) {
+        lines.push("");
+        if (override.env) {
+            const envStr = Object.entries(override.env)
+                .map(([key, value]) => `${key}=${quoteShellArg(value)}`)
+                .join(" ");
+            lines.push(`  Env:    ${envStr}`);
+        }
+        lines.push(`  Launch: ${commandPreview(override.command, override.args)}`);
+        lines.push("");
+        lines.push(override.command === tool.command
+            ? "  aimux hooks + session tracking applied"
+            : "  custom binary — launched without aimux hooks");
+    }
     if (parseError) {
         lines.push("");
         lines.push(`  Error: ${parseError}`);
@@ -106,8 +115,7 @@ export function renderToolPicker(host) {
 }
 export function runSelectedTool(host, toolKey, tool, opts = {}) {
     const wtPath = host.mode === "dashboard" ? host.dashboardState.focusedWorktreePath : undefined;
-    const extraArgs = opts.extraArgs ?? [];
-    const launchArgs = [...tool.args, ...extraArgs];
+    const override = opts.override;
     if (host.pickerMode === "fork") {
         const sourceSessionId = host.forkSourceSessionId;
         host.pickerMode = "create";
@@ -127,7 +135,7 @@ export function runSelectedTool(host, toolKey, tool, opts = {}) {
                 targetSessionId,
                 tool: toolKey,
                 worktreePath: wtPath,
-                extraArgs,
+                launchOverride: override,
             });
             return;
         }
@@ -137,7 +145,7 @@ export function runSelectedTool(host, toolKey, tool, opts = {}) {
             targetSessionId,
             targetWorktreePath: wtPath,
             open: false,
-            extraArgs,
+            launchOverride: override,
         });
         return;
     }
@@ -153,11 +161,11 @@ export function runSelectedTool(host, toolKey, tool, opts = {}) {
             sessionId,
             tool: toolKey,
             worktreePath: wtPath,
-            extraArgs,
+            launchOverride: override,
         });
         return;
     }
-    host.createSession(tool.command, launchArgs, tool.preambleFlag, toolKey, undefined, tool.sessionIdFlag, wtPath, undefined, sessionId);
+    host.createSession(override?.command ?? tool.command, override?.args ?? tool.args, tool.preambleFlag, toolKey, undefined, tool.sessionIdFlag, wtPath, undefined, sessionId, false, false, undefined, override?.env);
 }
 export function showToolPicker(host, sourceSessionId) {
     host.pickerMode = sourceSessionId ? "fork" : "create";
@@ -204,7 +212,7 @@ export function handleToolPickerKey(host, data) {
             return;
         }
         host.toolOptionsToolKey = picked[0];
-        host.toolOptionsBuffer = "";
+        host.toolOptionsBuffer = commandPreview(picked[1].command, picked[1].args);
         host.toolOptionsError = null;
         host.openDashboardOverlay("tool-options");
         if (typeof host.redrawDashboardWithOverlay === "function") {
@@ -271,9 +279,9 @@ export function handleToolOptionsKey(host, data) {
             return;
         }
         const [toolKey, tool] = selected;
-        let extraArgs;
+        let override;
         try {
-            extraArgs = parseShellArgs(host.toolOptionsBuffer ?? "");
+            override = parseLaunchCommandLine(host.toolOptionsBuffer ?? "");
         }
         catch (error) {
             host.toolOptionsError = error instanceof Error ? error.message : String(error);
@@ -286,7 +294,7 @@ export function handleToolOptionsKey(host, data) {
             return;
         }
         host.clearDashboardOverlay();
-        runSelectedTool(host, toolKey, tool, { extraArgs });
+        runSelectedTool(host, toolKey, tool, { override });
         return;
     }
     if (event.name === "paste" || event.char) {

package/dist/notify.d.ts

@@ -7,7 +7,7 @@ export declare function notifyPrompt(sessionId: string): void;
 export declare function notifyError(sessionId: string, message?: string): void;
 /** Notify that an agent completed (exited cleanly) */
 export declare function notifyComplete(sessionId: string): void;
-export declare function notifyAlert(event: AlertEvent): void;
+export declare function notifyAlert(event: AlertEvent): boolean;
 export declare function notifyRemoteClientConnected(input: {
     title?: unknown;
     body?: unknown;