oh-my-codex 0.16.4 → 0.17.1

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

@@ -17,6 +17,7 @@ import { shutdownTeam } from '../../team/runtime.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 { writePersistedTeamUltragoalContext } from '../../team/ultragoal-context.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;
@@ -263,7 +264,7 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('reuses the older same-signature approved team hint when the latest matching handoff is missing its baseline', async () => {
+    it('does not reuse an older approved team hint when the latest matching handoff is missing its baseline', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-lineage-missing-baseline-'));
         const previousCwd = process.cwd();
         const approvedTask = 'Execute approved Team lineage follow-up';
@@ -275,10 +276,10 @@ describe('parseTeamStartArgs', () => {
             await writeFile(join(plansDir, 'test-spec-alpha-team-lineage.md'), '# Test spec\n');
             await writeFile(join(plansDir, 'prd-zeta-team-lineage.md'), `# Approved plan\n\nLaunch via omx team 3:executor ${JSON.stringify(approvedTask)}\n`);
             const result = parseTeamStartArgs(['team']);
-            assert.equal(result.parsed.task, approvedTask);
+            assert.equal(result.parsed.task, 'team');
             assert.equal(result.parsed.workerCount, 3);
             assert.equal(result.parsed.agentType, 'executor');
-            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
             assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
@@ -286,7 +287,7 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('reuses the older ready Team handoff when the latest same-signature handoff is invalid', async () => {
+    it('does not reuse an older ready Team handoff when the latest same-signature handoff lacks a baseline', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-lineage-invalid-'));
         const previousCwd = process.cwd();
         const approvedTask = 'Execute approved Team invalid lineage follow-up';
@@ -313,21 +314,19 @@ describe('parseTeamStartArgs', () => {
                 '',
                 `Launch via ${approvedCommand}`,
             ].join('\n'));
-            await writeFile(join(plansDir, 'test-spec-zeta-team-lineage-invalid.md'), '# Test spec\n');
             const result = parseTeamStartArgs(['team']);
-            assert.equal(result.parsed.task, approvedTask);
+            assert.equal(result.parsed.task, 'team');
             assert.equal(result.parsed.workerCount, 3);
             assert.equal(result.parsed.agentType, 'executor');
-            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
-            assert.equal(result.parsed.approvedExecution?.command, approvedCommand);
-            assert.equal(sameFilePath(result.parsed.approvedExecution?.prd_path ?? '', alphaPrdPath), true);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+            assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
             process.chdir(previousCwd);
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('reuses the older ready Team handoff when the latest same-signature handoff is incomplete', async () => {
+    it('does not reuse an older ready Team handoff when the latest same-signature handoff is incomplete', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-lineage-incomplete-'));
         const previousCwd = process.cwd();
         const approvedTask = 'Execute approved Team incomplete lineage follow-up';
@@ -348,7 +347,6 @@ describe('parseTeamStartArgs', () => {
             await writeFile(alphaTestSpecPath, '# Test spec\n');
             await writeReadyContextPack(wd, 'alpha-team-lineage-complete', alphaPrdPath, alphaTestSpecPath);
             const zetaPrdPath = join(plansDir, 'prd-zeta-team-lineage-incomplete.md');
-            const zetaTestSpecPath = join(plansDir, 'test-spec-zeta-team-lineage-incomplete.md');
             await writeFile(zetaPrdPath, [
                 '# Approved plan',
                 '',
@@ -356,15 +354,12 @@ describe('parseTeamStartArgs', () => {
                 '',
                 `Launch via ${approvedCommand}`,
             ].join('\n'));
-            await writeFile(zetaTestSpecPath, '# Test spec\n');
-            await writeContextPack(wd, 'zeta-team-lineage-incomplete', zetaPrdPath, zetaTestSpecPath, ['scope']);
             const result = parseTeamStartArgs(['team']);
-            assert.equal(result.parsed.task, approvedTask);
+            assert.equal(result.parsed.task, 'team');
             assert.equal(result.parsed.workerCount, 3);
             assert.equal(result.parsed.agentType, 'executor');
-            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
-            assert.equal(result.parsed.approvedExecution?.command, approvedCommand);
-            assert.equal(sameFilePath(result.parsed.approvedExecution?.prd_path ?? '', alphaPrdPath), true);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+            assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
             process.chdir(previousCwd);
@@ -523,7 +518,7 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('keeps plan-only short follow-ups on the generic path even when a persisted approved binding exists', async () => {
+    it('carries plan-only short follow-ups when a persisted binding resolves to a baseline-ready hint', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-plan-only-'));
         const previousCwd = process.cwd();
         try {
@@ -545,14 +540,16 @@ describe('parseTeamStartArgs', () => {
             assert.equal(result.parsed.task, 'Execute approved issue 2085 plan');
             assert.equal(result.parsed.workerCount, 3);
             assert.equal(result.parsed.agentType, 'executor');
-            assert.equal(result.parsed.approvedExecution, undefined);
+            assert.equal(result.parsed.approvedExecution?.task, 'Execute approved issue 2085 plan');
+            assert.equal(result.parsed.approvedExecution?.command, command);
+            assert.equal(sameFilePath(result.parsed.approvedExecution?.prd_path ?? '', prdPath), true);
         }
         finally {
             process.chdir(previousCwd);
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('fails short follow-up reuse when the latest approved handoff is nonready', async () => {
+    it('keeps short follow-up generic when the latest approved handoff is non-baseline', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-nonready-'));
         const previousCwd = process.cwd();
         try {
@@ -568,15 +565,17 @@ describe('parseTeamStartArgs', () => {
                 '',
                 'Launch via omx team 3:executor "Execute approved issue 2086 plan"',
             ].join('\n'));
-            await writeFile(join(plansDir, 'test-spec-issue-2086.md'), '# Test spec\n');
-            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_hint_nonready:team:invalid/);
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'team');
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+            assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
             process.chdir(previousCwd);
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('fails short follow-up reuse when the latest approved handoff is missing its baseline', async () => {
+    it('keeps short follow-up generic when the latest approved handoff is missing its baseline', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-missing-baseline-'));
         const previousCwd = process.cwd();
         try {
@@ -584,14 +583,17 @@ describe('parseTeamStartArgs', () => {
             const plansDir = join(wd, '.omx', 'plans');
             await mkdir(plansDir, { recursive: true });
             await writeFile(join(plansDir, 'prd-issue-2086-missing-baseline.md'), '# Approved plan\n\nLaunch via omx team 3:executor "Execute approved issue 2086 missing-baseline plan"\n');
-            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_hint_nonready:team:missing-baseline/);
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'team');
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+            assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
             process.chdir(previousCwd);
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('fails short follow-up reuse when the latest approved handoff is incomplete', async () => {
+    it('keeps short follow-up generic when the latest approved handoff is incomplete and non-baseline', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-followup-incomplete-'));
         const previousCwd = process.cwd();
         try {
@@ -599,7 +601,6 @@ describe('parseTeamStartArgs', () => {
             const plansDir = join(wd, '.omx', 'plans');
             await mkdir(plansDir, { recursive: true });
             const prdPath = join(plansDir, 'prd-issue-2086-incomplete.md');
-            const testSpecPath = join(plansDir, 'test-spec-issue-2086-incomplete.md');
             await writeFile(prdPath, [
                 '# Approved plan',
                 '',
@@ -607,9 +608,10 @@ describe('parseTeamStartArgs', () => {
                 '',
                 'Launch via omx team 3:executor "Execute approved issue 2086 incomplete plan"',
             ].join('\n'));
-            await writeFile(testSpecPath, '# Test spec\n');
-            await writeContextPack(wd, 'issue-2086-incomplete', prdPath, testSpecPath, ['scope']);
-            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_hint_nonready:team:incomplete/);
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'team');
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+            assert.equal(result.parsed.approvedExecution, undefined);
         }
         finally {
             process.chdir(previousCwd);
@@ -981,10 +983,9 @@ describe('parseTeamStartArgs', () => {
             process.chdir(wd);
             await mkdir(join(wd, '.omx', 'plans'), { recursive: true });
             await writeFile(join(wd, '.omx', 'plans', 'prd-issue-2087.md'), '# Approved plan\n\nLaunch via omx team 3:executor "Execute approved issue 2087 plan"\n');
-            await writeFile(join(wd, '.omx', 'plans', 'test-spec-issue-2087.md'), '# Test spec\n');
-            await writeFile(join(wd, '.omx', 'plans', 'repo-context-issue-2087.md'), 'Do not widen plan-only context.\n');
+            await writeFile(join(wd, '.omx', 'plans', 'repo-context-issue-2087.md'), 'Do not widen non-baseline context.\n');
             const result = parseTeamStartArgs(['3:executor', 'Execute', 'approved', 'issue', '2087', 'plan']);
-            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
             assert.equal(result.parsed.approvedExecution, undefined);
             assert.equal(result.parsed.approvedRepositoryContextSummary, undefined);
         }
@@ -993,7 +994,7 @@ describe('parseTeamStartArgs', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
-    it('preserves lifecycle-specific DAG fallback reasons for explicit nonready approved launches', async () => {
+    it('uses generic DAG fallback reasons for explicit non-baseline approved launches', async () => {
         const previousCwd = process.cwd();
         const cases = [
             {
@@ -1002,25 +1003,23 @@ describe('parseTeamStartArgs', () => {
                 includeOutcome: false,
                 writeTestSpec: false,
                 packSetup: async (_wd, _prdPath, _testSpecPath) => { },
-                expected: 'context_pack_not_followup_ready:missing-baseline',
+                expected: 'dag_handoff_not_approved_for_invocation',
             },
             {
                 name: 'incomplete',
                 slug: 'issue-2090-incomplete',
                 includeOutcome: true,
-                writeTestSpec: true,
-                packSetup: async (wd, prdPath, testSpecPath) => {
-                    await writeContextPack(wd, 'issue-2090-incomplete', prdPath, testSpecPath, ['scope']);
-                },
-                expected: 'context_pack_not_followup_ready:incomplete',
+                writeTestSpec: false,
+                packSetup: async (_wd, _prdPath, _testSpecPath) => { },
+                expected: 'dag_handoff_not_approved_for_invocation',
             },
             {
                 name: 'invalid',
                 slug: 'issue-2090-invalid',
                 includeOutcome: true,
-                writeTestSpec: true,
+                writeTestSpec: false,
                 packSetup: async (_wd, _prdPath, _testSpecPath) => { },
-                expected: 'context_pack_not_followup_ready:invalid',
+                expected: 'dag_handoff_not_approved_for_invocation',
             },
         ];
         try {
@@ -1063,7 +1062,7 @@ describe('parseTeamStartArgs', () => {
                         approvedRepositoryContextSummary: parsed.parsed.approvedRepositoryContextSummary,
                     });
                     assert.equal(parsed.parsed.allowRepoAwareDagHandoff, false);
-                    assert.equal(parsed.parsed.dagFallbackReason, scenario.expected);
+                    assert.equal(parsed.parsed.dagFallbackReason, undefined);
                     assert.equal(parsed.parsed.approvedExecution, undefined);
                     assert.equal(executionPlan.metadata?.decomposition_source, 'legacy_text');
                     assert.equal(executionPlan.metadata?.fallback_reason, scenario.expected);
@@ -2291,6 +2290,131 @@ describe('teamCommand status', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('returns Ultragoal checkpoint guidance in JSON status only when approved Team context exists', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-status-ultragoal-json-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await withoutTeamTestWorkerEnv(() => initTeamState('ultragoal-json-team', 'inspect ultragoal guidance', 'executor', 1, wd));
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const prdPath = join(plansDir, 'prd-ultragoal-json.md');
+            const testSpecPath = join(plansDir, 'test-spec-ultragoal-json.md');
+            const task = 'Execute Team + Ultragoal G001-team-runtime-bridge plan';
+            await writeFile(prdPath, [
+                '# Ultragoal JSON status',
+                '',
+                'Active ultragoal story G001-team-runtime-bridge uses .omx/ultragoal/goals.json and .omx/ultragoal/ledger.jsonl.',
+                `Launch via omx team 1:executor "${task}"`,
+            ].join('\n'));
+            await writeFile(testSpecPath, '# Ultragoal JSON status test spec\n');
+            const hint = readApprovedExecutionLaunchHint(wd, 'team', { prdPath, task });
+            assert.ok(hint);
+            await writePersistedApprovedTeamExecutionBinding('ultragoal-json-team', wd, buildApprovedTeamExecutionBinding(hint));
+            await writePersistedTeamUltragoalContext('ultragoal-json-team', wd, {
+                kind: 'leader_owned_ultragoal_context',
+                goalsPath: '.omx/ultragoal/goals.json',
+                ledgerPath: '.omx/ultragoal/ledger.jsonl',
+                activeGoalId: 'G001-team-runtime-bridge',
+                codexGoalMode: 'aggregate',
+                checkpointPolicy: 'fresh_leader_get_goal_required',
+            });
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'ultragoal-json-team', '--json']));
+            const payload = JSON.parse(logs[0] ?? '{}');
+            assert.equal(payload.ultragoal_checkpoint_guidance?.goal_id, 'G001-team-runtime-bridge');
+            assert.equal(payload.ultragoal_checkpoint_guidance?.goals_path, '.omx/ultragoal/goals.json');
+            assert.equal(payload.ultragoal_checkpoint_guidance?.ledger_path, '.omx/ultragoal/ledger.jsonl');
+            assert.equal(payload.ultragoal_checkpoint_guidance?.checkpoint_policy, 'fresh_leader_get_goal_required');
+            assert.match(payload.ultragoal_checkpoint_guidance?.checkpoint_command_template ?? '', /omx ultragoal checkpoint/);
+            assert.match(payload.ultragoal_checkpoint_guidance?.checkpoint_command_template ?? '', /--codex-goal-json/);
+            assert.ok(payload.ultragoal_checkpoint_guidance?.evidence_requirements?.some((item) => item.includes('.omx/ultragoal artifacts')));
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('omits Ultragoal checkpoint guidance in JSON status for completed plans without activeGoalId', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-status-ultragoal-idle-json-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await withoutTeamTestWorkerEnv(() => initTeamState('ultragoal-idle-json-team', 'inspect idle ultragoal status', 'executor', 1, wd));
+            await mkdir(join(wd, '.omx', 'ultragoal'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'ultragoal', 'goals.json'), `${JSON.stringify({
+                version: 1,
+                codexGoalMode: 'aggregate',
+                goals: [{
+                        id: 'G001-completed-story',
+                        title: 'Completed story',
+                        status: 'complete',
+                    }],
+            })}\n`);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'ultragoal-idle-json-team', '--json']));
+            const payload = JSON.parse(logs[0] ?? '{}');
+            assert.equal(payload.status, 'ok');
+            assert.equal('ultragoal_checkpoint_guidance' in payload, false);
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('prints Ultragoal checkpoint guidance in text status with fresh get_goal requirement', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-team-status-ultragoal-text-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await withoutTeamTestWorkerEnv(() => initTeamState('ultragoal-text-team', 'inspect ultragoal text guidance', 'executor', 1, wd));
+            const plansDir = join(wd, '.omx', 'plans');
+            await mkdir(plansDir, { recursive: true });
+            const prdPath = join(plansDir, 'prd-ultragoal-text.md');
+            const testSpecPath = join(plansDir, 'test-spec-ultragoal-text.md');
+            const task = 'Execute Team + Ultragoal G001-team-runtime-bridge text plan';
+            await writeFile(prdPath, [
+                '# Ultragoal text status',
+                '',
+                'Team evidence checkpoints G001-team-runtime-bridge into .omx/ultragoal/goals.json and .omx/ultragoal/ledger.jsonl.',
+                `Launch via omx team 1:executor "${task}"`,
+            ].join('\n'));
+            await writeFile(testSpecPath, '# Ultragoal text status test spec\n');
+            const hint = readApprovedExecutionLaunchHint(wd, 'team', { prdPath, task });
+            assert.ok(hint);
+            await writePersistedApprovedTeamExecutionBinding('ultragoal-text-team', wd, buildApprovedTeamExecutionBinding(hint));
+            await writePersistedTeamUltragoalContext('ultragoal-text-team', wd, {
+                kind: 'leader_owned_ultragoal_context',
+                goalsPath: '.omx/ultragoal/goals.json',
+                ledgerPath: '.omx/ultragoal/ledger.jsonl',
+                activeGoalId: 'G001-team-runtime-bridge',
+                codexGoalMode: 'aggregate',
+                checkpointPolicy: 'fresh_leader_get_goal_required',
+            });
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'ultragoal-text-team']));
+            const output = logs.join('\n');
+            assert.match(output, /ultragoal_checkpoint_guidance/);
+            assert.match(output, /G001-team-runtime-bridge/);
+            assert.match(output, /\.omx\/ultragoal\/goals\.json/);
+            assert.match(output, /\.omx\/ultragoal\/ledger\.jsonl/);
+            assert.match(output, /leader captured fresh get_goal JSON before checkpointing/i);
+            assert.match(output, /workers do not own ultragoal goal state/i);
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('returns a missing envelope in JSON mode when team state is absent', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-team-status-missing-'));
         const previousCwd = process.cwd();