oh-my-codex 0.12.3 → 0.12.4

package/dist/team/runtime.js

@@ -3,7 +3,7 @@ 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, isNativeWindows, sleepFractionalSeconds, sendToWorker, sendToWorkerStdin, isWorkerAlive, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, listTeamSessions, } from './tmux-session.js';
+import { sanitizeTeamName, isTmuxAvailable, hasCurrentTmuxClientContext, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, dismissTrustPromptIfPresent, sleepFractionalSeconds, sendToWorker, sendToWorkerStdin, isWorkerAlive, getWorkerPanePid, killWorkerByPaneIdAsync, restoreStandaloneHudPane, teardownWorkerPanes, unregisterResizeHook, destroyTeamSession, listPaneIds, 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, 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, } from './team-ops.js';
 import { queueInboxInstruction, queueDirectMailboxMessage, queueBroadcastMailboxMessage, waitForDispatchReceipt, } from './mcp-comm.js';
 import { appendTeamDeliveryLogForCwd } from './delivery-log.js';
@@ -20,7 +20,7 @@ import { hasStructuredVerificationEvidence } from '../verification/verifier.js';
 import { buildRebalanceDecisions } from './rebalance-policy.js';
 import { readModeState, updateModeState } from '../modes/base.js';
 import { appendTeamCommitHygieneEntries, buildTeamCommitHygieneContext, writeTeamCommitHygieneContext, } from './commit-hygiene.js';
-import { assertCleanLeaderWorkspaceForWorkerWorktrees, ensureWorktree, isGitRepository, planWorktreeTarget, rollbackProvisionedWorktrees, } from './worktree.js';
+import { assertCleanLeaderWorkspaceForWorkerWorktrees, ensureWorktree, isGitRepository, isWorktreeDirty, planWorktreeTarget, removeWorktreeForce, rollbackProvisionedWorktrees, } from './worktree.js';
 async function syncRootTeamModeStateOnTerminalPhase(teamName, phase, cwd) {
     if (phase !== 'complete' && phase !== 'failed' && phase !== 'cancelled')
         return;
@@ -109,9 +109,15 @@ function collectShutdownPaneIds(params) {
     return [...paneIds];
 }
 export function shouldPrekillInteractiveShutdownProcessTrees(sessionName) {
-    // Native Windows + split-pane psmux sessions can expose overlapping
-    // ancestry around the leader client; rely on pane-targeted teardown there.
-    return !(isNativeWindows() && sessionName.includes(':'));
+    // Shared-window tmux sessions can expose overlapping ancestry around the
+    // invoking leader client. Rely on pane-targeted teardown there so shutdown
+    // does not signal the leader while tearing down worker panes.
+    if (sessionName.includes(':'))
+        return false;
+    // Detached session teardown still benefits from process-tree prekill,
+    // including native Windows prompt-worker ancestry where pane-targeted
+    // teardown alone is insufficient.
+    return true;
 }
 async function logRuntimeDispatchOutcome(params) {
     const { cwd, teamName, workerName, requestId, messageId, intent, outcome, source = 'team.runtime' } = params;
@@ -789,6 +795,44 @@ async function prepareWorkerWorktreeShutdownReports(config, leaderCwd) {
     }
     return reports;
 }
+function listDirtyShutdownWorkers(config) {
+    const dirtyWorkers = [];
+    for (const worker of config.workers) {
+        if (!worker.worktree_repo_root || !worker.worktree_path || !existsSync(worker.worktree_path))
+            continue;
+        const worktreePath = resolve(worker.worktree_path);
+        const repoRoot = resolve(worker.worktree_repo_root);
+        const status = runGitCommand(repoRoot, ['status', '--porcelain'], worktreePath);
+        if (!status.ok || status.stdout.trim().length > 0) {
+            dirtyWorkers.push(worker.name);
+        }
+    }
+    return dirtyWorkers;
+}
+async function classifyShutdown(params) {
+    const { teamName, cwd, config, governance, confirmIssues } = params;
+    const allTasks = await listTasks(teamName, cwd);
+    const gate = {
+        total: allTasks.length,
+        pending: allTasks.filter((t) => t.status === 'pending').length,
+        blocked: allTasks.filter((t) => t.status === 'blocked').length,
+        in_progress: allTasks.filter((t) => t.status === 'in_progress').length,
+        completed: allTasks.filter((t) => t.status === 'completed').length,
+        failed: allTasks.filter((t) => t.status === 'failed').length,
+        allowed: false,
+    };
+    const dirtyWorkers = listDirtyShutdownWorkers(config);
+    const hasBlockingBacklog = gate.pending > 0 || gate.blocked > 0 || gate.in_progress > 0;
+    const requiresIssueConfirmation = gate.failed > 0 && dirtyWorkers.length === 0 && !confirmIssues;
+    gate.allowed = governance.cleanup_requires_all_workers_inactive !== true
+        || (!hasBlockingBacklog && !requiresIssueConfirmation);
+    return {
+        gate,
+        dirtyWorkers,
+        requiresIssueConfirmation,
+        useCleanFastPath: dirtyWorkers.length === 0 && !hasBlockingBacklog && (gate.failed === 0 || confirmIssues),
+    };
+}
 function resolveEffectiveTeamWorktreeMode(leaderCwd, requestedMode) {
     if (!isGitRepository(leaderCwd)) {
         return { enabled: false };
@@ -1319,6 +1363,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
     for (let i = 1; i <= workerCount; i++) {
         workerWorkspaceByName.set(`worker-${i}`, { cwd: leaderCwd });
     }
+    await detectAndCleanStaleTeam(sanitized, leaderCwd, workerCount, options.confirmStaleCleanup);
     if (activeWorktreeMode) {
         assertCleanLeaderWorkspaceForWorkerWorktrees(leaderCwd);
         for (let i = 1; i <= workerCount; i++) {
@@ -2060,6 +2105,8 @@ export async function reassignTask(teamName, taskId, _fromWorker, toWorker, cwd)
  */
 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 config = await readTeamConfig(sanitized, cwd);
     if (!config) {
@@ -2077,26 +2124,26 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
     const manifest = await readTeamManifestV2(sanitized, cwd);
     const governance = resolveGovernancePolicy(manifest?.governance, manifest?.policy);
     if (!force) {
-        const allTasks = await listTasks(sanitized, cwd);
-        const gate = {
-            total: allTasks.length,
-            pending: allTasks.filter((t) => t.status === 'pending').length,
-            blocked: allTasks.filter((t) => t.status === 'blocked').length,
-            in_progress: allTasks.filter((t) => t.status === 'in_progress').length,
-            completed: allTasks.filter((t) => t.status === 'completed').length,
-            failed: allTasks.filter((t) => t.status === 'failed').length,
-            allowed: false,
-        };
-        gate.allowed = governance.cleanup_requires_all_workers_inactive !== true
-            || (gate.pending === 0 && gate.blocked === 0 && gate.in_progress === 0 && gate.failed === 0);
+        const classification = await classifyShutdown({
+            teamName: sanitized,
+            cwd,
+            config,
+            governance,
+            confirmIssues,
+        });
+        const { gate, dirtyWorkers, requiresIssueConfirmation, useCleanFastPath } = classification;
         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} cleanup_requires_all_workers_inactive=${governance.cleanup_requires_all_workers_inactive}`,
+            reason: `allowed=${gate.allowed} total=${gate.total} pending=${gate.pending} blocked=${gate.blocked} in_progress=${gate.in_progress} completed=${gate.completed} failed=${gate.failed} cleanup_requires_all_workers_inactive=${governance.cleanup_requires_all_workers_inactive} dirty_workers=${dirtyWorkers.join('|') || 'none'} confirm_issues=${confirmIssues} clean_fast_path=${useCleanFastPath}`,
         }, cwd).catch(() => { });
         if (!gate.allowed) {
+            if (requiresIssueConfirmation) {
+                throw new Error(`shutdown_confirm_issues_required:failed=${gate.failed}:rerun=omx team shutdown ${sanitized} --confirm-issues`);
+            }
             throw new Error(`shutdown_gate_blocked:pending=${gate.pending},blocked=${gate.blocked},in_progress=${gate.in_progress},failed=${gate.failed}`);
         }
+        skipWorkerAcks = useCleanFastPath;
     }
     if (force) {
         await appendTeamEvent(sanitized, {
@@ -2105,73 +2152,81 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             reason: 'force_bypass',
         }, cwd).catch(() => { });
     }
+    if (force && config.worker_launch_mode === 'prompt') {
+        // Prompt-mode workers are raw CLI children, not team-runtime workers that
+        // participate in the shutdown-ack handshake. Waiting the full ack window
+        // before force-killing them only adds deterministic suite slowness.
+        skipWorkerAcks = true;
+    }
     const sessionName = config.tmux_session;
     const dispatchPolicy = resolveDispatchPolicy(manifest?.policy, config.worker_launch_mode);
     const shutdownRequestTimes = new Map();
-    // 1. Send shutdown inbox to each worker
-    for (const w of config.workers) {
-        try {
-            const requestedAt = new Date().toISOString();
-            await writeShutdownRequest(sanitized, w.name, 'leader-fixed', cwd);
-            shutdownRequestTimes.set(w.name, requestedAt);
-            const triggerDirective = buildTriggerDirective(w.name, sanitized, resolveInstructionStateRoot(w.worktree_path));
-            await dispatchCriticalInboxInstruction({
-                teamName: sanitized,
-                config,
-                workerName: w.name,
-                workerIndex: w.index,
-                paneId: w.pane_id,
-                inbox: generateShutdownInbox(sanitized, w.name),
-                triggerMessage: triggerDirective.text,
-                intent: triggerDirective.intent,
-                cwd,
-                dispatchPolicy,
-                inboxCorrelationKey: `shutdown:${w.name}`,
-            });
-        }
-        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;
-    const rejected = [];
-    const ackedWorkers = new Set();
-    while (Date.now() < deadline) {
+    if (!skipWorkerAcks) {
+        // 1. Send shutdown inbox to each worker
         for (const w of config.workers) {
-            const ack = await readShutdownAck(sanitized, w.name, cwd, shutdownRequestTimes.get(w.name));
-            if (ack && !ackedWorkers.has(w.name)) {
-                ackedWorkers.add(w.name);
-                await appendTeamEvent(sanitized, {
-                    type: 'shutdown_ack',
-                    worker: w.name,
-                    reason: ack.status === 'reject' ? `reject:${ack.reason || 'no_reason'}` : 'accept',
-                }, cwd);
+            try {
+                const requestedAt = new Date().toISOString();
+                await writeShutdownRequest(sanitized, w.name, 'leader-fixed', cwd);
+                shutdownRequestTimes.set(w.name, requestedAt);
+                const triggerDirective = buildTriggerDirective(w.name, sanitized, resolveInstructionStateRoot(w.worktree_path));
+                await dispatchCriticalInboxInstruction({
+                    teamName: sanitized,
+                    config,
+                    workerName: w.name,
+                    workerIndex: w.index,
+                    paneId: w.pane_id,
+                    inbox: generateShutdownInbox(sanitized, w.name),
+                    triggerMessage: triggerDirective.text,
+                    intent: triggerDirective.intent,
+                    cwd,
+                    dispatchPolicy,
+                    inboxCorrelationKey: `shutdown:${w.name}`,
+                });
             }
-            if (ack?.status === 'reject') {
-                if (!rejected.some((r) => r.worker === w.name)) {
-                    rejected.push({ worker: w.name, reason: ack.reason || 'no_reason' });
-                }
+            catch (err) {
+                process.stderr.write(`[team/runtime] operation failed: ${err}\n`);
             }
         }
-        if (rejected.length > 0 && !force) {
-            const detail = rejected.map(r => `${r.worker}:${r.reason}`).join(',');
-            throw new Error(`shutdown_rejected:${detail}`);
+        // 2. Wait up to 15s for workers to exit and collect acks
+        const deadline = Date.now() + 15_000;
+        const rejected = [];
+        const ackedWorkers = new Set();
+        while (Date.now() < deadline) {
+            for (const w of config.workers) {
+                const ack = await readShutdownAck(sanitized, w.name, cwd, shutdownRequestTimes.get(w.name));
+                if (ack && !ackedWorkers.has(w.name)) {
+                    ackedWorkers.add(w.name);
+                    await appendTeamEvent(sanitized, {
+                        type: 'shutdown_ack',
+                        worker: w.name,
+                        reason: ack.status === 'reject' ? `reject:${ack.reason || 'no_reason'}` : 'accept',
+                    }, cwd);
+                }
+                if (ack?.status === 'reject') {
+                    if (!rejected.some((r) => r.worker === w.name)) {
+                        rejected.push({ worker: w.name, reason: ack.reason || 'no_reason' });
+                    }
+                }
+            }
+            if (rejected.length > 0 && !force) {
+                const detail = rejected.map(r => `${r.worker}:${r.reason}`).join(',');
+                throw new Error(`shutdown_rejected:${detail}`);
+            }
+            const anyAlive = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
+                ? isPromptWorkerAlive(config, w)
+                : isWorkerAlive(sessionName, w.index, w.pane_id)));
+            if (!anyAlive)
+                break;
+            // Sleep 2s
+            await new Promise(resolve => setTimeout(resolve, 2000));
         }
-        const anyAlive = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
+        const anyAliveAfterWait = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
             ? isPromptWorkerAlive(config, w)
             : isWorkerAlive(sessionName, w.index, w.pane_id)));
-        if (!anyAlive)
-            break;
-        // Sleep 2s
-        await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-    const anyAliveAfterWait = config.workers.some((w) => (config.worker_launch_mode === 'prompt'
-        ? isPromptWorkerAlive(config, w)
-        : isWorkerAlive(sessionName, w.index, w.pane_id)));
-    if (anyAliveAfterWait && !force) {
-        // Workers may have accepted shutdown but not exited (Codex TUI requires explicit exit).
-        // In this case, proceed to force kill panes (next step) rather than failing and leaving state around.
+        if (anyAliveAfterWait && !force) {
+            // Workers may have accepted shutdown but not exited (Codex TUI requires explicit exit).
+            // In this case, proceed to force kill panes (next step) rather than failing and leaving state around.
+        }
     }
     // 3. Force kill remaining workers
     const leaderPaneId = config.leader_pane_id;
@@ -2413,6 +2468,52 @@ async function findActiveTeams(cwd, leaderSessionId) {
     }
     return active;
 }
+async function detectAndCleanStaleTeam(teamName, leaderCwd, workerCount, confirmFn) {
+    const stateDir = join(leaderCwd, '.omx', 'state', 'team', teamName);
+    if (!existsSync(stateDir))
+        return;
+    const sessions = new Set(listTeamSessions());
+    if (sessions.has(`omx-team-${teamName}`))
+        return;
+    const repoRootResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd: leaderCwd, encoding: 'utf-8', windowsHide: true,
+    });
+    if (repoRootResult.status !== 0)
+        return;
+    const repoRoot = repoRootResult.stdout.trim();
+    const worktreePaths = [];
+    for (let i = 1; i <= workerCount; i++) {
+        const wtPath = join(repoRoot, '.omx', 'team', teamName, 'worktrees', `worker-${i}`);
+        if (existsSync(wtPath))
+            worktreePaths.push(wtPath);
+    }
+    if (worktreePaths.length === 0) {
+        await cleanupTeamState(teamName, leaderCwd);
+        return;
+    }
+    const hasDirtyWorktrees = worktreePaths.some((p) => {
+        try {
+            return isWorktreeDirty(p);
+        }
+        catch {
+            return false;
+        }
+    });
+    const summary = { teamName, worktreePaths, statePath: stateDir, hasDirtyWorktrees };
+    if (!confirmFn) {
+        throw new Error(`stale_team_artifacts:${teamName}:${worktreePaths.length}_worktrees:` +
+            'pass_confirmStaleCleanup_or_manually_remove');
+    }
+    const confirmed = await confirmFn(summary);
+    if (!confirmed) {
+        throw new Error(`stale_team_cleanup_declined:${teamName}:` +
+            'manually_remove_worktrees_and_state_before_retrying');
+    }
+    for (const wtPath of worktreePaths) {
+        await removeWorktreeForce(repoRoot, wtPath);
+    }
+    await cleanupTeamState(teamName, leaderCwd);
+}
 async function resolveLeaderSessionId(cwd) {
     const fromEnv = process.env.OMX_SESSION_ID || process.env.CODEX_SESSION_ID || process.env.SESSION_ID;
     if (fromEnv && fromEnv.trim() !== '')
@@ -2632,7 +2733,7 @@ async function dispatchCriticalInboxInstruction(params) {
     if (receipt?.status === 'failed') {
         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(() => { });
+            await transitionDispatchRequest(teamName, queued.request_id, 'pending', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
             return {
                 ok: true,
                 transport: fallback.transport,
@@ -2658,7 +2759,7 @@ async function dispatchCriticalInboxInstruction(params) {
     if (fallback.ok) {
         const marked = await markDispatchRequestNotified(teamName, queued.request_id, { last_reason: `fallback_confirmed:${fallback.reason}` }, cwd);
         if (!marked) {
-            await transitionDispatchRequest(teamName, queued.request_id, 'failed', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            await transitionDispatchRequest(teamName, queued.request_id, 'pending', 'failed', { last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
         }
         return {
             ok: true,
@@ -2700,7 +2801,7 @@ async function finalizeHookPreferredMailboxDispatch(params) {
     if (receipt?.status === 'failed') {
         if (fallback.ok) {
             await markMessageNotified(teamName, workerName, messageId, cwd).catch(() => false);
-            await transitionDispatchRequest(teamName, requestId, 'failed', 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => { });
+            await transitionDispatchRequest(teamName, requestId, 'failed', 'failed', { message_id: messageId, last_reason: `fallback_confirmed_after_failed_receipt:${fallback.reason}` }, cwd).catch(() => null);
             const outcome = {
                 ok: true,
                 transport: fallback.transport,