oh-my-codex 0.6.4 → 0.7.0

package/dist/team/runtime.js

@@ -2,18 +2,24 @@ import { join, resolve } from 'path';
 import { existsSync } from 'fs';
 import { readdir, readFile } from 'fs/promises';
 import { performance } from 'perf_hooks';
-import { sanitizeTeamName, isTmuxAvailable, createTeamSession, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, waitForWorkerReady, sendToWorker, notifyLeaderStatus, isWorkerAlive, getWorkerPanePid, killWorker, killWorkerByPaneId, unregisterResizeHook, destroyTeamSession, listTeamSessions, } from './tmux-session.js';
+import { spawn } from 'child_process';
+import { sanitizeTeamName, isTmuxAvailable, createTeamSession, buildWorkerProcessLaunchSpec, resolveTeamWorkerCli, resolveTeamWorkerCliPlan, resolveTeamWorkerLaunchMode, waitForWorkerReady, 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, teamClaimTask as claimTask, teamReleaseTaskClaim as releaseTaskClaim, teamAppendEvent as appendTeamEvent, teamReadTaskApproval as readTaskApproval, teamListMailbox as listMailboxMessages, teamMarkMessageNotified as markMessageNotified, 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, } from './mcp-comm.js';
 import { generateWorkerOverlay, writeTeamWorkerInstructionsFile, removeTeamWorkerInstructionsFile, generateInitialInbox, generateTaskAssignmentInbox, generateShutdownInbox, generateTriggerMessage, generateMailboxTriggerMessage, } from './worker-bootstrap.js';
-import { isLowComplexityAgentType, resolveTeamWorkerLaunchArgs, TEAM_LOW_COMPLEXITY_DEFAULT_MODEL, parseTeamWorkerLaunchArgs, splitWorkerLaunchArgs, } from './model-contract.js';
+import { isLowComplexityAgentType, resolveTeamWorkerLaunchArgs, TEAM_LOW_COMPLEXITY_DEFAULT_MODEL, resolveTeamLowComplexityDefaultModel, parseTeamWorkerLaunchArgs, splitWorkerLaunchArgs, } from './model-contract.js';
 import { inferPhaseTargetFromTaskCounts, reconcilePhaseStateForMonitor } from './phase-controller.js';
 import { getTeamTmuxSessions } from '../notifications/tmux.js';
+import { hasStructuredVerificationEvidence } from '../verification/verifier.js';
 import { ensureWorktree, planWorktreeTarget, rollbackProvisionedWorktrees, } from './worktree.js';
 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 promptWorkerRegistry = new Map();
 const previousModelInstructionsFileByTeam = new Map();
+const PROMPT_WORKER_SIGTERM_WAIT_MS = 3_000;
+const PROMPT_WORKER_SIGKILL_WAIT_MS = 2_000;
+const PROMPT_WORKER_EXIT_POLL_MS = 100;
 function resolveWorkerReadyTimeoutMs(env) {
     const raw = env.OMX_TEAM_READY_TIMEOUT_MS;
     const parsed = Number.parseInt(String(raw ?? ''), 10);
@@ -41,16 +47,149 @@ function restoreTeamModelInstructionsFile(teamName) {
     }
     delete process.env[MODEL_INSTRUCTIONS_FILE_ENV];
 }
+function registerPromptWorkerHandle(teamName, workerName, child) {
+    const { pid } = child;
+    if (!Number.isFinite(pid) || (pid ?? 0) < 1) {
+        throw new Error(`failed to spawn prompt worker process for ${workerName}`);
+    }
+    const processPid = pid;
+    const existingTeamHandles = promptWorkerRegistry.get(teamName) ?? new Map();
+    existingTeamHandles.set(workerName, { child, pid: processPid });
+    promptWorkerRegistry.set(teamName, existingTeamHandles);
+    child.on('exit', () => {
+        const teamHandles = promptWorkerRegistry.get(teamName);
+        if (!teamHandles)
+            return;
+        teamHandles.delete(workerName);
+        if (teamHandles.size === 0)
+            promptWorkerRegistry.delete(teamName);
+    });
+}
+function getPromptWorkerHandle(teamName, workerName) {
+    return promptWorkerRegistry.get(teamName)?.get(workerName) ?? null;
+}
+function removePromptWorkerHandle(teamName, workerName) {
+    const teamHandles = promptWorkerRegistry.get(teamName);
+    if (!teamHandles)
+        return;
+    teamHandles.delete(workerName);
+    if (teamHandles.size === 0)
+        promptWorkerRegistry.delete(teamName);
+}
+function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPidExit(pid, timeoutMs) {
+    if (!isPidAlive(pid))
+        return true;
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, PROMPT_WORKER_EXIT_POLL_MS));
+        if (!isPidAlive(pid))
+            return true;
+    }
+    return !isPidAlive(pid);
+}
+async function teardownPromptWorker(teamName, workerName, fallbackPid, cwd, context) {
+    const handle = getPromptWorkerHandle(teamName, workerName);
+    const pid = Number.isFinite(handle?.pid)
+        ? handle.pid
+        : (Number.isFinite(fallbackPid) && (fallbackPid ?? 0) > 0 ? fallbackPid : null);
+    if (pid === null) {
+        removePromptWorkerHandle(teamName, workerName);
+        return { terminated: true, forcedKill: false, pid: null };
+    }
+    try {
+        if (handle && handle.child.exitCode === null && !handle.child.killed) {
+            handle.child.kill('SIGTERM');
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+        }
+    }
+    catch {
+        // Best effort.
+    }
+    const exitedOnTerm = await waitForPidExit(pid, PROMPT_WORKER_SIGTERM_WAIT_MS);
+    if (exitedOnTerm) {
+        removePromptWorkerHandle(teamName, workerName);
+        return { terminated: true, forcedKill: false, pid };
+    }
+    await appendTeamEvent(teamName, {
+        type: 'worker_stopped',
+        worker: workerName,
+        reason: `prompt_force_kill:${context}:pid=${pid}`,
+    }, cwd).catch(() => { });
+    try {
+        if (handle && handle.child.exitCode === null) {
+            handle.child.kill('SIGKILL');
+        }
+        else {
+            process.kill(pid, 'SIGKILL');
+        }
+    }
+    catch {
+        // Best effort.
+    }
+    const exitedOnKill = await waitForPidExit(pid, PROMPT_WORKER_SIGKILL_WAIT_MS);
+    if (!exitedOnKill) {
+        await appendTeamEvent(teamName, {
+            type: 'worker_stopped',
+            worker: workerName,
+            reason: `prompt_teardown_failed:${context}:pid=${pid}`,
+        }, cwd).catch(() => { });
+        return {
+            terminated: false,
+            forcedKill: true,
+            pid,
+            error: 'still_alive_after_sigkill',
+        };
+    }
+    removePromptWorkerHandle(teamName, workerName);
+    return { terminated: true, forcedKill: true, pid };
+}
+function isPromptWorkerAlive(config, worker) {
+    const handle = getPromptWorkerHandle(config.name, worker.name);
+    if (handle?.child.exitCode === null && !handle.child.killed)
+        return true;
+    if (!Number.isFinite(worker.pid) || (worker.pid ?? 0) <= 0)
+        return false;
+    try {
+        process.kill(worker.pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export { TEAM_LOW_COMPLEXITY_DEFAULT_MODEL };
 export function resolveCanonicalTeamStateRoot(leaderCwd) {
     return resolve(join(leaderCwd, '.omx', 'state'));
 }
+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, {
+        cwd: workerCwd,
+        env: { ...process.env, ...processSpec.env },
+        stdio: ['pipe', 'ignore', 'ignore'],
+    });
+    registerPromptWorkerHandle(teamName, workerName, child);
+    return child;
+}
 export function resolveWorkerLaunchArgsFromEnv(env, agentType, inheritedLeaderModel) {
     const inheritedArgs = (typeof inheritedLeaderModel === 'string' && inheritedLeaderModel.trim() !== '')
         ? ['--model', inheritedLeaderModel.trim()]
         : [];
     const fallbackModel = isLowComplexityAgentType(agentType)
-        ? TEAM_LOW_COMPLEXITY_DEFAULT_MODEL
+        ? resolveTeamLowComplexityDefaultModel(env.CODEX_HOME)
         : undefined;
     // Detect if an explicit reasoning override exists before resolving (for log source labelling)
     const preEnvArgs = splitWorkerLaunchArgs(env.OMX_TEAM_WORKER_LAUNCH_ARGS);
@@ -110,13 +249,15 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
     if (process.env.OMX_TEAM_WORKER) {
         throw new Error('nested_team_disallowed');
     }
-    // tmux-only runtime
-    if (!isTmuxAvailable()) {
-        throw new Error('Team mode requires tmux. Install with: apt install tmux / brew install tmux');
-    }
-    const displayMode = 'split_pane';
-    if (!process.env.TMUX) {
-        throw new Error('Team mode requires running inside tmux current leader pane');
+    const workerLaunchMode = resolveTeamWorkerLaunchMode(process.env);
+    const displayMode = workerLaunchMode === 'interactive' ? 'split_pane' : 'auto';
+    if (workerLaunchMode === 'interactive') {
+        if (!isTmuxAvailable()) {
+            throw new Error('Team mode requires tmux. Install with: apt install tmux / brew install tmux');
+        }
+        if (!process.env.TMUX) {
+            throw new Error('Team mode requires running inside tmux current leader pane');
+        }
     }
     const leaderCwd = resolve(cwd);
     const sanitized = sanitizeTeamName(teamName);
@@ -172,7 +313,7 @@ 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 }, {
+        config = await initTeamState(sanitized, task, agentType, workerCount, leaderCwd, DEFAULT_MAX_WORKERS, { ...process.env, OMX_TEAM_DISPLAY_MODE: displayMode, OMX_TEAM_WORKER_LAUNCH_MODE: workerLaunchMode }, {
             leader_cwd: leaderCwd,
             team_state_root: teamStateRoot,
             workspace_mode: workspaceMode,
@@ -217,23 +358,44 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 env,
             };
         });
-        // 6. Create tmux session with workers
-        const createdSession = createTeamSession(sanitized, workerCount, leaderCwd, workerLaunchArgs, workerStartups);
-        sessionName = createdSession.name;
-        sessionCreated = true;
-        createdWorkerPaneIds.push(...createdSession.workerPaneIds);
-        createdLeaderPaneId = createdSession.leaderPaneId;
-        config.tmux_session = sessionName;
-        config.leader_pane_id = createdSession.leaderPaneId;
-        config.hud_pane_id = createdSession.hudPaneId;
-        config.resize_hook_name = createdSession.resizeHookName;
-        config.resize_hook_target = createdSession.resizeHookTarget;
+        const workerPaneIds = Array.from({ length: workerCount }, () => undefined);
+        // 6. Create worker runtime (interactive tmux panes or prompt-mode child processes)
+        if (workerLaunchMode === 'interactive') {
+            const createdSession = createTeamSession(sanitized, workerCount, leaderCwd, workerLaunchArgs, workerStartups);
+            sessionName = createdSession.name;
+            sessionCreated = true;
+            createdWorkerPaneIds.push(...createdSession.workerPaneIds);
+            createdLeaderPaneId = createdSession.leaderPaneId;
+            config.tmux_session = sessionName;
+            config.leader_pane_id = createdSession.leaderPaneId;
+            config.hud_pane_id = createdSession.hudPaneId;
+            config.resize_hook_name = createdSession.resizeHookName;
+            config.resize_hook_target = createdSession.resizeHookTarget;
+            for (let i = 0; i < createdSession.workerPaneIds.length; i++) {
+                workerPaneIds[i] = createdSession.workerPaneIds[i];
+            }
+        }
+        else {
+            config.tmux_session = `prompt-${sanitized}`;
+            config.leader_pane_id = null;
+            config.hud_pane_id = null;
+            config.resize_hook_name = null;
+            config.resize_hook_target = null;
+            for (let i = 1; i <= workerCount; i++) {
+                const startup = workerStartups[i - 1] || {};
+                const workerName = `worker-${i}`;
+                const child = spawnPromptWorker(sanitized, workerName, i, startup.cwd || leaderCwd, workerLaunchArgs, startup.env || {}, workerCliPlan[i - 1]);
+                if (config.workers[i - 1]) {
+                    config.workers[i - 1].pid = child.pid;
+                }
+            }
+        }
         await saveTeamConfig(config, leaderCwd);
-        // 7. Wait for all workers to be ready, then bootstrap them
+        // 7. Wait for all workers to be ready (interactive mode), then bootstrap them
         const allTasks = await listTasks(sanitized, leaderCwd);
         for (let i = 1; i <= workerCount; i++) {
             const workerName = `worker-${i}`;
-            const paneId = createdSession.workerPaneIds[i - 1];
+            const paneId = workerPaneIds[i - 1];
             const workerWorkspace = workerWorkspaceByName.get(workerName) ?? { cwd: leaderCwd };
             // Get tasks assigned to this worker
             const workerTasks = allTasks.filter(t => t.owner === workerName);
@@ -250,10 +412,15 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 worktree_detached: workerWorkspace.worktreeDetached,
                 team_state_root: teamStateRoot,
             };
-            // Get pane PID and store it
-            const panePid = getWorkerPanePid(sessionName, i);
-            if (panePid)
-                identity.pid = panePid;
+            // Get pane PID and store it (interactive mode) or process PID (prompt mode)
+            if (workerLaunchMode === 'interactive') {
+                const panePid = getWorkerPanePid(sessionName, i);
+                if (panePid)
+                    identity.pid = panePid;
+            }
+            else if (config.workers[i - 1]?.pid) {
+                identity.pid = config.workers[i - 1].pid;
+            }
             if (paneId)
                 identity.pane_id = paneId;
             if (config.workers[i - 1]) {
@@ -267,7 +434,7 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
             }
             await writeWorkerIdentity(sanitized, workerName, identity, leaderCwd);
             // Wait for worker readiness
-            if (!skipWorkerReadyWait) {
+            if (workerLaunchMode === 'interactive' && !skipWorkerReadyWait) {
                 const ready = waitForWorkerReady(sessionName, i, workerReadyTimeoutMs, paneId);
                 if (!ready) {
                     throw new Error(`Worker ${workerName} did not become ready in tmux session ${sessionName}`);
@@ -350,6 +517,18 @@ export async function startTeam(teamName, task, agentType, workerCount, tasks, c
                 }
             }
         }
+        if (workerLaunchMode === 'prompt' && config) {
+            const promptTeardownFailures = [];
+            for (const worker of config.workers) {
+                const teardown = await teardownPromptWorker(sanitized, worker.name, worker.pid, leaderCwd, 'startup_rollback');
+                if (!teardown.terminated) {
+                    promptTeardownFailures.push(`${worker.name}:${teardown.error || 'unknown_error'}`);
+                }
+            }
+            if (promptTeardownFailures.length > 0) {
+                rollbackErrors.push(`promptTeardown:${promptTeardownFailures.join(',')}`);
+            }
+        }
         if (workerInstructionsPath) {
             try {
                 await removeTeamWorkerInstructionsFile(sanitized, leaderCwd);
@@ -409,7 +588,9 @@ export async function monitorTeam(teamName, cwd) {
     const recommendations = [];
     const workerScanStartMs = performance.now();
     const workerSignals = await Promise.all(config.workers.map(async (worker) => {
-        const alive = isWorkerAlive(sessionName, worker.index, worker.pane_id);
+        const alive = config.worker_launch_mode === 'prompt'
+            ? isPromptWorkerAlive(config, worker)
+            : isWorkerAlive(sessionName, worker.index, worker.pane_id);
         const [status, heartbeat] = await Promise.all([
             readWorkerStatus(sanitized, worker.name, cwd),
             readWorkerHeartbeat(sanitized, worker.name, cwd),
@@ -461,9 +642,19 @@ export async function monitorTeam(teamName, cwd) {
         completed: allTasks.filter(t => t.status === 'completed').length,
         failed: allTasks.filter(t => t.status === 'failed').length,
     };
+    const verificationPendingTasks = allTasks.filter((task) => task.status === 'completed'
+        && task.requires_code_change === true
+        && !hasStructuredVerificationEvidence(task.result));
+    if (verificationPendingTasks.length > 0) {
+        for (const task of verificationPendingTasks) {
+            recommendations.push(`Verification evidence missing for task-${task.id}; require structured PASS/FAIL evidence before terminal success`);
+        }
+    }
     const allTasksTerminal = taskCounts.pending === 0 && taskCounts.blocked === 0 && taskCounts.in_progress === 0;
     const persistedPhase = await readTeamPhaseState(sanitized, cwd);
-    const targetPhase = inferPhaseTargetFromTaskCounts(taskCounts);
+    const targetPhase = inferPhaseTargetFromTaskCounts(taskCounts, {
+        verificationPending: verificationPendingTasks.length > 0,
+    });
     const phaseState = reconcilePhaseStateForMonitor(persistedPhase, targetPhase);
     await writeTeamPhaseState(sanitized, phaseState, cwd);
     const phase = phaseState.current_phase;
@@ -600,6 +791,27 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
         restoreTeamModelInstructionsFile(sanitized);
         return;
     }
+    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 = gate.pending === 0 && gate.blocked === 0 && gate.in_progress === 0 && gate.failed === 0;
+        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}`,
+        }, 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 sessionName = config.tmux_session;
     const shutdownRequestTimes = new Map();
     // 1. Send shutdown inbox to each worker
@@ -649,13 +861,17 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
             const detail = rejected.map(r => `${r.worker}:${r.reason}`).join(',');
             throw new Error(`shutdown_rejected:${detail}`);
         }
-        const anyAlive = config.workers.some(w => isWorkerAlive(sessionName, w.index, w.pane_id));
+        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 anyAliveAfterWait = config.workers.some(w => isWorkerAlive(sessionName, w.index, w.pane_id));
+    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.
@@ -663,38 +879,57 @@ export async function shutdownTeam(teamName, cwd, options = {}) {
     // 3. Force kill remaining workers
     const leaderPaneId = config.leader_pane_id;
     const hudPaneId = config.hud_pane_id;
-    if (config.resize_hook_name && config.resize_hook_target) {
-        const unregistered = unregisterResizeHook(config.resize_hook_target, config.resize_hook_name);
-        if (!unregistered && isTmuxAvailable()) {
-            const baseSession = sessionName.split(':')[0];
-            const sessionStillActive = listTeamSessions().includes(baseSession);
-            if (sessionStillActive) {
-                throw new Error(`failed to unregister resize hook ${config.resize_hook_name}`);
+    if (config.worker_launch_mode === 'interactive') {
+        let resizeHookWarning = null;
+        if (config.resize_hook_name && config.resize_hook_target) {
+            const resizeHookName = config.resize_hook_name;
+            const unregistered = unregisterResizeHook(config.resize_hook_target, resizeHookName);
+            if (!unregistered && isTmuxAvailable()) {
+                const baseSession = sessionName.split(':')[0];
+                const sessionStillActive = listTeamSessions().includes(baseSession);
+                if (sessionStillActive) {
+                    resizeHookWarning = `failed to unregister resize hook ${resizeHookName}`;
+                }
             }
         }
-    }
-    config.resize_hook_name = null;
-    config.resize_hook_target = null;
-    await saveTeamConfig(config, cwd);
-    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);
+        config.resize_hook_name = null;
+        config.resize_hook_target = null;
+        await saveTeamConfig(config, cwd);
+        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 */ }
+        }
+        // 4. Destroy tmux session
+        if (!sessionName.includes(':')) {
+            try {
+                destroyTeamSession(sessionName);
+            }
+            catch { /* ignore */ }
         }
-        catch { /* ignore */ }
     }
-    // 4. Destroy tmux session
-    if (!sessionName.includes(':')) {
-        try {
-            destroyTeamSession(sessionName);
+    else {
+        const promptTeardownFailures = [];
+        for (const w of config.workers) {
+            const teardown = await teardownPromptWorker(sanitized, w.name, w.pid, cwd, 'shutdown');
+            if (!teardown.terminated) {
+                promptTeardownFailures.push(`${w.name}:${teardown.error || 'unknown_error'}`);
+            }
+        }
+        if (promptTeardownFailures.length > 0) {
+            throw new Error(`shutdown_prompt_teardown_failed:${promptTeardownFailures.join(',')}`);
         }
-        catch { /* ignore */ }
     }
     // 5. Remove team-scoped worker instructions file (no mutation of project AGENTS.md)
     try {
@@ -713,11 +948,40 @@ export async function resumeTeam(teamName, cwd) {
     const config = await readTeamConfig(sanitized, cwd);
     if (!config)
         return null;
-    // Check if tmux session still exists
-    const baseSession = config.tmux_session.split(':')[0];
-    const teamSessions = getTeamTmuxSessions(sanitized);
-    if (!teamSessions.includes(baseSession))
-        return null;
+    if (config.worker_launch_mode === 'prompt') {
+        const hasLivePromptWorker = config.workers.some((worker) => isPromptWorkerAlive(config, worker));
+        if (!hasLivePromptWorker)
+            return null;
+        const missingHandles = config.workers
+            .filter((worker) => {
+            if (!Number.isFinite(worker.pid) || (worker.pid ?? 0) <= 0)
+                return false;
+            try {
+                process.kill(worker.pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })
+            .filter((worker) => !getPromptWorkerHandle(sanitized, worker.name));
+        if (missingHandles.length > 0) {
+            const detail = missingHandles.map((worker) => `${worker.name}:${worker.pid ?? 'unknown'}`).join(',');
+            await appendTeamEvent(sanitized, {
+                type: 'worker_stopped',
+                worker: 'leader-fixed',
+                reason: `prompt_resume_unavailable:missing_handle:${detail}`,
+            }, cwd).catch(() => { });
+            return null;
+        }
+    }
+    else {
+        // Check if tmux session still exists
+        const baseSession = config.tmux_session.split(':')[0];
+        const teamSessions = getTeamTmuxSessions(sanitized);
+        if (!teamSessions.includes(baseSession))
+            return null;
+    }
     return {
         teamName: sanitized,
         sanitizedName: sanitized,
@@ -741,12 +1005,21 @@ async function findActiveTeams(cwd, leaderSessionId) {
         const manifest = await readTeamManifestV2(teamName, cwd);
         if (manifest?.policy?.one_team_per_leader_session === false)
             continue;
+        const workerLaunchMode = cfg?.worker_launch_mode
+            ?? manifest?.policy?.worker_launch_mode
+            ?? 'interactive';
         const tmuxSession = (manifest?.tmux_session || cfg?.tmux_session || `omx-team-${teamName}`).split(':')[0];
         if (leaderSessionId) {
             const ownerSessionId = manifest?.leader?.session_id?.trim() ?? '';
             if (ownerSessionId && ownerSessionId !== leaderSessionId)
                 continue;
         }
+        if (workerLaunchMode === 'prompt') {
+            if ((cfg?.workers ?? []).some((worker) => isPromptWorkerAlive(cfg, worker))) {
+                active.push(teamName);
+            }
+            continue;
+        }
         if (sessions.has(tmuxSession))
             active.push(teamName);
     }
@@ -816,11 +1089,25 @@ async function emitMonitorDerivedEvents(teamName, tasks, workers, previous, cwd)
     }
 }
 function notifyWorker(config, workerIndex, message, workerPaneId) {
+    const worker = config.workers.find((candidate) => candidate.index === workerIndex);
+    if (!worker)
+        return false;
+    if (config.worker_launch_mode === 'prompt') {
+        const handle = getPromptWorkerHandle(config.name, worker.name);
+        if (!handle)
+            return false;
+        try {
+            sendToWorkerStdin(handle.child.stdin, message);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     if (!config.tmux_session || !isTmuxAvailable())
         return false;
     try {
-        const workerCli = config.workers.find((worker) => worker.index === workerIndex)?.worker_cli;
-        sendToWorker(config.tmux_session, workerIndex, message, workerPaneId, workerCli);
+        sendToWorker(config.tmux_session, workerIndex, message, workerPaneId, worker.worker_cli);
         return true;
     }
     catch {