oh-my-codex 0.7.5 → 0.8.0

package/dist/team/runtime.js

@@ -3,11 +3,14 @@ import { existsSync } from 'fs';
 import { readdir, readFile } from 'fs/promises';
 import { performance } from 'perf_hooks';
 import { spawn } from 'child_process';
-import { sanitizeTeamName, isTmuxAvailable, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, dismissTrustPromptIfPresent, sleepFractionalSeconds, sendToWorker, sendToWorkerStdin, notifyLeaderStatus, isWorkerAlive, getWorkerPanePid, killWorker, killWorkerByPaneId, unregisterResizeHook, destroyTeamSession, listTeamSessions, } from './tmux-session.js';
-import { teamInit as initTeamState, DEFAULT_MAX_WORKERS, teamReadConfig as readTeamConfig, teamWriteWorkerIdentity as writeWorkerIdentity, teamReadWorkerHeartbeat as readWorkerHeartbeat, teamReadWorkerStatus as readWorkerStatus, teamWriteWorkerInbox as writeWorkerInbox, teamCreateTask as createStateTask, teamReadTask as readTask, teamListTasks as listTasks, teamReadManifest as readTeamManifestV2, teamNormalizePolicy as normalizeTeamPolicy, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamAppendEvent as appendTeamEvent, teamReadTaskApproval as readTaskApproval, teamListMailbox as listMailboxMessages, teamMarkMessageNotified as markMessageNotified, teamEnqueueDispatchRequest as enqueueDispatchRequest, teamMarkDispatchRequestNotified as markDispatchRequestNotified, teamTransitionDispatchRequest as transitionDispatchRequest, teamReadDispatchRequest as readDispatchRequest, teamCleanup as cleanupTeamState, teamSaveConfig as saveTeamConfig, teamWriteShutdownRequest as writeShutdownRequest, teamReadShutdownAck as readShutdownAck, teamReadMonitorSnapshot as readMonitorSnapshot, teamWriteMonitorSnapshot as writeMonitorSnapshot, teamReadPhase as readTeamPhaseState, teamWritePhase as writeTeamPhaseState, } from './team-ops.js';
+import { sanitizeTeamName, isTmuxAvailable, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, dismissTrustPromptIfPresent, sleepFractionalSeconds, sendToWorker, sendToLeaderPane, sendToWorkerStdin, isWorkerAlive, getWorkerPanePid, killWorkerByPaneIdAsync, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listTeamSessions, } from './tmux-session.js';
+import { teamInit as initTeamState, DEFAULT_MAX_WORKERS, teamReadConfig as readTeamConfig, teamWriteWorkerIdentity as writeWorkerIdentity, teamReadWorkerHeartbeat as readWorkerHeartbeat, teamReadWorkerStatus as readWorkerStatus, teamWriteWorkerInbox as writeWorkerInbox, teamCreateTask as createStateTask, teamReadTask as readTask, teamListTasks as listTasks, teamReadManifest as readTeamManifestV2, teamNormalizePolicy as normalizeTeamPolicy, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamAppendEvent as appendTeamEvent, teamReadTaskApproval as readTaskApproval, teamListMailbox as listMailboxMessages, teamMarkMessageDelivered as markMessageDelivered, teamMarkMessageNotified as markMessageNotified, teamEnqueueDispatchRequest as enqueueDispatchRequest, teamMarkDispatchRequestNotified as markDispatchRequestNotified, teamTransitionDispatchRequest as transitionDispatchRequest, teamReadDispatchRequest as readDispatchRequest, teamCleanup as cleanupTeamState, teamSaveConfig as saveTeamConfig, teamWriteShutdownRequest as writeShutdownRequest, teamReadShutdownAck as readShutdownAck, teamReadMonitorSnapshot as readMonitorSnapshot, teamWriteMonitorSnapshot as writeMonitorSnapshot, teamReadPhase as readTeamPhaseState, teamWritePhase as writeTeamPhaseState, } from './team-ops.js';
 import { queueInboxInstruction, queueDirectMailboxMessage, queueBroadcastMailboxMessage, waitForDispatchReceipt, } from './mcp-comm.js';
 import { generateWorkerOverlay, writeTeamWorkerInstructionsFile, removeTeamWorkerInstructionsFile, generateInitialInbox, generateTaskAssignmentInbox, generateShutdownInbox, generateTriggerMessage, generateMailboxTriggerMessage, } from './worker-bootstrap.js';
+import { loadRolePrompt } from './role-router.js';
+import { codexPromptsDir } from '../utils/paths.js';
 import { isLowComplexityAgentType, resolveTeamWorkerLaunchArgs, TEAM_LOW_COMPLEXITY_DEFAULT_MODEL, resolveTeamLowComplexityDefaultModel, parseTeamWorkerLaunchArgs, splitWorkerLaunchArgs, } from './model-contract.js';
+import { resolveCanonicalTeamStateRoot } from './state-root.js';
 import { inferPhaseTargetFromTaskCounts, reconcilePhaseStateForMonitor } from './phase-controller.js';
 import { getTeamTmuxSessions } from '../notifications/tmux.js';
 import { hasStructuredVerificationEvidence } from '../verification/verifier.js';
@@ -83,7 +86,8 @@ function isPidAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
         return false;
     }
 }
@@ -100,8 +104,9 @@ async function waitForPidExit(pid, timeoutMs) {
 }
 async function teardownPromptWorker(teamName, workerName, fallbackPid, cwd, context) {
     const handle = getPromptWorkerHandle(teamName, workerName);
-    const pid = Number.isFinite(handle?.pid)
-        ? handle.pid
+    const handlePid = handle?.pid;
+    const pid = (typeof handlePid === 'number' && Number.isFinite(handlePid))
+        ? handlePid
         : (Number.isFinite(fallbackPid) && (fallbackPid ?? 0) > 0 ? fallbackPid : null);
     if (pid === null) {
         removePromptWorkerHandle(teamName, workerName);
@@ -115,7 +120,8 @@ async function teardownPromptWorker(teamName, workerName, fallbackPid, cwd, cont
             process.kill(pid, 'SIGTERM');
         }
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
         // Best effort.
     }
     const exitedOnTerm = await waitForPidExit(pid, PROMPT_WORKER_SIGTERM_WAIT_MS);
@@ -136,7 +142,8 @@ async function teardownPromptWorker(teamName, workerName, fallbackPid, cwd, cont
             process.kill(pid, 'SIGKILL');
         }
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
         // Best effort.
     }
     const exitedOnKill = await waitForPidExit(pid, PROMPT_WORKER_SIGKILL_WAIT_MS);
@@ -166,14 +173,13 @@ function isPromptWorkerAlive(config, worker) {
         process.kill(worker.pid, 0);
         return true;
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
         return false;
     }
 }
 export { TEAM_LOW_COMPLEXITY_DEFAULT_MODEL };
-export function resolveCanonicalTeamStateRoot(leaderCwd) {
-    return resolve(join(leaderCwd, '.omx', 'state'));
-}
+export { resolveCanonicalTeamStateRoot };
 function spawnPromptWorker(teamName, workerName, workerIndex, workerCwd, launchArgs, workerEnv, workerCli) {
     const processSpec = buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs, workerCwd, workerEnv, workerCli);
     const child = spawn(processSpec.command, processSpec.args, {
@@ -401,11 +407,24 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             const workerWorkspace = workerWorkspaceByName.get(workerName) ?? { cwd: leaderCwd };
             // Get tasks assigned to this worker
             const workerTasks = allTasks.filter(t => t.owner === workerName);
+            // Resolve per-worker role from assigned task roles
+            const taskRoles = workerTasks.map(t => t.role).filter(Boolean);
+            const uniqueTaskRoles = new Set(taskRoles);
+            const workerRole = taskRoles.length > 0 && uniqueTaskRoles.size === 1
+                ? taskRoles[0]
+                : agentType;
+            if (uniqueTaskRoles.size > 1) {
+                console.log(`[omx:team] ${workerName}: mixed task roles [${[...uniqueTaskRoles].join(', ')}], falling back to ${agentType}`);
+            }
+            // Load role-specific prompt content if role differs from default
+            const rolePromptContent = workerRole !== agentType
+                ? await loadRolePrompt(workerRole, codexPromptsDir())
+                : null;
             // Write worker identity
             const identity = {
                 name: workerName,
                 index: i,
-                role: agentType,
+                role: workerRole,
                 worker_cli: workerCliPlan[i - 1],
                 assigned_tasks: workerTasks.map(t => t.id),
                 working_dir: workerWorkspace.cwd,
@@ -448,6 +467,8 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             const inbox = generateInitialInbox(workerName, sanitized, agentType, workerTasks, {
                 teamStateRoot,
                 leaderCwd,
+                workerRole,
+                rolePromptContent: rolePromptContent ?? undefined,
             });
             const trigger = generateTriggerMessage(workerName, sanitized);
             const maxStartupDispatchRetries = 3;
@@ -524,15 +545,19 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             if (sessionName.includes(':')) {
                 for (const paneId of createdWorkerPaneIds) {
                     try {
-                        killWorkerByPaneId(paneId, createdLeaderPaneId);
+                        await killWorkerByPaneIdAsync(paneId, createdLeaderPaneId);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
                     }
-                    catch { /* ignore */ }
                 }
                 if (config?.hud_pane_id) {
                     try {
-                        killWorkerByPaneId(config.hud_pane_id, createdLeaderPaneId);
+                        await killWorkerByPaneIdAsync(config.hud_pane_id, createdLeaderPaneId);
+                    }
+                    catch (err) {
+                        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
                     }
-                    catch { /* ignore */ }
                 }
             }
             else {
@@ -573,7 +598,9 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
         }
         if (provisionedWorktrees.length > 0) {
             try {
-                await rollbackProvisionedWorktrees(provisionedWorktrees);
+                await rollbackProvisionedWorktrees(provisionedWorktrees, {
+                    skipBranchDeletion: options.ralph === true,
+                });
             }
             catch (cleanupError) {
                 rollbackErrors.push(`rollbackProvisionedWorktrees: ${String(cleanupError)}`);
@@ -691,6 +718,22 @@ export async function monitorTeam(teamName, cwd) {
     const mailboxDeliveryStartMs = performance.now();
     const mailboxNotifiedByMessageId = await deliverPendingMailboxMessages(sanitized, config, workers, previousSnapshot?.mailboxNotifiedByMessageId ?? {}, dispatchPolicy, cwd);
     const mailboxDeliveryMs = performance.now() - mailboxDeliveryStartMs;
+    // Prune ephemeral status messages from leader mailbox (TTL: 60s)
+    try {
+        const leaderMailbox = await listMailboxMessages(sanitized, 'leader-fixed', cwd);
+        const now = Date.now();
+        for (const msg of leaderMailbox) {
+            if (msg.from_worker === 'system' && msg.created_at) {
+                const age = now - new Date(msg.created_at).getTime();
+                if (age > 60_000) {
+                    await markMessageDelivered(sanitized, 'leader-fixed', msg.message_id, cwd);
+                }
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+    }
     const updatedAt = new Date().toISOString();
     const totalMs = performance.now() - monitorStartMs;
     await writeMonitorSnapshot(sanitized, {
@@ -788,7 +831,7 @@ export async function assignTask(teamName, workerName, taskId, cwd) {
                     waitForWorkerReady(config.tmux_session, workerInfo.index, 15_000, workerInfo.pane_id);
                 }
                 else {
-                    sleepFractionalSeconds(assignRetryDelayS);
+                    await new Promise(r => setTimeout(r, assignRetryDelayS * 1000));
                 }
             }
         }
@@ -805,7 +848,8 @@ export async function assignTask(teamName, workerName, taskId, cwd) {
         try {
             await writeWorkerInbox(sanitized, workerName, `# Assignment Cancelled\n\nTask ${taskId} was not dispatched due to ${reason}.\nDo not execute this task from prior inbox content.`, cwd);
         }
-        catch {
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
             // best effort
         }
         if (!released.ok) {
@@ -827,6 +871,7 @@ export async function reassignTask(teamName, taskId, _fromWorker, toWorker, cwd)
  */
 export async function shutdownTeam(teamName, cwd, options = {}) {
     const force = options.force === true;
+    const ralph = options.ralph === true;
     const sanitized = sanitizeTeamName(teamName);
     const config = await readTeamConfig(sanitized, cwd);
     if (!config) {
@@ -834,7 +879,9 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         try {
             destroyTeamSession(`omx-team-${sanitized}`);
         }
-        catch { /* ignore */ }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        }
         await cleanupTeamState(sanitized, cwd);
         restoreTeamModelInstructionsFile(sanitized);
         return;
@@ -854,10 +901,22 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         await appendTeamEvent(sanitized, {
             type: 'shutdown_gate',
             worker: 'leader-fixed',
-            reason: `allowed=${gate.allowed} total=${gate.total} pending=${gate.pending} blocked=${gate.blocked} in_progress=${gate.in_progress} completed=${gate.completed} failed=${gate.failed}`,
+            reason: `allowed=${gate.allowed} total=${gate.total} pending=${gate.pending} blocked=${gate.blocked} in_progress=${gate.in_progress} completed=${gate.completed} failed=${gate.failed}${ralph ? ' policy=ralph' : ''}`,
         }, cwd).catch(() => { });
         if (!gate.allowed) {
-            throw new Error(`shutdown_gate_blocked:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`);
+            const hasActiveWork = gate.pending > 0 || gate.blocked > 0 || gate.in_progress > 0;
+            if (ralph && !hasActiveWork) {
+                // Ralph policy: bypass on failure-only scenarios (no pending/blocked/in_progress tasks).
+                // This allows the ralph loop to retry rather than leaving stale team state.
+                await appendTeamEvent(sanitized, {
+                    type: 'ralph_cleanup_policy',
+                    worker: 'leader-fixed',
+                    reason: `gate_bypassed:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`,
+                }, cwd).catch(() => { });
+            }
+            else {
+                throw new Error(`shutdown_gate_blocked:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`);
+            }
         }
     }
     if (force) {
@@ -890,7 +949,9 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
                 inboxCorrelationKey: `shutdown:${w.name}`,
             });
         }
-        catch { /* worker might already be dead */ }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+        }
     }
     // 2. Wait up to 15s for workers to exit and collect acks
     const deadline = Date.now() + 15_000;
@@ -954,25 +1015,21 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         if (resizeHookWarning) {
             console.warn(`[team shutdown] ${sanitized}: ${resizeHookWarning}; continuing teardown`);
         }
-        for (const w of config.workers) {
-            try {
-                // Guard: never kill the leader's own pane or the HUD pane.
-                if (leaderPaneId && w.pane_id === leaderPaneId)
-                    continue;
-                if (hudPaneId && w.pane_id === hudPaneId)
-                    continue;
-                if (isWorkerAlive(sessionName, w.index, w.pane_id)) {
-                    killWorker(sessionName, w.index, w.pane_id, leaderPaneId ?? undefined);
-                }
-            }
-            catch { /* ignore */ }
-        }
+        const workerPaneIds = config.workers
+            .map((w) => w.pane_id)
+            .filter((paneId) => typeof paneId === 'string' && paneId.trim().length > 0);
+        await teardownWorkerPanes(workerPaneIds, {
+            leaderPaneId,
+            hudPaneId,
+        });
         // 4. Destroy tmux session
         if (!sessionName.includes(':')) {
             try {
                 destroyTeamSession(sessionName);
             }
-            catch { /* ignore */ }
+            catch (err) {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            }
         }
     }
     else {
@@ -991,9 +1048,23 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
     try {
         await removeTeamWorkerInstructionsFile(sanitized, cwd);
     }
-    catch { /* ignore */ }
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+    }
     restoreTeamModelInstructionsFile(sanitized);
-    // 6. Cleanup state
+    // 6. Ralph stricter completion logging
+    if (ralph) {
+        const finalTasks = await listTasks(sanitized, cwd).catch(() => []);
+        const completed = finalTasks.filter((t) => t.status === 'completed').length;
+        const failed = finalTasks.filter((t) => t.status === 'failed').length;
+        const pending = finalTasks.filter((t) => t.status === 'pending').length;
+        await appendTeamEvent(sanitized, {
+            type: 'ralph_cleanup_summary',
+            worker: 'leader-fixed',
+            reason: `total=${finalTasks.length} completed=${completed} failed=${failed} pending=${pending} force=${force}`,
+        }, cwd).catch(() => { });
+    }
+    // 7. Cleanup state
     await cleanupTeamState(sanitized, cwd);
 }
 /**
@@ -1016,7 +1087,8 @@ export async function resumeTeam(teamName, cwd) {
                 process.kill(worker.pid, 0);
                 return true;
             }
-            catch {
+            catch (err) {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
                 return false;
             }
         })
@@ -1094,7 +1166,8 @@ async function resolveLeaderSessionId(cwd) {
         if (typeof parsed.session_id === 'string' && parsed.session_id.trim() !== '')
             return parsed.session_id.trim();
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
         return '';
     }
     return '';
@@ -1144,7 +1217,7 @@ async function emitMonitorDerivedEvents(teamName, tasks, workers, previous, cwd)
         }
     }
 }
-function notifyWorkerOutcome(config, workerIndex, message, workerPaneId) {
+async function notifyWorkerOutcome(config, workerIndex, message, workerPaneId) {
     const worker = config.workers.find((candidate) => candidate.index === workerIndex);
     if (!worker)
         return { ok: false, transport: 'none', reason: 'worker_not_found' };
@@ -1168,7 +1241,7 @@ function notifyWorkerOutcome(config, workerIndex, message, workerPaneId) {
         return { ok: false, transport: 'tmux_send_keys', reason: 'tmux_unavailable' };
     }
     try {
-        sendToWorker(config.tmux_session, workerIndex, message, workerPaneId, worker.worker_cli);
+        await sendToWorker(config.tmux_session, workerIndex, message, workerPaneId, worker.worker_cli);
         return { ok: true, transport: 'tmux_send_keys', reason: 'tmux_send_keys_sent' };
     }
     catch (error) {
@@ -1240,7 +1313,7 @@ async function dispatchCriticalInboxInstruction(params) {
         return { ok: true, transport: 'hook', reason: `hook_receipt_${receipt.status}`, request_id: queued.request_id };
     }
     if (receipt?.status === 'failed') {
-        const fallback = notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
+        const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
         if (fallback.ok) {
             await transitionDispatchRequest(teamName, queued.request_id, 'failed', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
             return {
@@ -1258,7 +1331,7 @@ async function dispatchCriticalInboxInstruction(params) {
             request_id: queued.request_id,
         };
     }
-    const fallback = notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
+    const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
     if (fallback.ok) {
         const marked = await markDispatchRequestNotified(teamName, queued.request_id, { last_reason: `fallback_confirmed:${fallback.reason}` }, cwd);
         if (!marked) {
@@ -1293,9 +1366,9 @@ async function finalizeHookPreferredMailboxDispatch(params) {
         return { ok: true, transport: 'hook', reason: `hook_receipt_${receipt.status}`, request_id: requestId, message_id: messageId };
     }
     const fallback = fallbackNotify
-        ? fallbackNotify()
+        ? await fallbackNotify()
         : (typeof workerIndex === 'number'
-            ? notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId)
+            ? await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId)
             : { ok: false, transport: 'none', reason: 'missing_worker_index' });
     if (receipt?.status === 'failed') {
         if (fallback.ok) {
@@ -1344,10 +1417,25 @@ async function finalizeHookPreferredMailboxDispatch(params) {
         message_id: messageId,
     };
 }
-function notifyLeader(config, message) {
+async function notifyLeaderAsync(config, message, cwd) {
+    // Primary: inject directly into the leader pane via tmux send-keys.
+    // This is the fallback path when hook-based dispatch timed out, so the
+    // leader needs a direct tmux notification to wake up. Fixes #437.
+    if (config.leader_pane_id && isTmuxAvailable()) {
+        try {
+            await sendToLeaderPane(config.leader_pane_id, message);
+            return true;
+        }
+        catch (err) {
+            process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
+            // Fall through to mailbox
+        }
+    }
+    // Fallback: write to leader mailbox (leader picks up on next hook cycle)
     if (!config.tmux_session)
         return false;
-    return notifyLeaderStatus(config.tmux_session, message);
+    const { notifyLeaderMailboxAsync } = await import('./tmux-session.js');
+    return notifyLeaderMailboxAsync(config.name, 'system', message, cwd);
 }
 async function deliverPendingMailboxMessages(teamName, config, workers, previousNotifications, dispatchPolicy, cwd) {
     const nextNotifications = {};
@@ -1410,7 +1498,7 @@ async function deliverPendingMailboxMessages(teamName, config, workers, previous
                 });
             }
             else {
-                const direct = notifyWorkerOutcome(config, workerInfo.index, triggerMessage, workerInfo.pane_id);
+                const direct = await notifyWorkerOutcome(config, workerInfo.index, triggerMessage, workerInfo.pane_id);
                 outcome = { ...direct, request_id: queued.request.request_id, message_id: msg.message_id };
                 if (outcome.ok) {
                     await markMessageNotified(teamName, worker.name, msg.message_id, cwd).catch(() => false);
@@ -1451,9 +1539,9 @@ export async function sendWorkerMessage(teamName, fromWorker, toWorker, body, cw
             cwd,
             transportPreference: leaderTransportPreference,
             fallbackAllowed: leaderTransportPreference === 'hook_preferred_with_fallback',
-            notify: (_target, message) => (leaderTransportPreference === 'hook_preferred_with_fallback'
+            notify: async (_target, message) => (leaderTransportPreference === 'hook_preferred_with_fallback'
                 ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
-                : { ok: notifyLeader(config, message), transport: 'tmux_send_keys', reason: 'leader_notified' }),
+                : { ok: await notifyLeaderAsync(config, message, cwd), transport: 'mailbox', reason: 'leader_mailbox_notified' }),
         });
         let finalOutcome = outcome;
         const canLeaderFallbackDirectly = Boolean(config.leader_pane_id) && isTmuxAvailable();
@@ -1471,10 +1559,10 @@ export async function sendWorkerMessage(teamName, fromWorker, toWorker, body, cw
                 config,
                 dispatchPolicy,
                 cwd,
-                fallbackNotify: () => ({
-                    ok: notifyLeader(config, leaderTriggerMessage),
-                    transport: 'tmux_send_keys',
-                    reason: 'leader_notified',
+                fallbackNotify: async () => ({
+                    ok: await notifyLeaderAsync(config, leaderTriggerMessage, cwd),
+                    transport: 'mailbox',
+                    reason: 'leader_mailbox_notified',
                 }),
             });
         }
@@ -1500,9 +1588,9 @@ export async function sendWorkerMessage(teamName, fromWorker, toWorker, body, cw
         cwd,
         transportPreference,
         fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
-        notify: (_target, message) => (transportPreference === 'hook_preferred_with_fallback'
+        notify: async (_target, message) => (transportPreference === 'hook_preferred_with_fallback'
             ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
-            : notifyWorkerOutcome(config, recipient.index, message, recipient.pane_id)),
+            : await notifyWorkerOutcome(config, recipient.index, message, recipient.pane_id)),
     });
     let finalOutcome = outcome;
     if (transportPreference === 'hook_preferred_with_fallback') {
@@ -1544,10 +1632,10 @@ export async function broadcastWorkerMessage(teamName, fromWorker, body, cwd) {
         triggerFor: (workerName) => generateMailboxTriggerMessage(workerName, sanitized, 1),
         transportPreference,
         fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
-        notify: (target, message) => transportPreference === 'hook_preferred_with_fallback'
+        notify: async (target, message) => transportPreference === 'hook_preferred_with_fallback'
             ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
             : (typeof target.workerIndex === 'number'
-                ? notifyWorkerOutcome(config, target.workerIndex, message, target.paneId)
+                ? await notifyWorkerOutcome(config, target.workerIndex, message, target.paneId)
                 : { ok: false, transport: 'none', reason: 'missing_worker_index' }),
     });
     const finalizedOutcomes = [];