oh-my-codex 0.15.2 → 0.16.0

package/dist/team/runtime.js

@@ -3,25 +3,28 @@ 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, 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 { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, waitForWorkerReadyAsync, dismissTrustPromptIfPresent, evaluateStartupDirectTriggerSafety, 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, writeAtomic, } 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 { buildTeamWorkerGoalInstruction } from './goal-workflow.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';
+import { codexPromptsDir, omxStateDir } from '../utils/paths.js';
 import { isTerminalPhase } from './orchestrator.js';
 import { resolveTeamWorkerLaunchArgs, TEAM_LOW_COMPLEXITY_DEFAULT_MODEL, parseTeamWorkerLaunchArgs, splitWorkerLaunchArgs, resolveAgentDefaultModel, resolveAgentReasoningEffort, } from './model-contract.js';
 import { resolveCanonicalTeamStateRoot } from './state-root.js';
+import { buildInternalTeamName, resolveTeamIdentityScope, resolveTeamNameForCurrentContext } from './team-identity.js';
 import { inferPhaseTargetFromTaskCounts, reconcilePhaseStateForMonitor } from './phase-controller.js';
 import { getTeamTmuxSessions } from '../notifications/tmux.js';
 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 { buildApprovedTeamExecutionBinding, normalizeApprovedTeamExecutionBinding, readApprovedTeamExecutionHintFromBinding, resolvePersistedApprovedTeamExecutionContinuityState, writePersistedApprovedTeamExecutionBinding, } from './approved-execution.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';
@@ -188,6 +191,21 @@ async function logRuntimeDispatchOutcome(params) {
         reason: outcome.reason,
     });
 }
+async function logStartupTiming(params) {
+    const { cwd, teamName, workerName, event, paneId, elapsedMs, reason, requestId, transport } = params;
+    await appendTeamDeliveryLogForCwd(cwd, {
+        event: 'startup_timing',
+        source: 'team.runtime',
+        team: teamName,
+        to_worker: workerName,
+        startup_event: event,
+        pane_id: paneId,
+        elapsed_ms: typeof elapsedMs === 'number' ? Math.round(elapsedMs) : undefined,
+        reason,
+        request_id: requestId,
+        transport,
+    });
+}
 function collectProvisionedShutdownWorktrees(config) {
     const seenWorktreePaths = new Set();
     const worktrees = [];
@@ -932,6 +950,52 @@ const WORKTREE_TRIGGER_STATE_ROOT = '$OMX_TEAM_STATE_ROOT';
 const STARTUP_EVIDENCE_TIMEOUT_MS = 15_000;
 const STARTUP_EVIDENCE_POLL_MS = 100;
 const STARTUP_EVIDENCE_LAUNCH_TIMEOUT_MS = 45_000;
+const STARTUP_TIMING_LOG_VERSION = 1;
+export function teamStartupTimingPath(teamName, cwd) {
+    return join(resolveCanonicalTeamStateRoot(cwd), 'team', teamName, 'startup-timing.json');
+}
+export function teamRuntimeTeamsRoot(cwd) {
+    return join(resolveCanonicalTeamStateRoot(cwd), 'team');
+}
+export function teamRuntimeTeamRoot(teamName, cwd) {
+    return join(teamRuntimeTeamsRoot(cwd), teamName);
+}
+export function teamRuntimeSessionPath(cwd) {
+    return join(omxStateDir(cwd), 'session.json');
+}
+function createStartupTimingRecorder(teamName, cwd) {
+    const startedAt = performance.now();
+    const events = [];
+    return {
+        mark: (phase, details = {}) => {
+            events.push({
+                phase,
+                at: new Date().toISOString(),
+                elapsed_ms: Math.round((performance.now() - startedAt) * 1000) / 1000,
+                ...details,
+            });
+        },
+        flush: async () => {
+            const timingPath = teamStartupTimingPath(teamName, cwd);
+            await writeAtomic(timingPath, JSON.stringify({ schema_version: STARTUP_TIMING_LOG_VERSION, team_name: teamName, events }, null, 2)).catch(() => { });
+            for (const event of events) {
+                await appendTeamDeliveryLogForCwd(cwd, {
+                    event: 'dispatch_result',
+                    source: 'team.runtime.startup-timing',
+                    team: teamName,
+                    result: event.ok === false ? 'failed' : 'ok',
+                    phase: event.phase,
+                    elapsed_ms: event.elapsed_ms,
+                    to_worker: event.worker,
+                    pane_id: event.pane_id,
+                    reason: event.reason,
+                    transport: event.transport,
+                    request_id: event.request_id,
+                });
+            }
+        },
+    };
+}
 const promptWorkerRegistry = new Map();
 const previousModelInstructionsFileByTeam = new Map();
 const PROMPT_WORKER_SIGTERM_WAIT_MS = 3_000;
@@ -1000,7 +1064,7 @@ function resolveGovernancePolicy(governance, legacyPolicy) {
     return normalizeTeamGovernance(governance, legacyPolicy);
 }
 async function assertNestedTeamAllowed(cwd) {
-    const workerContext = parseTeamWorkerContext(process.env.OMX_TEAM_WORKER);
+    const workerContext = parseTeamWorkerContext(process.env.OMX_TEAM_INTERNAL_WORKER || process.env.OMX_TEAM_WORKER);
     if (!workerContext)
         return;
     for (const candidateCwd of resolveManifestLookupCwds(cwd)) {
@@ -1077,6 +1141,22 @@ async function recordRecoverableStartupIssue(params) {
         reason,
     }, cwd).catch(() => { });
 }
+async function recordPromptStartupWorkerStopped(params) {
+    const { teamName, workerName, taskIds, reason, cwd } = params;
+    const updatedAt = new Date().toISOString();
+    await writeWorkerStatus(teamName, workerName, {
+        state: 'failed',
+        current_task_id: taskIds[0],
+        reason,
+        updated_at: updatedAt,
+    }, cwd).catch(() => { });
+    await appendTeamEvent(teamName, {
+        type: 'worker_stopped',
+        worker: workerName,
+        task_id: taskIds[0],
+        reason,
+    }, cwd).catch(() => { });
+}
 function setTeamModelInstructionsFile(teamName, filePath) {
     if (!previousModelInstructionsFileByTeam.has(teamName)) {
         previousModelInstructionsFileByTeam.set(teamName, process.env[MODEL_INSTRUCTIONS_FILE_ENV]);
@@ -1383,10 +1463,16 @@ export { TEAM_LOW_COMPLEXITY_DEFAULT_MODEL };
 export { resolveCanonicalTeamStateRoot };
 function spawnPromptWorker(teamName, workerName, workerIndex, workerCwd, launchArgs, workerEnv, workerCli, initialPrompt, workerRole) {
     const processSpec = buildWorkerProcessLaunchSpec(teamName, workerIndex, launchArgs, workerCwd, workerEnv, workerCli, initialPrompt, workerRole);
+    const childEnv = { ...process.env, ...processSpec.env };
+    // Prompt workers are external CLI processes, not in-process runtime code.
+    // Keeping c8's NODE_V8_COVERAGE in their environment makes coverage runs
+    // track long-lived fake worker descendants and can keep node --test alive
+    // after the runtime test itself has completed.
+    delete childEnv.NODE_V8_COVERAGE;
     const child = spawn(processSpec.command, processSpec.args, {
         cwd: workerCwd,
         detached: process.platform !== 'win32',
-        env: { ...process.env, ...processSpec.env },
+        env: childEnv,
         stdio: ['pipe', 'ignore', 'ignore'],
     });
     registerPromptWorkerHandle(teamName, workerName, child);
@@ -1481,11 +1567,28 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
     const leaderCwd = resolve(cwd);
     await assertNestedTeamAllowed(leaderCwd);
     const effectiveWorktreeMode = resolveEffectiveTeamWorktreeMode(leaderCwd, options.worktreeMode);
-    const sanitized = sanitizeTeamName(teamName);
-    const leaderSessionId = await resolveLeaderSessionId(leaderCwd);
-    await assertTeamStartupIsNonDestructive(sanitized, leaderCwd, leaderSessionId);
+    const displayName = sanitizeTeamName(teamName);
     const workerLaunchMode = resolveTeamWorkerLaunchMode(process.env);
     const displayMode = workerLaunchMode === 'interactive' ? 'split_pane' : 'auto';
+    const rawIdentityScope = resolveTeamIdentityScope(process.env);
+    const resolvedLeaderSessionId = await resolveLeaderSessionId(leaderCwd);
+    const identityScope = rawIdentityScope.source === 'run-id'
+        ? (resolvedLeaderSessionId
+            ? { ...rawIdentityScope, sessionId: resolvedLeaderSessionId, runId: '' }
+            : {
+                ...rawIdentityScope,
+                // Prompt-mode starts can run outside tmux/native session metadata. A fresh
+                // random run id would give every start a new leader identity and bypass
+                // one-active-team protection, so scope that fallback to the leader cwd.
+                runId: `cwd:${leaderCwd}`,
+            })
+        : rawIdentityScope;
+    const sanitized = buildInternalTeamName(displayName, identityScope);
+    const leaderSessionId = identityScope.sessionId || identityScope.paneId || identityScope.tmuxTarget || identityScope.runId;
+    await assertTeamStartupIsNonDestructive(sanitized, leaderCwd, leaderSessionId);
+    if (displayName !== sanitized) {
+        await assertTeamStartupIsNonDestructive(displayName, leaderCwd, leaderSessionId);
+    }
     if (workerLaunchMode === 'interactive') {
         if (!isTmuxAvailable()) {
             throw new Error('Team mode requires tmux. Install with: apt install tmux / brew install tmux');
@@ -1495,6 +1598,16 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
         }
     }
     const teamStateRoot = resolveCanonicalTeamStateRoot(leaderCwd);
+    const requestedApprovedExecution = normalizeApprovedTeamExecutionBinding(options.approvedExecution);
+    const selectedApprovedExecutionHint = requestedApprovedExecution
+        ? readApprovedTeamExecutionHintFromBinding(leaderCwd, requestedApprovedExecution)
+        : null;
+    if (requestedApprovedExecution && !selectedApprovedExecutionHint) {
+        throw new Error(`approved_execution_binding_stale:${requestedApprovedExecution.prd_path}:${requestedApprovedExecution.task}`);
+    }
+    const approvedExecution = selectedApprovedExecutionHint
+        ? buildApprovedTeamExecutionBinding(selectedApprovedExecutionHint)
+        : null;
     const activeWorktreeMode = effectiveWorktreeMode.enabled
         ? (effectiveWorktreeMode.detached ? 'detached' : 'named')
         : null;
@@ -1553,10 +1666,18 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
     const skipWorkerReadyWait = shouldSkipWorkerReadyWait(process.env);
     try {
         // 3. Init state directory + config
-        config = await initTeamState(sanitized, task, agentType, workerCount, leaderCwd, DEFAULT_MAX_WORKERS, { ...process.env, OMX_TEAM_DISPLAY_MODE: displayMode, OMX_TEAM_WORKER_LAUNCH_MODE: workerLaunchMode }, {
+        config = await initTeamState(sanitized, task, agentType, workerCount, leaderCwd, DEFAULT_MAX_WORKERS, {
+            ...process.env,
+            OMX_SESSION_ID: leaderSessionId,
+            OMX_TEAM_DISPLAY_MODE: displayMode,
+            OMX_TEAM_WORKER_LAUNCH_MODE: workerLaunchMode,
+        }, {
             leader_cwd: leaderCwd,
             team_state_root: teamStateRoot,
             workspace_mode: workspaceMode,
+            display_name: displayName,
+            requested_name: displayName,
+            identity_source: identityScope.source,
             worktree_mode: effectiveWorktreeMode,
         }, 'default');
         if (!config) {
@@ -1565,7 +1686,11 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
         config.leader_cwd = leaderCwd;
         config.team_state_root = teamStateRoot;
         config.workspace_mode = workspaceMode;
+        config.display_name = displayName;
+        config.requested_name = displayName;
+        config.identity_source = identityScope.source;
         config.worktree_mode = effectiveWorktreeMode;
+        await writePersistedApprovedTeamExecutionBinding(sanitized, leaderCwd, approvedExecution, teamStateRoot);
         // 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.
@@ -1661,6 +1786,8 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 rolePromptContent: rawRolePromptContent ?? undefined,
                 worktreeRootAgentsCanonical: Boolean(workerWorkspace.worktreePath),
                 taskHints: effectiveDecompositionMetadata?.task_hints,
+                approvedContextSummary: effectiveDecompositionMetadata?.approved_context_summary,
+                workerGoalInstruction: buildTeamWorkerGoalInstruction(sanitized, workerName, workerTasks, { teamStateRoot }),
             });
             const triggerDirective = buildTriggerDirective(workerName, sanitized, resolveInstructionStateRoot(workerWorkspace.worktreePath));
             const trigger = triggerDirective.text;
@@ -1688,6 +1815,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 [TEAM_STATE_ROOT_ENV]: teamStateRoot,
                 [TEAM_LEADER_CWD_ENV]: leaderCwd,
                 [MODEL_INSTRUCTIONS_FILE_ENV]: plan.instructionsFilePath,
+                OMX_TEAM_DISPLAY_NAME: displayName,
             };
             if (plan.workerWorkspace.worktreePath) {
                 env.OMX_TEAM_WORKTREE_PATH = plan.workerWorkspace.worktreePath;
@@ -1756,6 +1884,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             cleanup: options.cleanupLaunchOrphanedMcpProcesses,
             writeWarning: options.writeCleanupWarning,
         });
+        const startupTiming = createStartupTimingRecorder(sanitized, leaderCwd);
         if (workerLaunchMode === 'interactive') {
             const createdSession = createTeamSession(sanitized, workerCount, leaderCwd, sharedWorkerLaunchArgs, workerStartups);
             sessionName = createdSession.name;
@@ -1763,6 +1892,9 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             createdWorkerPaneIds.push(...createdSession.workerPaneIds);
             createdLeaderPaneId = createdSession.leaderPaneId;
             applyCreatedInteractiveSessionToConfig(config, createdSession, workerPaneIds);
+            for (const [index, paneId] of createdSession.workerPaneIds.entries()) {
+                startupTiming.mark('split_returned', { worker: `worker-${index + 1}`, pane_id: paneId });
+            }
         }
         else {
             config.tmux_session = `prompt-${sanitized}`;
@@ -1787,6 +1919,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 throw new Error(`missing bootstrap plan for worker-${i}`);
             }
             await materializeWorkerStartupState(bootstrapPlan, i, workerPaneIds[i - 1]);
+            startupTiming.mark('identity_inbox_written', { worker: bootstrapPlan.workerName, pane_id: workerPaneIds[i - 1] });
         }
         await saveTeamConfig(config, leaderCwd);
         // 7. Start all safe per-worker readiness/dispatch attempts concurrently.
@@ -1812,6 +1945,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             const trigger = bootstrapPlan.trigger;
             const triggerIntent = bootstrapPlan.triggerIntent;
             const initialPrompt = bootstrapPlan.initialPrompt;
+            const startupStartedAt = performance.now();
             const taskRoles = workerTasks
                 .map((task) => task.role)
                 .filter((role) => Boolean(role));
@@ -1819,8 +1953,26 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             if (uniqueTaskRoles.length > 1) {
                 console.log(`[omx:team] ${workerName}: mixed task roles [${uniqueTaskRoles.join(', ')}], falling back to ${agentType}`);
             }
-            if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt) {
+            const startupDirectOutcome = workerLaunchMode === 'interactive' && !initialPrompt
+                ? await attemptStartupDirectTrigger({
+                    teamName: sanitized,
+                    config: config,
+                    workerName,
+                    workerIndex,
+                    paneId,
+                    workerCli: workerCliPlan[workerIndex - 1],
+                    inbox,
+                    triggerMessage: trigger,
+                    intent: triggerIntent,
+                    taskIds: workerTasks.map((task) => task.id),
+                    cwd: leaderCwd,
+                    timing: startupTiming,
+                })
+                : null;
+            if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt && !startupDirectOutcome?.ok) {
+                startupTiming.mark('ready_wait_start', { worker: workerName, pane_id: paneId });
                 const ready = await waitForWorkerReadyAsync(sessionName, workerIndex, workerReadyTimeoutMs, paneId);
+                startupTiming.mark('ready_wait_end', { worker: workerName, pane_id: paneId, ok: ready });
                 if (!ready) {
                     const workerAlive = isWorkerPaneOpen(sessionName, workerIndex, paneId);
                     if (workerAlive) {
@@ -1841,10 +1993,11 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                     };
                 }
             }
+            const startupReadyPromptObserved = workerLaunchMode === 'interactive' && !skipWorkerReadyWait && !initialPrompt;
             let dispatchOutcome = initialPrompt
                 ? { ok: true, transport: 'none', reason: 'startup_prompt_delivered_at_launch' }
-                : { ok: false, transport: 'none', reason: 'not_attempted' };
-            if (!initialPrompt) {
+                : (startupDirectOutcome ?? { ok: false, transport: 'none', reason: 'not_attempted' });
+            if (!initialPrompt && !startupDirectOutcome?.ok) {
                 for (let attempt = 1; attempt <= startupDispatchRetries; attempt++) {
                     dispatchOutcome = await dispatchCriticalInboxInstruction({
                         teamName: sanitized,
@@ -1861,7 +2014,20 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                         inboxCorrelationKey: `startup:${workerName}`,
                         requireWorkerStartupEvidence: true,
                         startupEvidenceTimeoutMs: workerStartupEvidenceTimeoutMs,
+                        startupReadyPromptObserved,
+                        startupTiming,
                     });
+                    await logStartupTiming({
+                        cwd: leaderCwd,
+                        teamName: sanitized,
+                        workerName,
+                        event: dispatchOutcome.ok ? 'startup_evidence' : 'startup_attempt_failed',
+                        paneId,
+                        elapsedMs: performance.now() - startupStartedAt,
+                        reason: dispatchOutcome.reason,
+                        requestId: dispatchOutcome.request_id,
+                        transport: dispatchOutcome.transport,
+                    }).catch(() => { });
                     if (dispatchOutcome.ok)
                         break;
                     if (attempt < startupDispatchRetries) {
@@ -1895,6 +2061,16 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                     });
                     return { ok: true, workerIndex, workerName };
                 }
+                if (workerLaunchMode === 'prompt' && !workerAlive) {
+                    await recordPromptStartupWorkerStopped({
+                        teamName: sanitized,
+                        workerName,
+                        taskIds: workerTasks.map((task) => task.id),
+                        reason: dispatchOutcome.reason,
+                        cwd: leaderCwd,
+                    });
+                    return { ok: true, workerIndex, workerName };
+                }
                 return {
                     ok: false,
                     workerIndex,
@@ -1921,6 +2097,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             throw firstStartupError.error;
         }
         await saveTeamConfig(config, leaderCwd);
+        await startupTiming.flush();
         return {
             teamName: sanitized,
             sanitizedName: sanitized,
@@ -2046,7 +2223,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
  */
 export async function monitorTeam(teamName, cwd) {
     const monitorStartMs = performance.now();
-    const sanitized = sanitizeTeamName(teamName);
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
     const config = await readTeamConfig(sanitized, cwd);
     if (!config)
         return null;
@@ -2361,6 +2538,25 @@ export async function assignTask(teamName, workerName, taskId, cwd) {
 export async function reassignTask(teamName, taskId, _fromWorker, toWorker, cwd) {
     await assignTask(teamName, toWorker, taskId, cwd);
 }
+function resolveCommitHygieneArtifactTeamNames(config, internalTeamName) {
+    const names = [];
+    for (const value of [config.requested_name, config.display_name, internalTeamName]) {
+        if (typeof value !== 'string' || value.trim() === '')
+            continue;
+        try {
+            const sanitized = sanitizeTeamName(value);
+            if (!names.includes(sanitized))
+                names.push(sanitized);
+        }
+        catch {
+            // Persisted display/request names are best-effort aliases. If an older
+            // state file contains an invalid value, fall back to the internal name.
+        }
+    }
+    if (!names.includes(internalTeamName))
+        names.push(internalTeamName);
+    return names;
+}
 /**
  * Graceful shutdown: send shutdown inbox to all workers, wait, force kill, cleanup.
  */
@@ -2368,7 +2564,7 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
     const force = options.force === true;
     const confirmIssues = options.confirmIssues === true;
     let skipWorkerAcks = false;
-    const sanitized = sanitizeTeamName(teamName);
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
     const config = await readTeamConfig(sanitized, cwd);
     if (!config) {
         // No config -- just try to kill tmux session and clean up
@@ -2616,14 +2812,22 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         }
     }
     const artifactCwd = resolveTeamCommitHygieneArtifactCwd(config, cwd);
-    const ledger = await appendTeamCommitHygieneEntries(sanitized, commitHygieneEntries, artifactCwd);
     const taskView = await listTasks(sanitized, cwd).catch(() => []);
-    const commitHygieneContext = buildTeamCommitHygieneContext({
-        teamName: sanitized,
-        tasks: taskView,
-        ledger,
-    });
-    const commitHygieneArtifacts = await writeTeamCommitHygieneContext(sanitized, commitHygieneContext, artifactCwd);
+    const internalLedger = await appendTeamCommitHygieneEntries(sanitized, commitHygieneEntries, artifactCwd);
+    const commitHygieneArtifactTeamNames = resolveCommitHygieneArtifactTeamNames(config, sanitized);
+    let commitHygieneArtifacts = null;
+    for (const artifactTeamName of commitHygieneArtifactTeamNames) {
+        const ledger = artifactTeamName === sanitized
+            ? internalLedger
+            : await appendTeamCommitHygieneEntries(artifactTeamName, internalLedger.entries, artifactCwd);
+        const commitHygieneContext = buildTeamCommitHygieneContext({
+            teamName: artifactTeamName,
+            tasks: taskView,
+            ledger,
+        });
+        const writtenArtifacts = await writeTeamCommitHygieneContext(artifactTeamName, commitHygieneContext, artifactCwd);
+        commitHygieneArtifacts ??= writtenArtifacts;
+    }
     // 5. Remove worker worktree-root instructions and team-scoped fallback instructions.
     for (const worker of config.workers) {
         if (!worker.worktree_path || !worker.team_state_root)
@@ -2675,11 +2879,19 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
  * Resume monitoring an existing team.
  */
 export async function resumeTeam(teamName, cwd) {
-    const sanitized = sanitizeTeamName(teamName);
+    const sanitized = resolveTeamNameForCurrentContext(teamName, cwd);
     const config = await readTeamConfig(sanitized, cwd);
     if (!config)
         return null;
     config.lifecycle_profile = 'default';
+    const leaderCwd = config.leader_cwd ?? cwd;
+    const approvedExecutionState = await resolvePersistedApprovedTeamExecutionContinuityState(sanitized, leaderCwd, config.team_state_root ?? resolveCanonicalTeamStateRoot(leaderCwd));
+    if (approvedExecutionState.status === 'malformed') {
+        throw new Error(`approved_execution_binding_malformed:${sanitized}`);
+    }
+    if (approvedExecutionState.status === 'stale') {
+        throw new Error(`approved_execution_binding_stale:${approvedExecutionState.binding.prd_path}:${approvedExecutionState.binding.task}`);
+    }
     if (config.worker_launch_mode === 'prompt') {
         const handleTeamConfig = { ...config, name: sanitized };
         const hasLivePromptWorker = config.workers.some((worker) => isPromptWorkerAlive(handleTeamConfig, worker));
@@ -2718,7 +2930,7 @@ export async function resumeTeam(teamName, cwd) {
     };
 }
 async function findActiveTeams(cwd, leaderSessionId) {
-    const root = join(cwd, '.omx', 'state', 'team');
+    const root = teamRuntimeTeamsRoot(cwd);
     if (!existsSync(root))
         return [];
     const sessions = new Set(listTeamSessions());
@@ -2754,7 +2966,7 @@ async function findActiveTeams(cwd, leaderSessionId) {
     return active;
 }
 async function detectAndCleanStaleTeam(teamName, leaderCwd, workerCount, confirmFn) {
-    const stateDir = join(leaderCwd, '.omx', 'state', 'team', teamName);
+    const stateDir = teamRuntimeTeamRoot(teamName, leaderCwd);
     if (!existsSync(stateDir))
         return;
     const sessions = new Set(listTeamSessions());
@@ -2803,7 +3015,7 @@ async function resolveLeaderSessionId(cwd) {
     const fromEnv = process.env.OMX_SESSION_ID || process.env.CODEX_SESSION_ID || process.env.SESSION_ID;
     if (fromEnv && fromEnv.trim() !== '')
         return fromEnv.trim();
-    const p = join(cwd, '.omx', 'state', 'session.json');
+    const p = teamRuntimeSessionPath(cwd);
     if (!existsSync(p))
         return '';
     try {
@@ -2951,8 +3163,89 @@ async function markDispatchRequestLeaderPaneMissingDeferred(params) {
         last_reason: 'leader_pane_missing_deferred',
     }, cwd).catch(() => { });
 }
+async function attemptStartupDirectTrigger(params) {
+    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, taskIds, cwd, timing, } = params;
+    const safety = await evaluateStartupDirectTriggerSafety(config.tmux_session, workerIndex, paneId, workerCli);
+    if (!safety.safe) {
+        timing.mark('startup_direct_bypass', {
+            worker: workerName,
+            pane_id: paneId,
+            ok: false,
+            reason: `startup_direct_unsafe:${safety.reason}`,
+        });
+        return null;
+    }
+    const queued = await queueInboxInstruction({
+        teamName,
+        workerName,
+        workerIndex,
+        paneId,
+        inbox,
+        triggerMessage,
+        intent,
+        cwd,
+        transportPreference: 'transport_direct',
+        fallbackAllowed: false,
+        inboxCorrelationKey: `startup-direct:${workerName}`,
+        notify: (_target, message) => notifyWorkerOutcome(config, workerIndex, message, paneId),
+    });
+    timing.mark('dispatch_queued', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: queued.ok,
+        reason: queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    timing.mark('direct_fallback', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: queued.ok,
+        reason: queued.ok ? `startup_direct_trigger_sent:${safety.reason}` : queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    if (!queued.ok)
+        return queued;
+    const effectiveWorkerCli = workerCli ?? 'codex';
+    const workerStartupEvidence = await waitForWorkerStartupEvidence({
+        teamName,
+        workerName,
+        workerCli: effectiveWorkerCli,
+        cwd,
+        timeoutMs: 0,
+        pollMs: STARTUP_EVIDENCE_POLL_MS,
+    });
+    timing.mark('startup_evidence', {
+        worker: workerName,
+        pane_id: paneId,
+        ok: workerStartupEvidence !== 'none',
+        reason: workerStartupEvidence,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
+    const reason = workerStartupEvidence === 'none'
+        ? `${effectiveWorkerCli}_startup_direct_no_evidence:${safety.reason}`
+        : `startup_direct_trigger_sent:${safety.reason}`;
+    if ((effectiveWorkerCli === 'codex' || effectiveWorkerCli === 'claude') && workerStartupEvidence === 'none') {
+        await recordRecoverableStartupIssue({
+            teamName,
+            workerName,
+            taskIds,
+            reason,
+            cwd,
+        });
+    }
+    return {
+        ...queued,
+        reason,
+    };
+}
 async function dispatchCriticalInboxInstruction(params) {
-    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, cwd, dispatchPolicy, inboxCorrelationKey, requireWorkerStartupEvidence, startupEvidenceTimeoutMs, } = params;
+    const { teamName, config, workerName, workerIndex, paneId, workerCli, inbox, triggerMessage, intent, cwd, dispatchPolicy, inboxCorrelationKey, requireWorkerStartupEvidence, startupEvidenceTimeoutMs, startupReadyPromptObserved = false, startupTiming, } = params;
+    const noteTiming = (phase, details) => {
+        startupTiming?.mark(phase, { worker: workerName, pane_id: paneId, ...details });
+    };
     if (config.worker_launch_mode === 'prompt') {
         return await queueInboxInstruction({
             teamName,
@@ -2999,12 +3292,26 @@ async function dispatchCriticalInboxInstruction(params) {
         inboxCorrelationKey,
         notify: () => ({ ok: true, transport: 'hook', reason: 'queued_for_hook_dispatch' }),
     });
+    noteTiming('dispatch_queued', {
+        ok: queued.ok,
+        reason: queued.reason,
+        transport: queued.transport,
+        request_id: queued.request_id,
+    });
     if (!queued.request_id)
         return { ...queued, ok: false, reason: 'dispatch_request_missing_id' };
     const receipt = await waitForDispatchReceipt(teamName, queued.request_id, cwd, {
         timeoutMs: dispatchPolicy.dispatch_ack_timeout_ms,
         pollMs: 50,
     });
+    if (receipt) {
+        noteTiming('hook_receipt', {
+            ok: receipt.status === 'delivered' || receipt.status === 'notified',
+            reason: receipt.status,
+            transport: 'hook',
+            request_id: queued.request_id,
+        });
+    }
     if (receipt?.status === 'delivered') {
         return { ok: true, transport: 'hook', reason: 'hook_receipt_delivered', request_id: queued.request_id };
     }
@@ -3015,6 +3322,14 @@ async function dispatchCriticalInboxInstruction(params) {
         if (!requiresObservedStartupEvidence) {
             return { ok: true, transport: 'hook', reason: 'hook_receipt_notified', request_id: queued.request_id };
         }
+        if (startupReadyPromptObserved) {
+            return {
+                ok: true,
+                transport: 'hook',
+                reason: 'hook_receipt_notified_with_ready_prompt',
+                request_id: queued.request_id,
+            };
+        }
         startupEvidence = await waitForWorkerStartupEvidence({
             teamName,
             workerName,
@@ -3022,6 +3337,12 @@ async function dispatchCriticalInboxInstruction(params) {
             cwd,
             timeoutMs: startupEvidenceTimeoutMs,
         });
+        noteTiming('startup_evidence', {
+            ok: startupEvidence !== 'none',
+            reason: startupEvidence,
+            transport: 'hook',
+            request_id: queued.request_id,
+        });
         if (startupEvidence !== 'none') {
             return {
                 ok: true,
@@ -3034,13 +3355,21 @@ async function dispatchCriticalInboxInstruction(params) {
     if (receipt?.status === 'failed') {
         const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
         if (fallback.ok) {
-            const fallbackStartupEvidence = await waitForRequiredStartupEvidenceAfterDirectFallback({
-                requireWorkerStartupEvidence,
-                workerCli,
-                teamName,
-                workerName,
-                cwd,
-                timeoutMs: startupEvidenceTimeoutMs,
+            const fallbackStartupEvidence = startupReadyPromptObserved
+                ? 'ready_prompt'
+                : await waitForRequiredStartupEvidenceAfterDirectFallback({
+                    requireWorkerStartupEvidence,
+                    workerCli,
+                    teamName,
+                    workerName,
+                    cwd,
+                    timeoutMs: startupEvidenceTimeoutMs,
+                });
+            noteTiming('startup_evidence', {
+                ok: fallbackStartupEvidence !== 'none',
+                reason: fallbackStartupEvidence,
+                transport: fallback.transport,
+                request_id: queued.request_id,
             });
             if (requiresObservedStartupEvidence && fallbackStartupEvidence === 'none') {
                 await transitionDispatchRequest(teamName, queued.request_id, 'failed', 'failed', { last_reason: `${workerCli}_startup_no_evidence_after_fallback:${fallback.reason}` }, cwd).catch(() => { });
@@ -3071,6 +3400,12 @@ async function dispatchCriticalInboxInstruction(params) {
         };
     }
     const fallback = await notifyWorkerOutcome(config, workerIndex, triggerMessage, paneId);
+    noteTiming('direct_fallback', {
+        ok: fallback.ok,
+        reason: fallback.reason,
+        transport: fallback.transport,
+        request_id: queued.request_id,
+    });
     const startupFallbackLabel = receipt?.status === 'notified' && requiresObservedStartupEvidence
         ? `${workerCli}_startup_no_evidence`
         : null;
@@ -3078,13 +3413,21 @@ async function dispatchCriticalInboxInstruction(params) {
         ? `${startupFallbackLabel}_fallback_failed:${fallback.reason}`
         : `fallback_attempted_but_unconfirmed:${fallback.reason}`;
     if (fallback.ok) {
-        const fallbackStartupEvidence = await waitForRequiredStartupEvidenceAfterDirectFallback({
-            requireWorkerStartupEvidence,
-            workerCli,
-            teamName,
-            workerName,
-            cwd,
-            timeoutMs: startupEvidenceTimeoutMs,
+        const fallbackStartupEvidence = startupReadyPromptObserved
+            ? 'ready_prompt'
+            : await waitForRequiredStartupEvidenceAfterDirectFallback({
+                requireWorkerStartupEvidence,
+                workerCli,
+                teamName,
+                workerName,
+                cwd,
+                timeoutMs: startupEvidenceTimeoutMs,
+            });
+        noteTiming('startup_evidence', {
+            ok: fallbackStartupEvidence !== 'none',
+            reason: fallbackStartupEvidence,
+            transport: fallback.transport,
+            request_id: queued.request_id,
         });
         if (requiresObservedStartupEvidence && fallbackStartupEvidence === 'none') {
             const current = await readDispatchRequest(teamName, queued.request_id, cwd);