oh-my-codex 0.8.11 → 0.8.13

package/dist/team/__tests__/runtime.test.js

@@ -24,25 +24,53 @@ function expectedLowComplexityModel(codexHomeOverride) {
 function withEmptyPath(fn) {
     const prev = process.env.PATH;
     process.env.PATH = '';
+    let restoreImmediately = true;
     try {
-        return fn();
+        const result = fn();
+        if (result instanceof Promise) {
+            restoreImmediately = false;
+            return result.finally(() => {
+                if (typeof prev === 'string')
+                    process.env.PATH = prev;
+                else
+                    delete process.env.PATH;
+            });
+        }
+        return result;
     }
     finally {
-        if (typeof prev === 'string')
-            process.env.PATH = prev;
-        else
-            delete process.env.PATH;
+        if (restoreImmediately) {
+            if (typeof prev === 'string')
+                process.env.PATH = prev;
+            else
+                delete process.env.PATH;
+        }
     }
 }
 function withoutTeamWorkerEnv(fn) {
     const prev = process.env.OMX_TEAM_WORKER;
     delete process.env.OMX_TEAM_WORKER;
+    let restoreImmediately = true;
     try {
-        return fn();
+        const result = fn();
+        if (result instanceof Promise) {
+            restoreImmediately = false;
+            return result.finally(() => {
+                if (typeof prev === 'string')
+                    process.env.OMX_TEAM_WORKER = prev;
+                else
+                    delete process.env.OMX_TEAM_WORKER;
+            });
+        }
+        return result;
     }
     finally {
-        if (typeof prev === 'string')
-            process.env.OMX_TEAM_WORKER = prev;
+        if (restoreImmediately) {
+            if (typeof prev === 'string')
+                process.env.OMX_TEAM_WORKER = prev;
+            else
+                delete process.env.OMX_TEAM_WORKER;
+        }
     }
 }
 async function waitForFileText(filePath, matcher, timeoutMs = 3_000) {
@@ -311,12 +339,87 @@ describe('runtime', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('startTeam allows nested team invocation when parent governance enables it', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-nested-allow-'));
+        const binDir = join(cwd, 'bin');
+        const fakeGeminiPath = join(binDir, 'gemini');
+        await mkdir(binDir, { recursive: true });
+        await writeFile(fakeGeminiPath, `#!/usr/bin/env bash
+sleep 5
+`, { mode: 0o755 });
+        await initTeamState('parent-team', 'parent', 'executor', 1, cwd);
+        const parentManifestPath = join(cwd, '.omx', 'state', 'team', 'parent-team', 'manifest.v2.json');
+        const parentManifest = JSON.parse(await readFile(parentManifestPath, 'utf-8'));
+        parentManifest.governance = { ...(parentManifest.governance || {}), nested_teams_allowed: true };
+        await writeFile(parentManifestPath, JSON.stringify(parentManifest, null, 2));
+        const prevPath = process.env.PATH;
+        const prevTmux = process.env.TMUX;
+        const prevWorker = process.env.OMX_TEAM_WORKER;
+        const prevStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        const prevLeaderCwd = process.env.OMX_TEAM_LEADER_CWD;
+        const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+        const prevWorkerCli = process.env.OMX_TEAM_WORKER_CLI;
+        process.env.PATH = `${binDir}:${prevPath ?? ''}`;
+        delete process.env.TMUX;
+        process.env.OMX_TEAM_WORKER = 'parent-team/worker-1';
+        process.env.OMX_TEAM_STATE_ROOT = join(cwd, '.omx', 'state');
+        process.env.OMX_TEAM_LEADER_CWD = cwd;
+        process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
+        process.env.OMX_TEAM_WORKER_CLI = 'gemini';
+        let runtime = null;
+        try {
+            runtime = await startTeam('nested-allowed', 'nested task', 'explore', 1, [{ subject: 's', description: 'd', owner: 'worker-1' }], cwd);
+            assert.equal(runtime.teamName, 'nested-allowed');
+            await shutdownTeam(runtime.teamName, cwd, { force: true });
+            runtime = null;
+        }
+        finally {
+            if (runtime) {
+                await shutdownTeam(runtime.teamName, cwd, { force: true }).catch(() => { });
+            }
+            if (typeof prevPath === 'string')
+                process.env.PATH = prevPath;
+            else
+                delete process.env.PATH;
+            if (typeof prevTmux === 'string')
+                process.env.TMUX = prevTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof prevWorker === 'string')
+                process.env.OMX_TEAM_WORKER = prevWorker;
+            else
+                delete process.env.OMX_TEAM_WORKER;
+            if (typeof prevStateRoot === 'string')
+                process.env.OMX_TEAM_STATE_ROOT = prevStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            if (typeof prevLeaderCwd === 'string')
+                process.env.OMX_TEAM_LEADER_CWD = prevLeaderCwd;
+            else
+                delete process.env.OMX_TEAM_LEADER_CWD;
+            if (typeof prevLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof prevWorkerCli === 'string')
+                process.env.OMX_TEAM_WORKER_CLI = prevWorkerCli;
+            else
+                delete process.env.OMX_TEAM_WORKER_CLI;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('startTeam throws when tmux is not available', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-'));
+        const prevLaunchMode = process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
         try {
+            process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'interactive';
             await assert.rejects(() => withoutTeamWorkerEnv(() => withEmptyPath(() => startTeam('team-a', 'task', 'executor', 1, [{ subject: 's', description: 'd' }], cwd))), /requires tmux/i);
         }
         finally {
+            if (typeof prevLaunchMode === 'string')
+                process.env.OMX_TEAM_WORKER_LAUNCH_MODE = prevLaunchMode;
+            else
+                delete process.env.OMX_TEAM_WORKER_LAUNCH_MODE;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -869,8 +972,64 @@ process.on('SIGTERM', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('monitorTeam surfaces reclaimed work pickup attempts when an idle worker is available', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-reassign-reclaimed-'));
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        delete process.env.OMX_TEAM_STATE_ROOT;
+        let sleeper1 = null;
+        let sleeper2 = null;
+        try {
+            await initTeamState('team-runtime-reassign', 'reassign reclaimed test', 'executor', 2, cwd);
+            const task = await createTask('team-runtime-reassign', { subject: 'write docs', description: 'document feature', status: 'pending', role: 'writer' }, cwd);
+            const claim = await claimTask('team-runtime-reassign', task.id, 'worker-1', null, cwd);
+            assert.ok(claim.ok);
+            if (!claim.ok)
+                throw new Error('claim failed');
+            const taskPath = join(cwd, '.omx', 'state', 'team', 'team-runtime-reassign', 'tasks', `task-${task.id}.json`);
+            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
+            current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
+            await writeAtomic(taskPath, JSON.stringify(current, null, 2));
+            const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-runtime-reassign', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            sleeper1 = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore', detached: false });
+            sleeper2 = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore', detached: false });
+            manifest.policy = { ...(manifest.policy || {}), worker_launch_mode: 'prompt' };
+            manifest.workers[0].role = 'executor';
+            manifest.workers[1].role = 'writer';
+            manifest.workers[0].pid = sleeper1.pid;
+            manifest.workers[1].pid = sleeper2.pid;
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+            await writeAtomic(join(cwd, '.omx', 'state', 'team', 'team-runtime-reassign', 'workers', 'worker-1', 'status.json'), JSON.stringify({ state: 'working', current_task_id: task.id, updated_at: new Date().toISOString() }, null, 2));
+            await writeAtomic(join(cwd, '.omx', 'state', 'team', 'team-runtime-reassign', 'workers', 'worker-2', 'status.json'), JSON.stringify({ state: 'idle', updated_at: new Date().toISOString() }, null, 2));
+            const snapshot = await monitorTeam('team-runtime-reassign', cwd);
+            assert.ok(snapshot);
+            const reread = await readTask('team-runtime-reassign', task.id, cwd);
+            assert.equal(reread?.status, 'pending');
+            assert.equal(reread?.owner, undefined);
+            assert.equal(snapshot?.recommendations.some((r) => r.includes(`Unable to assign task-${task.id} to worker-2: worker_notify_failed`)), true);
+        }
+        finally {
+            try {
+                if (sleeper1?.pid)
+                    process.kill(sleeper1.pid, 'SIGKILL');
+            }
+            catch { }
+            try {
+                if (sleeper2?.pid)
+                    process.kill(sleeper2.pid, 'SIGKILL');
+            }
+            catch { }
+            if (typeof prevTeamStateRoot === 'string')
+                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('monitorTeam reclaims expired task claims and surfaces the recovery in recommendations', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-reclaim-'));
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        delete process.env.OMX_TEAM_STATE_ROOT;
         try {
             await initTeamState('team-runtime-reclaim', 'reclaim test', 'executor', 2, cwd);
             const t = await createTask('team-runtime-reclaim', { subject: 'task', description: 'd', status: 'pending' }, cwd);
@@ -890,6 +1049,10 @@ process.on('SIGTERM', () => {
             assert.equal(snapshot?.recommendations.some((r) => r.includes(`task-${t.id}`) && r.includes('Reclaimed expired claim')), true);
         }
         finally {
+            if (typeof prevTeamStateRoot === 'string')
+                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
             await rm(cwd, { recursive: true, force: true });
         }
     });
@@ -960,6 +1123,45 @@ process.on('SIGTERM', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('monitorTeam propagates linked terminal state into Ralph without waiting for notify-hook', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-linked-ralph-monitor-'));
+        try {
+            await initTeamState('team-linked-ralph-monitor', 'linked runtime sync test', 'executor', 1, cwd);
+            await createTask('team-linked-ralph-monitor', {
+                subject: 'code change',
+                description: 'implement feature',
+                status: 'completed',
+                owner: 'worker-1',
+                requires_code_change: false,
+            }, cwd);
+            await writeFile(join(cwd, '.omx', 'state', 'team-state.json'), JSON.stringify({
+                active: true,
+                current_phase: 'team-exec',
+                linked_ralph: true,
+                team_name: 'team-linked-ralph-monitor',
+            }, null, 2));
+            await writeFile(join(cwd, '.omx', 'state', 'ralph-state.json'), JSON.stringify({
+                active: true,
+                iteration: 1,
+                max_iterations: 10,
+                current_phase: 'executing',
+                started_at: '2026-03-11T00:00:00.000Z',
+                linked_team: true,
+            }, null, 2));
+            const snapshot = await monitorTeam('team-linked-ralph-monitor', cwd);
+            assert.ok(snapshot);
+            assert.equal(snapshot?.phase, 'complete');
+            const ralphState = JSON.parse(await readFile(join(cwd, '.omx', 'state', 'ralph-state.json'), 'utf-8'));
+            assert.equal(ralphState.active, false);
+            assert.equal(ralphState.current_phase, 'complete');
+            assert.equal(ralphState.linked_team_terminal_phase, 'complete');
+            assert.ok(typeof ralphState.linked_team_terminal_at === 'string' && ralphState.linked_team_terminal_at);
+            assert.ok(typeof ralphState.completed_at === 'string' && ralphState.completed_at);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('monitorTeam emits worker_state_changed, worker_idle, and task_completed events based on transitions', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-'));
         try {
@@ -1006,6 +1208,26 @@ process.on('SIGTERM', () => {
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('shutdownTeam honors governance cleanup override when active tasks remain', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-gate-override-'));
+        try {
+            await initTeamState('team-shutdown-gate-override', 'shutdown gate override test', 'executor', 1, cwd);
+            await createTask('team-shutdown-gate-override', { subject: 'pending', description: 'd', status: 'pending' }, cwd);
+            const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-shutdown-gate-override', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.governance = {
+                ...(manifest.governance || {}),
+                cleanup_requires_all_workers_inactive: false,
+            };
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+            await shutdownTeam('team-shutdown-gate-override', cwd);
+            const teamRoot = join(cwd, '.omx', 'state', 'team', 'team-shutdown-gate-override');
+            assert.equal(existsSync(teamRoot), false);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('shutdownTeam blocks when failed tasks remain (completion gate)', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-gate-failed-'));
         try {
@@ -1289,7 +1511,7 @@ esac
             await rm(fakeBinDir, { recursive: true, force: true });
         }
     });
-    it('shutdownTeam preserves leader and hud exclusions in teardown', async () => {
+    it('shutdownTeam preserves leader exclusion while tearing down the hud pane', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-exclusions-'));
         const fakeBinDir = await mkdtemp(join(tmpdir(), 'omx-runtime-shutdown-exclusions-bin-'));
         const tmuxLogPath = join(fakeBinDir, 'tmux.log');
@@ -1332,7 +1554,7 @@ esac
             await shutdownTeam('team-shutdown-exclusions', cwd, { force: true });
             const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
             assert.doesNotMatch(tmuxLog, /kill-pane -t %11/);
-            assert.doesNotMatch(tmuxLog, /kill-pane -t %12/);
+            assert.match(tmuxLog, /kill-pane -t %12/);
             assert.match(tmuxLog, /kill-pane -t %13/);
         }
         finally {
@@ -1402,6 +1624,37 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('shutdownTeam ralph=true propagates linked Ralph cancellation before cleanup', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-linked-ralph-shutdown-'));
+        try {
+            await initTeamState('team-linked-ralph-shutdown', 'linked shutdown sync test', 'executor', 1, cwd);
+            await createTask('team-linked-ralph-shutdown', { subject: 'done', description: 'd', status: 'completed' }, cwd);
+            await writeFile(join(cwd, '.omx', 'state', 'team-state.json'), JSON.stringify({
+                active: true,
+                current_phase: 'team-exec',
+                linked_ralph: true,
+                team_name: 'team-linked-ralph-shutdown',
+            }, null, 2));
+            await writeFile(join(cwd, '.omx', 'state', 'ralph-state.json'), JSON.stringify({
+                active: true,
+                iteration: 1,
+                max_iterations: 10,
+                current_phase: 'executing',
+                started_at: '2026-03-11T00:00:00.000Z',
+                linked_team: true,
+            }, null, 2));
+            await shutdownTeam('team-linked-ralph-shutdown', cwd, { ralph: true });
+            const ralphState = JSON.parse(await readFile(join(cwd, '.omx', 'state', 'ralph-state.json'), 'utf-8'));
+            assert.equal(ralphState.active, false);
+            assert.equal(ralphState.current_phase, 'cancelled');
+            assert.equal(ralphState.linked_team_terminal_phase, 'cancelled');
+            assert.ok(typeof ralphState.linked_team_terminal_at === 'string' && ralphState.linked_team_terminal_at);
+            assert.ok(typeof ralphState.completed_at === 'string' && ralphState.completed_at);
+        }
+        finally {
+            await rm(cwd, { recursive: true, force: true });
+        }
+    });
     it('shutdownTeam ralph=false still throws on failed tasks (normal path unchanged)', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-ralph-normal-'));
         try {
@@ -1477,7 +1730,7 @@ esac
             const task = await createTask('team-delegation', { subject: 'x', description: 'd', status: 'pending', requires_code_change: false }, cwd);
             const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-delegation', 'manifest.v2.json');
             const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-            manifest.policy.delegation_only = true;
+            manifest.governance = { ...(manifest.governance || {}), delegation_only: true };
             await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
             await assert.rejects(() => assignTask('team-delegation', 'leader-fixed', task.id, cwd), /delegation_only_violation/);
         }
@@ -1541,7 +1794,7 @@ esac
             const task = await createTask('team-approval', { subject: 'x', description: 'd', status: 'pending', requires_code_change: true }, cwd);
             const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-approval', 'manifest.v2.json');
             const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
-            manifest.policy.plan_approval_required = true;
+            manifest.governance = { ...(manifest.governance || {}), plan_approval_required: true };
             await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
             await assert.rejects(() => assignTask('team-approval', 'worker-1', task.id, cwd), /plan_approval_required/);
         }
@@ -1696,6 +1949,56 @@ esac
             await rm(cwd, { recursive: true, force: true });
         }
     });
+    it('sendWorkerMessage hook-preferred path injects leader mailbox read guidance when leader pane exists', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-leader-inject-'));
+        const fakeBinDir = await mkdtemp(join(tmpdir(), 'omx-runtime-leader-inject-bin-'));
+        const tmuxLogPath = join(fakeBinDir, 'tmux.log');
+        const tmuxStubPath = join(fakeBinDir, 'tmux');
+        const previousPath = process.env.PATH;
+        try {
+            await writeFile(tmuxStubPath, `#!/bin/sh
+set -eu
+printf '%s\n' "$*" >> "${tmuxLogPath}"
+case "\${1:-}" in
+  send-keys)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`);
+            await chmod(tmuxStubPath, 0o755);
+            process.env.PATH = `${fakeBinDir}:${previousPath ?? ''}`;
+            await initTeamState('team-leader-inject', 'leader injection test', 'executor', 1, cwd);
+            const cfg = await readTeamConfig('team-leader-inject', cwd);
+            assert.ok(cfg);
+            if (!cfg)
+                throw new Error('missing team config');
+            cfg.leader_pane_id = '%55';
+            await saveTeamConfig(cfg, cwd);
+            const manifestPath = join(cwd, '.omx', 'state', 'team', 'team-leader-inject', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.policy = { ...(manifest.policy || {}), dispatch_ack_timeout_ms: 100 };
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+            await sendWorkerMessage('team-leader-inject', 'worker-1', 'leader-fixed', 'hello leader', cwd);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys -t %55 -l -- Read \.omx\/state\/team\/team-leader-inject\/mailbox\/leader-fixed\.json; worker-1 sent a new message\. Reply with the next concrete step\./);
+            const mailbox = await listMailboxMessages('team-leader-inject', 'leader-fixed', cwd);
+            assert.ok(mailbox.some((m) => typeof m.notified_at === 'string' && m.notified_at.length > 0));
+            const requests = await listDispatchRequests('team-leader-inject', cwd, { kind: 'mailbox', to_worker: 'leader-fixed' });
+            const latest = requests[requests.length - 1];
+            assert.equal(latest?.status, 'notified');
+        }
+        finally {
+            if (typeof previousPath === 'string')
+                process.env.PATH = previousPath;
+            else
+                delete process.env.PATH;
+            await rm(cwd, { recursive: true, force: true });
+            await rm(fakeBinDir, { recursive: true, force: true });
+        }
+    });
     it('sendWorkerMessage hook-preferred path for leader waits for receipt then falls back to direct notify', async () => {
         const cwd = await mkdtemp(join(tmpdir(), 'omx-runtime-leader-hook-'));
         try {