oh-my-codex 0.15.0 → 0.15.2

package/dist/team/runtime.js

@@ -3,11 +3,13 @@ import { existsSync, appendFileSync, mkdirSync } from 'fs';
 import { mkdir, readdir, readFile, writeFile } from 'fs/promises';
 import { performance } from 'perf_hooks';
 import { spawn, spawnSync } from 'child_process';
-import { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, dismissTrustPromptIfPresent, sleepFractionalSeconds, sendToWorker, sendToWorkerStdin, isWorkerAlive, isWorkerPaneOpen, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, listTeamSessions, resolveSharedSessionShutdownTopology, } 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, teamNormalizeGovernance as normalizeTeamGovernance, teamNormalizePolicy as normalizeTeamPolicy, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamReclaimExpiredTaskClaim as reclaimExpiredTaskClaim, 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, teamWriteWorkerStatus as writeWorkerStatus, } from './team-ops.js';
+import { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, waitForWorkerReadyAsync, dismissTrustPromptIfPresent, sendToWorker, sendToWorkerStdin, isWorkerAlive, isWorkerPaneOpen, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, listTeamSessions, resolveSharedSessionShutdownTopology, } 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, teamUpdateTask as updateTask, teamReadManifest as readTeamManifestV2, teamNormalizeGovernance as normalizeTeamGovernance, teamNormalizePolicy as normalizeTeamPolicy, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamReclaimExpiredTaskClaim as reclaimExpiredTaskClaim, 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, teamWriteWorkerStatus as writeWorkerStatus, } from './team-ops.js';
 import { queueInboxInstruction, queueDirectMailboxMessage, queueBroadcastMailboxMessage, waitForDispatchReceipt, } from './mcp-comm.js';
 import { appendTeamDeliveryLogForCwd } from './delivery-log.js';
+import { remapRepoAwareDecompositionMetadataToCreatedTasks, } from './repo-aware-decomposition.js';
 import { generateWorkerOverlay, writeTeamWorkerInstructionsFile, removeTeamWorkerInstructionsFile, writeWorkerWorktreeRootAgentsFile, removeWorkerWorktreeRootAgentsFile, generateInitialInbox, generateTaskAssignmentInbox, generateShutdownInbox, buildTriggerDirective, buildMailboxTriggerDirective, buildLeaderMailboxTriggerDirective, writeWorkerRoleInstructionsFile, } from './worker-bootstrap.js';
+import { synthesizeDelegationPlan } from './delegation-policy.js';
 import { loadRolePrompt } from './role-router.js';
 import { composeRoleInstructionsForRole } from '../agents/native-config.js';
 import { codexPromptsDir } from '../utils/paths.js';
@@ -20,7 +22,7 @@ import { hasStructuredVerificationEvidence } from '../verification/verifier.js';
 import { buildRebalanceDecisions } from './rebalance-policy.js';
 import { getStatePath } from '../mcp/state-paths.js';
 import { readModeState, updateModeState } from '../modes/base.js';
-import { appendTeamCommitHygieneEntries, buildTeamCommitHygieneContext, writeTeamCommitHygieneContext, } from './commit-hygiene.js';
+import { appendTeamCommitHygieneEntries, buildTeamCommitHygieneContext, resolveTeamCommitHygieneArtifactCwd, writeTeamCommitHygieneContext, } from './commit-hygiene.js';
 import { assertCleanLeaderWorkspaceForWorkerWorktrees, ensureWorktree, isGitRepository, isWorktreeDirty, planWorktreeTarget, removeWorktreeForce, rollbackProvisionedWorktrees, } from './worktree.js';
 import { cleanupOmxMcpProcesses, findLaunchSafeCleanupCandidates, } from '../cli/cleanup.js';
 async function syncRootTeamModeStateOnTerminalPhase(teamName, phase, cwd) {
@@ -371,7 +373,7 @@ async function integrateWorkerCommitsIntoLeader(params) {
     const leaderHeadAtCycleStart = resolveLeaderHead(resolve(config.workers[0]?.worktree_repo_root ?? cwd), cwd);
     const integratedWorkerNames = new Set();
     const commitHygieneEntries = [];
-    const artifactCwd = config.leader_cwd ?? cwd;
+    const artifactCwd = resolveTeamCommitHygieneArtifactCwd(config, cwd);
     // ── Phase A: Auto-commit dirty worktrees ──
     for (const worker of config.workers) {
         if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
@@ -927,9 +929,9 @@ const MODEL_INSTRUCTIONS_FILE_ENV = 'OMX_MODEL_INSTRUCTIONS_FILE';
 const TEAM_STATE_ROOT_ENV = 'OMX_TEAM_STATE_ROOT';
 const TEAM_LEADER_CWD_ENV = 'OMX_TEAM_LEADER_CWD';
 const WORKTREE_TRIGGER_STATE_ROOT = '$OMX_TEAM_STATE_ROOT';
-const STARTUP_EVIDENCE_TIMEOUT_MS = 2_000;
+const STARTUP_EVIDENCE_TIMEOUT_MS = 15_000;
 const STARTUP_EVIDENCE_POLL_MS = 100;
-const STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS = 5_000;
+const STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS = 45_000;
 const promptWorkerRegistry = new Map();
 const previousModelInstructionsFileByTeam = new Map();
 const PROMPT_WORKER_SIGTERM_WAIT_MS = 3_000;
@@ -1454,9 +1456,27 @@ function resolveEffectiveWorkerCliForStartupLog(resolvedLaunchArgs, env) {
     }
     return resolveTeamWorkerCli(resolvedLaunchArgs, env);
 }
-/**
- * Start a new team: init state, create tmux session, bootstrap workers.
- */
+async function writeDecompositionArtifacts(teamName, cwd, metadata) {
+    const root = join(resolveCanonicalTeamStateRoot(cwd), 'team', teamName);
+    await mkdir(root, { recursive: true });
+    await writeFile(join(root, 'decomposition-report.json'), JSON.stringify(metadata, null, 2), 'utf8');
+    const manifest = await readTeamManifestV2(teamName, cwd);
+    if (manifest) {
+        await writeFile(join(root, 'manifest.v2.json'), JSON.stringify({ ...manifest, team_decomposition: metadata }, null, 2), 'utf8');
+    }
+}
+export async function settleStartupAttemptResults(attempts) {
+    const settled = await Promise.allSettled(attempts.map((attempt) => attempt.attempt));
+    return settled.map((result, index) => {
+        if (result.status === 'fulfilled')
+            return result.value;
+        const descriptor = attempts[index];
+        const workerIndex = descriptor?.workerIndex ?? index + 1;
+        const workerName = descriptor?.workerName ?? `worker-${workerIndex}`;
+        const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        return { ok: false, workerIndex, workerName, error };
+    });
+}
 export async function startTeam(teamName, task, agentType, workerCount, tasks, cwd, options = {}) {
     const leaderCwd = resolve(cwd);
     await assertNestedTeamAllowed(leaderCwd);
@@ -1546,15 +1566,49 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
         config.team_state_root = teamStateRoot;
         config.workspace_mode = workspaceMode;
         config.worktree_mode = effectiveWorktreeMode;
-        // 4. Create tasks
+        // 4. Create tasks. Repo-aware DAG dependencies are symbolic until the
+        // state layer returns concrete task IDs, so create those tasks dependency
+        // free and patch runtime dependency fields after ID assignment.
+        const createdTasks = [];
         for (const t of tasks) {
-            await createStateTask(sanitized, {
+            const hasSymbolicDagIdentity = Boolean(t.symbolic_id);
+            const created = await createStateTask(sanitized, {
                 subject: t.subject,
                 description: t.description,
                 status: 'pending',
                 owner: t.owner,
-                blocked_by: t.blocked_by,
+                blocked_by: hasSymbolicDagIdentity ? undefined : t.blocked_by ?? t.depends_on,
+                depends_on: hasSymbolicDagIdentity ? undefined : t.depends_on ?? t.blocked_by,
                 role: t.role,
+                delegation: t.delegation ?? synthesizeDelegationPlan(t),
+                requires_code_change: t.requires_code_change,
+                filePaths: t.filePaths,
+                domains: t.domains,
+                lane: t.lane,
+                allocation_reason: t.allocation_reason,
+            }, leaderCwd);
+            createdTasks.push(created);
+        }
+        const effectiveDecompositionMetadata = options.decompositionMetadata
+            ? remapRepoAwareDecompositionMetadataToCreatedTasks(options.decompositionMetadata, tasks, createdTasks)
+            : undefined;
+        const nodeIdToTaskId = effectiveDecompositionMetadata?.node_id_to_task_id ?? {};
+        for (let index = 0; index < tasks.length; index += 1) {
+            const planned = tasks[index];
+            if (!planned?.symbolic_id)
+                continue;
+            const created = createdTasks[index];
+            if (!created)
+                continue;
+            const symbolicDeps = planned.symbolic_depends_on
+                ?? effectiveDecompositionMetadata?.node_dependencies?.[planned.symbolic_id]
+                ?? [];
+            const concreteDeps = symbolicDeps.map((dep) => nodeIdToTaskId[dep]).filter(Boolean);
+            if (concreteDeps.length === 0)
+                continue;
+            await updateTask(sanitized, created.id, {
+                blocked_by: concreteDeps,
+                depends_on: concreteDeps,
             }, leaderCwd);
         }
         // 5. Write team-scoped worker instructions file only for single-workspace mode.
@@ -1563,6 +1617,9 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             setTeamModelInstructionsFile(sanitized, workerInstructionsPath);
         }
         const allTasks = await listTasks(sanitized, leaderCwd);
+        if (effectiveDecompositionMetadata) {
+            await writeDecompositionArtifacts(sanitized, leaderCwd, effectiveDecompositionMetadata);
+        }
         const workerBootstrapPlans = [];
         for (let i = 1; i <= workerCount; i++) {
             const workerName = `worker-${i}`;
@@ -1603,6 +1660,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 workerRole: runtimeRole,
                 rolePromptContent: rawRolePromptContent ?? undefined,
                 worktreeRootAgentsCanonical: Boolean(workerWorkspace.worktreePath),
+                taskHints: effectiveDecompositionMetadata?.task_hints,
             });
             const triggerDirective = buildTriggerDirective(workerName, sanitized, resolveInstructionStateRoot(workerWorkspace.worktreePath));
             const trigger = triggerDirective.text;
@@ -1731,31 +1789,40 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             await materializeWorkerStartupState(bootstrapPlan, i, workerPaneIds[i - 1]);
         }
         await saveTeamConfig(config, leaderCwd);
-        // 7. Wait for all workers to be ready (interactive mode), then bootstrap them
+        // 7. Start all safe per-worker readiness/dispatch attempts concurrently.
+        // Pane creation and worktree provisioning above remain dependency-bound and
+        // ordered; readiness polling and startup dispatch must not let worker-1
+        // block later workers from receiving their own startup attempts.
         const manifest = await readTeamManifestV2(sanitized, leaderCwd);
         const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, workerLaunchMode);
-        for (let i = 1; i <= workerCount; i++) {
-            const bootstrapPlan = workerBootstrapPlans[i - 1];
+        const runWorkerStartupAttempt = async (workerIndex) => {
+            const bootstrapPlan = workerBootstrapPlans[workerIndex - 1];
             if (!bootstrapPlan) {
-                throw new Error(`missing bootstrap plan for worker-${i}`);
+                return {
+                    ok: false,
+                    workerIndex,
+                    workerName: `worker-${workerIndex}`,
+                    error: new Error(`missing bootstrap plan for worker-${workerIndex}`),
+                };
             }
-            const { workerName, paneId, workerTasks, inbox, trigger, triggerIntent, initialPrompt } = {
-                workerName: bootstrapPlan.workerName,
-                paneId: workerPaneIds[i - 1],
-                workerTasks: bootstrapPlan.workerTasks,
-                inbox: bootstrapPlan.inbox,
-                trigger: bootstrapPlan.trigger,
-                triggerIntent: bootstrapPlan.triggerIntent,
-                initialPrompt: bootstrapPlan.initialPrompt,
-            };
-            if (workerTasks.map(t => t.role).filter(Boolean).length > 0 && new Set(workerTasks.map(t => t.role).filter(Boolean)).size > 1) {
-                console.log(`[omx:team] ${workerName}: mixed task roles [${[...new Set(workerTasks.map(t => t.role).filter(Boolean))].join(', ')}], falling back to ${agentType}`);
+            const workerName = bootstrapPlan.workerName;
+            const paneId = workerPaneIds[workerIndex - 1];
+            const workerTasks = bootstrapPlan.workerTasks;
+            const inbox = bootstrapPlan.inbox;
+            const trigger = bootstrapPlan.trigger;
+            const triggerIntent = bootstrapPlan.triggerIntent;
+            const initialPrompt = bootstrapPlan.initialPrompt;
+            const taskRoles = workerTasks
+                .map((task) => task.role)
+                .filter((role) => Boolean(role));
+            const uniqueTaskRoles = [...new Set(taskRoles)];
+            if (uniqueTaskRoles.length > 1) {
+                console.log(`[omx:team] ${workerName}: mixed task roles [${uniqueTaskRoles.join(', ')}], falling back to ${agentType}`);
             }
-            // Wait for worker readiness
             if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt) {
-                const ready = waitForWorkerReady(sessionName, i, workerReadyTimeoutMs, paneId);
+                const ready = await waitForWorkerReadyAsync(sessionName, workerIndex, workerReadyTimeoutMs, paneId);
                 if (!ready) {
-                    const workerAlive = isWorkerPaneOpen(sessionName, i, paneId);
+                    const workerAlive = isWorkerPaneOpen(sessionName, workerIndex, paneId);
                     if (workerAlive) {
                         await recordRecoverableStartupIssue({
                             teamName: sanitized,
@@ -1764,14 +1831,16 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                             reason: 'ready_prompt_timeout',
                             cwd: leaderCwd,
                         });
-                        continue;
+                        return { ok: true, workerIndex, workerName };
                     }
-                    throw new Error(`Worker ${workerName} did not become ready in tmux session ${sessionName}`);
+                    return {
+                        ok: false,
+                        workerIndex,
+                        workerName,
+                        error: new Error(`Worker ${workerName} did not become ready in tmux session ${sessionName}`),
+                    };
                 }
             }
-            // Queue inbox via MCP/state then notify worker via tmux transport.
-            // Retry dispatch up to 3 times to handle Codex trust prompts that may
-            // block the worker pane during startup (fixes #393).
             let dispatchOutcome = initialPrompt
                 ? { ok: true, transport: 'none', reason: 'startup_prompt_delivered_at_launch' }
                 : { ok: false, transport: 'none', reason: 'not_attempted' };
@@ -1781,9 +1850,9 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                         teamName: sanitized,
                         config: config,
                         workerName,
-                        workerIndex: i,
+                        workerIndex,
                         paneId,
-                        workerCli: workerCliPlan[i - 1],
+                        workerCli: workerCliPlan[workerIndex - 1],
                         inbox,
                         triggerMessage: trigger,
                         intent: triggerIntent,
@@ -1796,25 +1865,24 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                     if (dispatchOutcome.ok)
                         break;
                     if (attempt < startupDispatchRetries) {
-                        // Check for trust prompt blocking the worker and dismiss it before retry
                         if (workerLaunchMode === 'interactive') {
-                            if (dismissTrustPromptIfPresent(sessionName, i, paneId)) {
-                                waitForWorkerReady(sessionName, i, workerReadyTimeoutMs, paneId);
+                            if (dismissTrustPromptIfPresent(sessionName, workerIndex, paneId)) {
+                                await waitForWorkerReadyAsync(sessionName, workerIndex, workerReadyTimeoutMs, paneId);
                             }
                             else {
-                                sleepFractionalSeconds(startupRetryDelayS);
+                                await new Promise((resolve) => setTimeout(resolve, Math.max(0, startupRetryDelayS * 1000)));
                             }
                         }
                         else {
-                            sleepFractionalSeconds(startupRetryDelayS);
+                            await new Promise((resolve) => setTimeout(resolve, Math.max(0, startupRetryDelayS * 1000)));
                         }
                     }
                 }
             }
             if (!dispatchOutcome.ok) {
                 const workerAlive = workerLaunchMode === 'prompt'
-                    ? isPromptWorkerAlive(config, config.workers[i - 1])
-                    : isWorkerPaneOpen(sessionName, i, paneId);
+                    ? isPromptWorkerAlive(config, config.workers[workerIndex - 1])
+                    : isWorkerPaneOpen(sessionName, workerIndex, paneId);
                 if (workerLaunchMode === 'interactive'
                     && workerAlive
                     && isRecoverableInteractiveStartupReason(dispatchOutcome.reason)) {
@@ -1825,10 +1893,32 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                         reason: dispatchOutcome.reason,
                         cwd: leaderCwd,
                     });
-                    continue;
+                    return { ok: true, workerIndex, workerName };
                 }
-                throw new Error(`worker_notify_failed:${workerName}:${dispatchOutcome.reason}`);
+                return {
+                    ok: false,
+                    workerIndex,
+                    workerName,
+                    error: new Error(`worker_notify_failed:${workerName}:${dispatchOutcome.reason}`),
+                };
             }
+            return { ok: true, workerIndex, workerName };
+        };
+        const startupAttemptResults = await settleStartupAttemptResults(Array.from({ length: workerCount }, (_, index) => {
+            const workerIndex = index + 1;
+            const bootstrapPlan = workerBootstrapPlans[index];
+            const workerName = bootstrapPlan?.workerName ?? `worker-${workerIndex}`;
+            return {
+                workerIndex,
+                workerName,
+                attempt: runWorkerStartupAttempt(workerIndex),
+            };
+        }));
+        const firstStartupError = startupAttemptResults
+            .filter((result) => !result.ok)
+            .sort((a, b) => a.workerIndex - b.workerIndex)[0];
+        if (firstStartupError) {
+            throw firstStartupError.error;
         }
         await saveTeamConfig(config, leaderCwd);
         return {
@@ -2207,7 +2297,10 @@ export async function assignTask(teamName, workerName, taskId, cwd) {
     }
     try {
         // Retry dispatch up to 2 times to handle trust prompts during assignment (fixes #393).
-        const inbox = generateTaskAssignmentInbox(workerName, sanitized, taskId, task.description);
+        const taskForInbox = task.delegation
+            ? task
+            : (await updateTask(sanitized, taskId, { delegation: synthesizeDelegationPlan(task) }, cwd)) ?? task;
+        const inbox = generateTaskAssignmentInbox(workerName, sanitized, taskForInbox);
         const maxAssignRetries = 2;
         const assignRetryDelayS = 2;
         let outcome = { ok: false, transport: 'none', reason: 'not_attempted' };
@@ -2522,7 +2615,7 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             });
         }
     }
-    const artifactCwd = config.leader_cwd ?? cwd;
+    const artifactCwd = resolveTeamCommitHygieneArtifactCwd(config, cwd);
     const ledger = await appendTeamCommitHygieneEntries(sanitized, commitHygieneEntries, artifactCwd);
     const taskView = await listTasks(sanitized, cwd).catch(() => []);
     const commitHygieneContext = buildTeamCommitHygieneContext({
@@ -2588,7 +2681,8 @@ export async function resumeTeam(teamName, cwd) {
         return null;
     config.lifecycle_profile = 'default';
     if (config.worker_launch_mode === 'prompt') {
-        const hasLivePromptWorker = config.workers.some((worker) => isPromptWorkerAlive(config, worker));
+        const handleTeamConfig = { ...config, name: sanitized };
+        const hasLivePromptWorker = config.workers.some((worker) => isPromptWorkerAlive(handleTeamConfig, worker));
         if (!hasLivePromptWorker)
             return null;
         const missingHandles = config.workers
@@ -3311,9 +3405,15 @@ async function sendLeaderMailboxMessage(params) {
         cwd,
         transportPreference,
         fallbackAllowed: transportPreference === 'hook_preferred_with_fallback',
-        notify: async (_target, message) => (transportPreference === 'hook_preferred_with_fallback'
-            ? { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }
-            : await notifyLeaderAsync(config, message, cwd)),
+        notify: async (_target, message) => {
+            if (transportPreference === 'hook_preferred_with_fallback') {
+                return { ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' };
+            }
+            if (!config.leader_pane_id) {
+                return { ok: false, transport: 'mailbox', reason: 'leader_pane_missing_transport_direct_failed' };
+            }
+            return await notifyLeaderAsync(config, message, cwd);
+        },
     });
     if (!isExistingMailboxNotificationOutcome(queuedOutcome)
         && transportPreference === 'hook_preferred_with_fallback'
@@ -3343,6 +3443,26 @@ async function sendLeaderMailboxMessage(params) {
         });
         return deferredOutcome;
     }
+    if (!isExistingMailboxNotificationOutcome(queuedOutcome)
+        && transportPreference === 'transport_direct'
+        && !config.leader_pane_id) {
+        const failedOutcome = {
+            ...queuedOutcome,
+            ok: false,
+            transport: 'mailbox',
+            reason: 'leader_pane_missing_transport_direct_failed',
+        };
+        await logRuntimeDispatchOutcome({
+            cwd,
+            teamName,
+            workerName: 'leader-fixed',
+            requestId: failedOutcome.request_id,
+            messageId: failedOutcome.message_id,
+            intent: triggerDirective.intent,
+            outcome: failedOutcome,
+        });
+        return failedOutcome;
+    }
     const canLeaderFallbackDirectly = Boolean(config.leader_pane_id) && isTmuxAvailable();
     return await finalizeQueuedMailboxDispatch({
         queuedOutcome,