oh-my-codex 0.15.2 → 0.16.0

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

@@ -9,12 +9,20 @@ import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { buildLeaderMonitoringHints, parseTeamStartArgs, teamCommand } from '../team.js';
 import { readModeState } from '../../modes/base.js';
+import { readApprovedExecutionLaunchHint } from '../../planning/artifacts.js';
 import { DEFAULT_MAX_WORKERS } from '../../team/state.js';
+import { sameFilePath } from '../../utils/paths.js';
 import { appendTeamEvent, createTask, initTeamState, readTeamConfig, saveTeamConfig, updateWorkerHeartbeat, writeMonitorSnapshot, writeTaskApproval, writeWorkerStatus, } from '../../team/state.js';
+import { buildApprovedTeamExecutionBinding, writePersistedApprovedTeamExecutionBinding, } from '../../team/approved-execution.js';
 import { isRealTmuxAvailable, withTempTmuxSession } from '../../team/__tests__/tmux-test-fixture.js';
 const OMX_CLI_PATH = fileURLToPath(new URL('../omx.js', import.meta.url));
 const ORIGINAL_OMX_TEAM_WORKER = process.env.OMX_TEAM_WORKER;
 const ORIGINAL_OMX_TEAM_STATE_ROOT = process.env.OMX_TEAM_STATE_ROOT;
+function encodeApprovedExecutionTask(task, quote) {
+    return quote === 'single'
+        ? `'${task.replace(/'/g, "\\'")}'`
+        : `"${task.replace(/"/g, '\\"')}"`;
+}
 beforeEach(() => {
     delete process.env.OMX_TEAM_WORKER;
     delete process.env.OMX_TEAM_STATE_ROOT;
@@ -210,6 +218,205 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('prefers the persisted approved binding over a newer latest approved hint for a short follow-up', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-bound-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const boundPrdPath = join(plansDir, 'prd-20260501T010203Z-issue-831.md');
+            await writeFile(boundPrdPath, '# Approved plan\n\nLaunch via omx team 2:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(plansDir, 'test-spec-20260501T010203Z-issue-831.md'), '# Test spec\n');
+            await writeFile(join(plansDir, 'prd-20260502T010203Z-issue-999.md'), '# Approved plan\n\nLaunch via omx team 5:debugger "Execute newer approved issue 999 plan"\n');
+            await writeFile(join(plansDir, 'test-spec-20260502T010203Z-issue-999.md'), '# Test spec\n');
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'team-state.json'), JSON.stringify({ active: true, team_name: 'bound-team' }, null, 2));
+            await writePersistedApprovedTeamExecutionBinding('bound-team', wd, {
+                prd_path: boundPrdPath,
+                task: 'Execute approved issue 831 plan',
+                command: 'omx team 2:executor "Execute approved issue 831 plan"',
+            });
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'Execute approved issue 831 plan');
+            assert.equal(result.parsed.workerCount, 2);
+            assert.equal(result.parsed.agentType, 'executor');
+            assert.equal(result.parsed.approvedExecution?.task, 'Execute approved issue 831 plan');
+            assert.equal(result.parsed.approvedExecution?.command, 'omx team 2:executor "Execute approved issue 831 plan"');
+            assert.equal(sameFilePath(result.parsed.approvedExecution?.prd_path ?? '', boundPrdPath), true);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('round-trips single-quoted approved follow-ups from launch hint encoding through persisted binding', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-bound-quoted-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const boundTask = "Fix Bob's regression in C:\\\\tmp";
+            const boundCommand = `omx team 2:executor ${encodeApprovedExecutionTask(boundTask, 'single')}`;
+            const boundPrdPath = join(plansDir, 'prd-issue-831-quoted.md');
+            await writeFile(boundPrdPath, `# Approved plan\n\nLaunch via ${boundCommand}\n`);
+            await writeFile(join(plansDir, 'test-spec-issue-831-quoted.md'), '# Test spec\n');
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'team-state.json'), JSON.stringify({ active: true, team_name: 'bound-team-quoted' }, null, 2));
+            const approvedHint = readApprovedExecutionLaunchHint(wd, 'team');
+            assert.ok(approvedHint);
+            assert.equal(approvedHint?.task, boundTask);
+            assert.equal(approvedHint?.command, boundCommand);
+            await writePersistedApprovedTeamExecutionBinding('bound-team-quoted', wd, buildApprovedTeamExecutionBinding(approvedHint));
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, boundTask);
+            assert.equal(result.parsed.workerCount, 2);
+            assert.equal(result.parsed.agentType, 'executor');
+            assert.equal(result.parsed.approvedExecution?.task, boundTask);
+            assert.equal(result.parsed.approvedExecution?.command, boundCommand);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('round-trips double-quoted approved follow-ups from launch hint encoding through persisted binding', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-bound-double-quoted-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const boundTask = String.raw `Use C:\tmp and keep \n literal plus "quotes"`;
+            const boundCommand = `omx team 2:executor ${encodeApprovedExecutionTask(boundTask, 'double')}`;
+            const boundPrdPath = join(plansDir, 'prd-issue-831-double-quoted.md');
+            await writeFile(boundPrdPath, `# Approved plan\n\nLaunch via ${boundCommand}\n`);
+            await writeFile(join(plansDir, 'test-spec-issue-831-double-quoted.md'), '# Test spec\n');
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'team-state.json'), JSON.stringify({ active: true, team_name: 'bound-team-double-quoted' }, null, 2));
+            const approvedHint = readApprovedExecutionLaunchHint(wd, 'team');
+            assert.ok(approvedHint);
+            assert.equal(approvedHint?.task, boundTask);
+            assert.equal(approvedHint?.command, boundCommand);
+            await writePersistedApprovedTeamExecutionBinding('bound-team-double-quoted', wd, buildApprovedTeamExecutionBinding(approvedHint));
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, boundTask);
+            assert.equal(result.parsed.workerCount, 2);
+            assert.equal(result.parsed.agentType, 'executor');
+            assert.equal(result.parsed.approvedExecution?.task, boundTask);
+            assert.equal(result.parsed.approvedExecution?.command, boundCommand);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('reuses the persisted approved binding from session-scoped team state for a short follow-up', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-bound-session-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const sessionId = 'sess-team-followup-bound';
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const prdPath = join(plansDir, 'prd-issue-954.md');
+            await writeFile(prdPath, '# Approved plan\n\nLaunch via omx team 5:executor "Execute approved session-scoped plan"\n');
+            await writeFile(join(plansDir, 'test-spec-issue-954.md'), '# Test spec\n');
+            await mkdir(join(wd, '.omx', 'state', 'sessions', sessionId), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(wd, '.omx', 'state', 'sessions', sessionId, 'team-state.json'), JSON.stringify({
+                active: true,
+                team_name: 'bound-team-session',
+                task_description: 'Execute approved session-scoped plan',
+                agent_count: 5,
+            }, null, 2));
+            await writePersistedApprovedTeamExecutionBinding('bound-team-session', wd, {
+                prd_path: prdPath,
+                task: 'Execute approved session-scoped plan',
+                command: 'omx team 5:executor "Execute approved session-scoped plan"',
+            });
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'Execute approved session-scoped plan');
+            assert.equal(result.parsed.workerCount, 5);
+            assert.equal(result.parsed.agentType, 'executor');
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed for a short follow-up when the persisted approved binding is malformed', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-malformed-binding-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const plansDir = join(wd, '.omx', 'plans');
+            const stateDir = join(wd, '.omx', 'state');
+            await mkdir(plansDir, { recursive: true });
+            await mkdir(join(stateDir, 'team', 'broken-team'), { recursive: true });
+            await writeFile(join(plansDir, 'prd-issue-831.md'), '# Approved plan\n\nLaunch via omx team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(plansDir, 'test-spec-issue-831.md'), '# Test spec\n');
+            await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({ active: true, team_name: 'broken-team' }, null, 2));
+            await writeFile(join(stateDir, 'team', 'broken-team', 'approved-execution.json'), '{"prd_path":42}', 'utf-8');
+            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_binding_malformed:broken-team/);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed for a short follow-up when the persisted approved binding is stale even if a newer PRD is ready', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-bound-stale-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const stalePrdPath = join(plansDir, 'prd-issue-955-alpha.md');
+            await writeFile(stalePrdPath, '# Approved plan\n\nLaunch via omx team 4:executor "Execute approved alpha plan"\n');
+            await writeFile(join(plansDir, 'test-spec-issue-955-alpha.md'), '# Test spec\n');
+            await writeFile(join(plansDir, 'prd-issue-955-zeta.md'), '# Approved plan\n\nLaunch via omx team 6:debugger "Execute approved zeta plan"\n');
+            await writeFile(join(plansDir, 'test-spec-issue-955-zeta.md'), '# Test spec\n');
+            await rm(stalePrdPath, { force: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'team-state.json'), JSON.stringify({
+                active: true,
+                team_name: 'bound-team-stale',
+                task_description: 'Execute approved alpha plan',
+                agent_count: 4,
+            }, null, 2));
+            await writePersistedApprovedTeamExecutionBinding('bound-team-stale', wd, {
+                prd_path: stalePrdPath,
+                task: 'Execute approved alpha plan',
+            });
+            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_binding_stale:.*Execute approved alpha plan/);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed for a short team follow-up when the selected PRD lists multiple team launch hints', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-ambiguous-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.omx', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'plans', 'prd-issue-831-ambiguous.md'), [
+                '# Approved plan',
+                '',
+                'Launch via omx team 3:executor "Execute approved issue 831 plan"',
+                'Launch via omx team 5:debugger "Execute alternate issue 831 plan"',
+            ].join('\n'));
+            await writeFile(join(wd, '.omx', 'plans', 'test-spec-issue-831-ambiguous.md'), '# Test spec\n');
+            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_hint_ambiguous:team/);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('does not opt normal team startup into repo-aware DAG handoff even when a stale sidecar exists', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-dag-normal-'));
         const previousCwd = process.cwd();
@@ -244,6 +451,25 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('attaches approved repository context summary only for matching team launches', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-context-approved-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.omx', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'plans', 'prd-issue-2039.md'), '# Approved plan\n\nLaunch via omx team 3:executor "Execute approved issue 2039 plan"\n');
+            await writeFile(join(wd, '.omx', 'plans', 'test-spec-issue-2039.md'), '# Test spec\n');
+            await writeFile(join(wd, '.omx', 'plans', 'repo-context-issue-2039.md'), 'Key boundary: latest approved handoff only.\n');
+            const approved = parseTeamStartArgs(['3:executor', 'Execute', 'approved', 'issue', '2039', 'plan']);
+            assert.equal(approved.parsed.approvedRepositoryContextSummary?.content, 'Key boundary: latest approved handoff only.');
+            const unrelated = parseTeamStartArgs(['3:executor', 'fix', 'unrelated', 'bug']);
+            assert.equal(unrelated.parsed.approvedRepositoryContextSummary, undefined);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('preserves explicit team staffing overrides while reusing the approved plan task', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-override-'));
         const previousCwd = process.cwd();
@@ -1590,7 +1816,7 @@ describe('teamCommand await', () => {
         const teamName = parseTeamStartArgs(['1:executor', teamTask]).parsed.teamName;
         await mkdir(binDir, { recursive: true });
         await writeFile(fakeCodexPath, `#!/usr/bin/env node
-setTimeout(() => process.exit(0), 150);
+setTimeout(() => process.exit(0), 0);
 process.stdin.resume();
 process.on('SIGTERM', () => process.exit(0));
 `);
@@ -1607,11 +1833,13 @@ process.on('SIGTERM', () => process.exit(0));
                 return true;
             });
             await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
+            const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
             let statusOutput = '';
             for (let attempt = 0; attempt < 50; attempt += 1) {
                 logs.length = 0;
                 stderr.length = 0;
-                await withoutTeamTestWorkerEnv(() => teamCommand(['status', teamName]));
+                await withoutTeamTestWorkerEnv(() => teamCommand(['status', runtimeTeamName]));
                 statusOutput = logs.join('\n');
                 if (/phase=failed/.test(statusOutput))
                     break;
@@ -1620,9 +1848,9 @@ process.on('SIGTERM', () => process.exit(0));
             assert.match(statusOutput, /phase=failed/);
             assert.doesNotMatch(stderr.join('\n'), /ESRCH/);
             logs.length = 0;
-            await withoutTeamTestWorkerEnv(() => teamCommand(['await', teamName, '--json', '--timeout-ms', '250']));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['await', runtimeTeamName, '--json', '--timeout-ms', '250']));
             const payload = JSON.parse(logs.at(-1) ?? '{}');
-            assert.equal(payload.team_name, teamName);
+            assert.equal(payload.team_name, runtimeTeamName);
             assert.equal(payload.status, 'event');
             assert.equal(payload.event?.type, 'worker_stopped');
             assert.equal(payload.event?.worker, 'worker-1');
@@ -1676,15 +1904,17 @@ process.on('SIGTERM', () => process.exit(0));
             process.env.OMX_TEAM_WORKER_CLI = 'codex';
             await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
             const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
             assert.equal(startedState?.active, true);
-            assert.equal(startedState?.team_name, teamName);
+            assert.equal(startedState?.team_name, runtimeTeamName);
+            assert.equal(startedState?.display_name, teamName);
             assert.equal(startedState?.current_phase, 'team-exec');
             await rm(join(wd, '.omx', 'state', 'team-state.json'), { force: true });
             assert.equal(await readModeState('team', wd), null);
-            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', teamName]));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', runtimeTeamName]));
             const resumedState = await readModeState('team', wd);
             assert.equal(resumedState?.active, true);
-            assert.equal(resumedState?.team_name, teamName);
+            assert.equal(resumedState?.team_name, runtimeTeamName);
             assert.equal(resumedState?.current_phase, 'team-exec');
         }
         finally {
@@ -1733,7 +1963,9 @@ process.on('SIGTERM', () => process.exit(0));
             process.env.OMX_TEAM_WORKER_LAUNCH_MODE = 'prompt';
             process.env.OMX_TEAM_WORKER_CLI = 'codex';
             await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
-            await writeFile(join(wd, '.omx', 'state', 'team', teamName, 'phase.json'), JSON.stringify({
+            const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
+            await writeFile(join(wd, '.omx', 'state', 'team', runtimeTeamName, 'phase.json'), JSON.stringify({
                 current_phase: 'complete',
                 max_fix_attempts: 3,
                 current_fix_attempt: 0,
@@ -1741,10 +1973,10 @@ process.on('SIGTERM', () => process.exit(0));
                 updated_at: new Date().toISOString(),
             }, null, 2));
             await rm(join(wd, '.omx', 'state', 'team-state.json'), { force: true });
-            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', teamName]));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', runtimeTeamName]));
             const resumedState = await readModeState('team', wd);
             assert.equal(resumedState?.active, false);
-            assert.equal(resumedState?.team_name, teamName);
+            assert.equal(resumedState?.team_name, runtimeTeamName);
             assert.equal(resumedState?.current_phase, 'complete');
         }
         finally {