oh-my-codex 0.11.13 → 0.12.1

package/dist/team/__tests__/api-interop.test.js

@@ -1,10 +1,10 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, rm, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { chmod, mkdtemp, rm, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { resolveTeamApiOperation, buildLegacyTeamDeprecationHint, executeTeamApiOperation, LEGACY_TEAM_MCP_TOOLS, TEAM_API_OPERATIONS, } from '../api-interop.js';
-import { initTeamState, createTask, readTask, sendDirectMessage, enqueueDispatchRequest, readDispatchRequest, listDispatchRequests, appendTeamEvent, updateWorkerHeartbeat, writeMonitorSnapshot, writeWorkerStatus, } from '../state.js';
+import { initTeamState, createTask, readTeamLeaderAttention, readTeamManifestV2, readTask, writeTeamLeaderAttention, writeTeamManifestV2, writeTeamPhase, sendDirectMessage, enqueueDispatchRequest, readDispatchRequest, listDispatchRequests, appendTeamEvent, markOwnedTeamsLeaderStopObserved, markOwnedTeamsLeaderSessionStopped, updateWorkerHeartbeat, writeMonitorSnapshot, writeWorkerStatus, } from '../state.js';
 async function setupTeam(name) {
     const cwd = await mkdtemp(join(tmpdir(), `omx-interop-${name}-`));
     const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
@@ -21,6 +21,76 @@ async function setupTeam(name) {
         },
     };
 }
+async function withMailboxCompatHoleRuntime(cwd, fn) {
+    const fakeBin = join(cwd, 'runtime-bin');
+    const runtimePath = join(fakeBin, 'omx-runtime');
+    const previousPath = process.env.PATH;
+    const previousBinary = process.env.OMX_RUNTIME_BINARY;
+    const previousBridge = process.env.OMX_RUNTIME_BRIDGE;
+    await mkdir(fakeBin, { recursive: true });
+    await writeFile(runtimePath, `#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const argv = process.argv.slice(2);
+function argValue(prefix) {
+  const entry = argv.find((value) => value.startsWith(prefix));
+  return entry ? entry.slice(prefix.length) : null;
+}
+function stateDir() {
+  return argValue('--state-dir=') || process.cwd();
+}
+function readJson(file, fallback) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\\n');
+}
+if (argv[0] === 'schema') {
+  process.stdout.write(JSON.stringify({ schema_version: 1, commands: [], events: [], transport: 'tmux' }) + '\\n');
+  process.exit(0);
+}
+if (argv[0] !== 'exec') process.exit(1);
+const command = JSON.parse(argv[1] || '{}');
+const dir = stateDir();
+if (command.command === 'CreateMailboxMessage') {
+  writeJson(path.join(dir, 'mailbox.json'), readJson(path.join(dir, 'mailbox.json'), { records: [] }));
+  process.stdout.write(JSON.stringify({ event: 'MailboxMessageCreated', message_id: command.message_id, from_worker: command.from_worker, to_worker: command.to_worker }) + '\\n');
+  process.exit(0);
+}
+process.stdout.write(JSON.stringify({ event: 'ok' }) + '\\n');
+`, 'utf8');
+    await chmod(runtimePath, 0o755);
+    process.env.PATH = `${fakeBin}:${previousPath || ''}`;
+    process.env.OMX_RUNTIME_BINARY = runtimePath;
+    process.env.OMX_RUNTIME_BRIDGE = '1';
+    try {
+        return await fn();
+    }
+    finally {
+        if (typeof previousPath === 'string')
+            process.env.PATH = previousPath;
+        else
+            delete process.env.PATH;
+        if (typeof previousBinary === 'string')
+            process.env.OMX_RUNTIME_BINARY = previousBinary;
+        else
+            delete process.env.OMX_RUNTIME_BINARY;
+        if (typeof previousBridge === 'string')
+            process.env.OMX_RUNTIME_BRIDGE = previousBridge;
+        else
+            delete process.env.OMX_RUNTIME_BRIDGE;
+    }
+}
+async function readTeamDeliveryLog(cwd) {
+    const path = join(cwd, '.omx', 'logs', `team-delivery-${new Date().toISOString().slice(0, 10)}.jsonl`);
+    const raw = await readFile(path, 'utf-8').catch(() => '');
+    return raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
 // ─── resolveTeamApiOperation ──────────────────────────────────────────────
 describe('resolveTeamApiOperation', () => {
     it('resolves a valid kebab-case operation', () => {
@@ -149,6 +219,15 @@ describe('executeTeamApiOperation: send-message', () => {
             const mailboxRequest = parsedRequests.find((request) => request.message_id === messageId);
             assert.ok(mailboxRequest, 'send-message should enqueue a mailbox dispatch request');
             assert.equal(mailboxRequest?.to_worker, 'worker-2');
+            const deliveryLog = await readTeamDeliveryLog(cwd);
+            assert.ok(deliveryLog.some((entry) => entry.event === 'mailbox_created'
+                && entry.message_id === messageId
+                && entry.from_worker === 'worker-1'
+                && entry.to_worker === 'worker-2'));
+            assert.ok(deliveryLog.some((entry) => entry.event === 'dispatch_attempted'
+                && entry.request_id === mailboxRequest?.request_id
+                && entry.message_id === messageId
+                && entry.to_worker === 'worker-2'));
         }
         finally {
             await cleanup();
@@ -197,6 +276,15 @@ describe('executeTeamApiOperation: send-message', () => {
             const mailbox = JSON.parse(await readFile(join(repoCwd, '.omx', 'state', 'team', teamName, 'mailbox', 'leader-fixed.json'), 'utf-8'));
             const workerMessages = (mailbox.messages ?? []).filter((message) => message.from_worker === 'worker-1' && message.to_worker === 'leader-fixed');
             assert.equal(workerMessages.length, 1, 'deduped leader sends should not append duplicate worker mailbox rows');
+            const deliveryLog = [
+                ...(await readTeamDeliveryLog(repoCwd)),
+                ...(await readTeamDeliveryLog(workerCwd)),
+            ];
+            const createdEvents = deliveryLog.filter((entry) => entry.event === 'mailbox_created'
+                && entry.from_worker === 'worker-1'
+                && entry.to_worker === 'leader-fixed'
+                && entry.message_id === firstMessage.message_id);
+            assert.equal(createdEvents.length, 1, 'deduped leader sends should only emit one mailbox_created event');
         }
         finally {
             if (typeof prevTeamStateRoot === 'string')
@@ -207,6 +295,43 @@ describe('executeTeamApiOperation: send-message', () => {
             await rm(workerCwd, { recursive: true, force: true });
         }
     });
+    it('returns the persisted mailbox message when bridge compat omits the mailbox row under an explicit shared state root', async () => {
+        const teamName = 'msg-team-shared-root';
+        const root = await mkdtemp(join(tmpdir(), 'omx-interop-shared-root-'));
+        const leaderCwd = join(root, 'leader');
+        const workerCwd = join(root, 'worker-worktree');
+        const sharedStateRoot = join(root, 'shared-state');
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            await mkdir(leaderCwd, { recursive: true });
+            await mkdir(workerCwd, { recursive: true });
+            process.env.OMX_TEAM_STATE_ROOT = sharedStateRoot;
+            await initTeamState(teamName, 'shared state root mailbox fallback', 'executor', 2, leaderCwd);
+            await withMailboxCompatHoleRuntime(root, async () => {
+                const result = await executeTeamApiOperation('send-message', {
+                    team_name: teamName,
+                    from_worker: 'worker-1',
+                    to_worker: 'leader-fixed',
+                    body: 'shared-root hello',
+                }, workerCwd);
+                assert.equal(result.ok, true);
+                if (!result.ok)
+                    throw new Error('expected send-message call to succeed');
+                const message = result.data.message;
+                assert.equal(message.body, 'shared-root hello');
+                assert.equal(message.to_worker, 'leader-fixed');
+                const mailbox = JSON.parse(await readFile(join(sharedStateRoot, 'team', teamName, 'mailbox', 'leader-fixed.json'), 'utf8'));
+                assert.equal(mailbox.messages?.length, 1);
+            });
+        }
+        finally {
+            if (typeof prevTeamStateRoot === 'string')
+                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(root, { recursive: true, force: true });
+        }
+    });
     it('returns error when from_worker missing', async () => {
         const result = await executeTeamApiOperation('send-message', {
             team_name: 'any', to_worker: 'w2', body: 'hi',
@@ -318,11 +443,70 @@ describe('executeTeamApiOperation: mailbox-mark-delivered', () => {
             assert.equal(result.data.dispatch_updated, true);
             const updatedDispatch = await readDispatchRequest('mark-dlv', dispatch.request.request_id, cwd);
             assert.equal(updatedDispatch?.status, 'delivered');
+            const deliveryLog = await readTeamDeliveryLog(cwd);
+            assert.ok(deliveryLog.some((entry) => entry.event === 'delivered'
+                && entry.message_id === msgId
+                && entry.to_worker === 'worker-2'));
+            assert.ok(deliveryLog.some((entry) => entry.event === 'mark_delivered'
+                && entry.message_id === msgId
+                && entry.request_id === dispatch.request.request_id
+                && entry.dispatch_updated === true));
         }
         finally {
             await cleanup();
         }
     });
+    it('marks leader-fixed mailbox delivery from a worker worktree and resolves the matching dispatch receipt', async () => {
+        const teamName = 'mark-dlv-leader-worktree';
+        const repoCwd = await mkdtemp(join(tmpdir(), 'omx-interop-mark-dlv-root-'));
+        const workerCwd = await mkdtemp(join(tmpdir(), 'omx-interop-mark-dlv-worktree-'));
+        const prevTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
+        delete process.env.OMX_TEAM_STATE_ROOT;
+        try {
+            await initTeamState(teamName, 'leader mailbox delivery receipt', 'executor', 2, repoCwd);
+            process.env.OMX_TEAM_STATE_ROOT = join(repoCwd, '.omx', 'state');
+            const sendResult = await executeTeamApiOperation('send-message', {
+                team_name: teamName,
+                from_worker: 'worker-1',
+                to_worker: 'leader-fixed',
+                body: 'DONE: worker-1 finished a mailbox integrity probe',
+            }, workerCwd);
+            assert.equal(sendResult.ok, true);
+            if (!sendResult.ok)
+                throw new Error('expected successful leader send-message result');
+            const message = sendResult.data.message;
+            const messageId = String(message.message_id ?? '');
+            assert.ok(messageId, 'leader mailbox message should include a message_id');
+            const pendingRequests = await listDispatchRequests(teamName, repoCwd, { kind: 'mailbox', to_worker: 'leader-fixed' });
+            const pendingDispatch = pendingRequests.find((request) => request.message_id === messageId);
+            assert.ok(pendingDispatch, 'leader mailbox send should enqueue a matching dispatch request');
+            const result = await executeTeamApiOperation('mailbox-mark-delivered', {
+                team_name: teamName,
+                worker: 'leader-fixed',
+                message_id: messageId,
+            }, workerCwd);
+            assert.equal(result.ok, true);
+            if (!result.ok)
+                throw new Error('expected successful leader mailbox-mark-delivered result');
+            assert.equal(result.data.updated, true);
+            assert.equal(result.data.dispatch_request_id, pendingDispatch?.request_id);
+            assert.equal(result.data.dispatch_updated, true);
+            const updatedDispatch = await readDispatchRequest(teamName, pendingDispatch.request_id, repoCwd);
+            assert.equal(updatedDispatch?.status, 'delivered');
+            assert.ok(updatedDispatch?.delivered_at, 'leader dispatch receipt should record delivered_at');
+            const leaderMailbox = JSON.parse(await readFile(join(repoCwd, '.omx', 'state', 'team', teamName, 'mailbox', 'leader-fixed.json'), 'utf-8'));
+            const deliveredMessage = (leaderMailbox.messages ?? []).find((entry) => entry.message_id === messageId);
+            assert.equal(typeof deliveredMessage?.delivered_at, 'string');
+        }
+        finally {
+            if (typeof prevTeamStateRoot === 'string')
+                process.env.OMX_TEAM_STATE_ROOT = prevTeamStateRoot;
+            else
+                delete process.env.OMX_TEAM_STATE_ROOT;
+            await rm(repoCwd, { recursive: true, force: true });
+            await rm(workerCwd, { recursive: true, force: true });
+        }
+    });
     it('reports when no matching mailbox dispatch request exists', async () => {
         const { cwd, cleanup } = await setupTeam('mark-dlv-no-dispatch');
         try {
@@ -1208,7 +1392,7 @@ describe('executeTeamApiOperation: read-idle-state', () => {
 });
 // ─── read-stall-state ───────────────────────────────────────────────────────
 describe('executeTeamApiOperation: read-stall-state', () => {
-    it('returns structured stall state from summary, snapshot, and recent events', async () => {
+    it('returns structured stall state from authoritative leader attention state', async () => {
         const { cwd, cleanup } = await setupTeam('stall-state-team');
         try {
             const task = await createTask('stall-state-team', {
@@ -1256,15 +1440,21 @@ describe('executeTeamApiOperation: read-stall-state', () => {
                 mailboxNotifiedByMessageId: {},
                 completedEventTaskIds: {},
             }, cwd);
-            const idleEvent = await appendTeamEvent('stall-state-team', {
-                type: 'all_workers_idle',
-                worker: 'worker-2',
-                worker_count: 2,
-            }, cwd);
-            const nudgeEvent = await appendTeamEvent('stall-state-team', {
-                type: 'team_leader_nudge',
-                worker: 'leader-fixed',
-                reason: 'all_workers_idle',
+            await writeTeamLeaderAttention('stall-state-team', {
+                team_name: 'stall-state-team',
+                updated_at: '2026-03-10T10:05:00.000Z',
+                source: 'native_stop',
+                leader_decision_state: 'still_actionable',
+                leader_attention_pending: true,
+                leader_attention_reason: 'leader_session_stopped',
+                attention_reasons: ['leader_session_stopped'],
+                leader_stale: false,
+                leader_session_active: false,
+                leader_session_id: 'leader-session-1',
+                leader_session_stopped_at: '2026-03-10T10:05:00.000Z',
+                unread_leader_message_count: 1,
+                work_remaining: true,
+                stalled_for_ms: null,
             }, cwd);
             const result = await executeTeamApiOperation('read-stall-state', {
                 team_name: 'stall-state-team',
@@ -1279,18 +1469,154 @@ describe('executeTeamApiOperation: read-stall-state', () => {
                 assert.equal(result.data.pending_task_count, 1);
                 assert.equal(result.data.all_workers_idle, true);
                 assert.match(result.data.reasons.join(' '), /workers_non_reporting:worker-1/);
-                assert.match(result.data.reasons.join(' '), /leader_attention_pending:team_leader_nudge/);
-                const lastAllIdle = result.data.last_all_workers_idle_event;
-                const lastNudge = result.data.last_team_leader_nudge_event;
-                assert.equal(lastAllIdle?.event_id, idleEvent.event_id);
-                assert.equal(lastNudge?.event_id, nudgeEvent.event_id);
-                assert.equal(lastNudge?.reason, 'all_workers_idle');
+                assert.match(result.data.reasons.join(' '), /leader_attention_pending:leader_session_stopped/);
+                const attention = result.data.leader_attention_state;
+                assert.equal(attention?.leader_session_active, false);
+                assert.equal(attention?.source, 'native_stop');
+            }
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it('uses unread leader mailbox state even without recent nudge events', async () => {
+        const { cwd, cleanup } = await setupTeam('stall-state-mailbox');
+        try {
+            await sendDirectMessage('stall-state-mailbox', 'worker-1', 'leader-fixed', 'please review', cwd);
+            const result = await executeTeamApiOperation('read-stall-state', {
+                team_name: 'stall-state-mailbox',
+            }, cwd);
+            assert.equal(result.ok, true);
+            if (result.ok) {
+                assert.equal(result.data.leader_attention_pending, true);
+                assert.equal(result.data.leader_stale, false);
+                assert.equal(result.data.unread_leader_message_count, 1);
+                assert.match(result.data.reasons.join(' '), /leader_attention_pending:unread_leader_mailbox/);
             }
         }
         finally {
             await cleanup();
         }
     });
+    it('suppresses stale native-stop attention after newer leader activity', async () => {
+        const { cwd, cleanup } = await setupTeam('stall-state-resume');
+        try {
+            await writeTeamLeaderAttention('stall-state-resume', {
+                team_name: 'stall-state-resume',
+                updated_at: '2026-03-10T10:05:00.000Z',
+                source: 'native_stop',
+                leader_decision_state: 'still_actionable',
+                leader_attention_pending: true,
+                leader_attention_reason: 'leader_session_stopped',
+                attention_reasons: ['leader_session_stopped'],
+                leader_stale: false,
+                leader_session_active: false,
+                leader_session_id: 'leader-session-1',
+                leader_session_stopped_at: '2026-03-10T10:05:00.000Z',
+                unread_leader_message_count: 0,
+                work_remaining: false,
+                stalled_for_ms: null,
+            }, cwd);
+            await writeFile(join(cwd, '.omx', 'state', 'leader-runtime-activity.json'), JSON.stringify({
+                last_activity_at: '2026-03-10T10:06:00.000Z',
+                last_source: 'team_status',
+                last_team_name: 'stall-state-resume',
+            }, null, 2));
+            const result = await executeTeamApiOperation('read-stall-state', {
+                team_name: 'stall-state-resume',
+            }, cwd);
+            assert.equal(result.ok, true);
+            if (result.ok) {
+                assert.equal(result.data.leader_attention_pending, false);
+                assert.equal(result.data.leader_stale, false);
+                assert.doesNotMatch(result.data.reasons.join(' '), /leader_attention_pending:leader_session_stopped/);
+            }
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it('marks only active leader-owned teams as stopped on session end', async () => {
+        const { cwd, cleanup } = await setupTeam('owned-team');
+        try {
+            await initTeamState('other-team', 'Other', 'executor', 1, cwd);
+            const ownedManifest = await readTeamManifestV2('owned-team', cwd);
+            const otherManifest = await readTeamManifestV2('other-team', cwd);
+            assert.ok(ownedManifest);
+            assert.ok(otherManifest);
+            await writeTeamManifestV2({
+                ...ownedManifest,
+                leader: {
+                    ...ownedManifest.leader,
+                    session_id: 'leader-session-1',
+                },
+            }, cwd);
+            await writeTeamManifestV2({
+                ...otherManifest,
+                leader: {
+                    ...otherManifest.leader,
+                    session_id: 'leader-session-2',
+                },
+            }, cwd);
+            await writeTeamLeaderAttention('owned-team', {
+                team_name: 'owned-team',
+                updated_at: '2026-03-10T10:12:00.000Z',
+                source: 'notify_hook',
+                leader_decision_state: 'still_actionable',
+                leader_attention_pending: true,
+                leader_attention_reason: 'stale_leader_with_messages',
+                attention_reasons: ['stale_leader_with_messages'],
+                leader_stale: true,
+                leader_session_active: true,
+                leader_session_id: 'leader-session-1',
+                leader_session_stopped_at: null,
+                unread_leader_message_count: 1,
+                work_remaining: true,
+                stalled_for_ms: null,
+            }, cwd);
+            await writeTeamPhase('other-team', {
+                current_phase: 'complete',
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: '2026-03-10T10:10:00.000Z',
+            }, cwd);
+            const updatedTeams = await markOwnedTeamsLeaderSessionStopped(cwd, 'leader-session-1', '2026-03-10T10:15:00.000Z');
+            assert.deepEqual(updatedTeams, ['owned-team']);
+            const ownedAttention = await readTeamLeaderAttention('owned-team', cwd);
+            const otherAttention = await readTeamLeaderAttention('other-team', cwd);
+            assert.equal(ownedAttention?.leader_session_active, false);
+            assert.equal(ownedAttention?.leader_attention_pending, true);
+            assert.equal(ownedAttention?.leader_attention_reason, 'stale_leader_with_messages');
+            assert.deepEqual(ownedAttention?.attention_reasons, ['stale_leader_with_messages', 'leader_session_stopped']);
+            assert.equal(otherAttention, null);
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it('marks only active leader-owned teams from the native stop hook', async () => {
+        const { cwd, cleanup } = await setupTeam('owned-stop-team');
+        try {
+            const ownedManifest = await readTeamManifestV2('owned-stop-team', cwd);
+            assert.ok(ownedManifest);
+            await writeTeamManifestV2({
+                ...ownedManifest,
+                leader: {
+                    ...ownedManifest.leader,
+                    session_id: 'leader-session-stop',
+                },
+            }, cwd);
+            const updatedTeams = await markOwnedTeamsLeaderStopObserved(cwd, 'leader-session-stop', '2026-03-10T10:15:00.000Z');
+            assert.deepEqual(updatedTeams, ['owned-stop-team']);
+            const ownedAttention = await readTeamLeaderAttention('owned-stop-team', cwd);
+            assert.equal(ownedAttention?.source, 'native_stop');
+            assert.equal(ownedAttention?.leader_session_active, false);
+        }
+        finally {
+            await cleanup();
+        }
+    });
 });
 // ─── get-summary ──────────────────────────────────────────────────────────
 describe('executeTeamApiOperation: get-summary', () => {