oh-my-codex 0.11.13 → 0.12.0

package/dist/hooks/__tests__/debugger-log-recency-contract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debugger-log-recency-contract.test.d.ts.map

package/dist/hooks/__tests__/debugger-log-recency-contract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugger-log-recency-contract.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/__tests__/debugger-log-recency-contract.test.ts"],"names":[],"mappings":""}

package/dist/hooks/__tests__/debugger-log-recency-contract.test.js

@@ -0,0 +1,20 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { loadSurface } from './prompt-guidance-test-helpers.js';
+describe('debugger log recency guidance contract', () => {
+    it('root guidance prioritizes newer same-thread evidence over stale context', () => {
+        for (const surface of ['AGENTS.md', 'templates/AGENTS.md']) {
+            const content = loadSurface(surface);
+            assert.match(content, /newer same-thread evidence/i);
+            assert.match(content, /current source of truth/i);
+            assert.match(content, /do not anchor on older evidence unless the user reaffirms it/i);
+        }
+    });
+    it('debugger guidance prioritizes the latest logs in the current turn', () => {
+        const content = loadSurface('prompts/debugger.md');
+        assert.match(content, /newly provided logs, stack traces, and diagnostics in the current turn/i);
+        assert.match(content, /primary evidence/i);
+        assert.match(content, /instead of anchoring on older logs/i);
+    });
+});
+//# sourceMappingURL=debugger-log-recency-contract.test.js.map

package/dist/hooks/__tests__/debugger-log-recency-contract.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugger-log-recency-contract.test.js","sourceRoot":"","sources":["../../../src/hooks/__tests__/debugger-log-recency-contract.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAEhE,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;IACtD,EAAE,CAAC,yEAAyE,EAAE,GAAG,EAAE;QACjF,KAAK,MAAM,OAAO,IAAI,CAAC,WAAW,EAAE,qBAAqB,CAAC,EAAE,CAAC;YAC3D,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACrC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,6BAA6B,CAAC,CAAC;YACrD,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;YAClD,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,+DAA+D,CAAC,CAAC;QACzF,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,MAAM,OAAO,GAAG,WAAW,CAAC,qBAAqB,CAAC,CAAC;QACnD,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,yEAAyE,CAAC,CAAC;QACjG,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;QAC3C,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,qCAAqC,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/hooks/__tests__/notify-fallback-watcher.test.js

@@ -22,6 +22,14 @@ async function readLines(path) {
     const content = await readFile(path, 'utf-8').catch(() => '');
     return content.split('\n').map(s => s.trim()).filter(Boolean);
 }
+async function readJsonLines(path) {
+    const content = await readFile(path, 'utf-8').catch(() => '');
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
 async function sleep(ms) {
     await new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -452,6 +460,70 @@ describe('notify-fallback watcher', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('backs off authority-only nudge ticks when the primary watcher is healthy', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-authority-backed-off-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        const codexHome = join(wd, 'codex-home');
+        try {
+            await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await mkdir(codexHome, { recursive: true });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            await writeFile(join(codexHome, '.omx-config.json'), JSON.stringify({
+                autoNudge: { enabled: true, delaySec: 0, ttlMs: 30_000 },
+            }, null, 2));
+            await writeSessionStart(wd, 'sess-managed-fallback');
+            await writeFile(join(wd, '.omx', 'state', 'hud-state.json'), JSON.stringify({
+                last_turn_at: new Date(Date.now() - 6_000).toISOString(),
+                turn_count: 7,
+                last_agent_output: 'If you want, I can keep going from here.',
+            }, null, 2));
+            await writeFile(join(wd, '.omx', 'state', 'notify-fallback.pid'), JSON.stringify({
+                pid: process.pid,
+                cwd: wd,
+                started_at: new Date().toISOString(),
+            }, null, 2));
+            await writeFile(join(wd, '.omx', 'state', 'notify-fallback-state.json'), JSON.stringify({
+                pid: process.pid,
+                cwd: wd,
+                authority_only: false,
+                poll_ms: 250,
+                dispatch_drain: { last_tick_at: new Date().toISOString() },
+            }, null, 2));
+            const watcherScript = new URL('../../../dist/scripts/notify-fallback-watcher.js', import.meta.url).pathname;
+            const notifyHook = new URL('../../../dist/scripts/notify-hook.js', import.meta.url).pathname;
+            const result = spawnSync(process.execPath, [watcherScript, '--once', '--authority-only', '--cwd', wd, '--notify-script', notifyHook, '--poll-ms', '50'], {
+                encoding: 'utf-8',
+                env: buildCleanNotifyEnv({
+                    PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                    CODEX_HOME: codexHome,
+                    OMX_SESSION_ID: 'sess-managed-fallback',
+                    TMUX: '1',
+                    TMUX_PANE: '%42',
+                    OMX_NOTIFY_FALLBACK_AUTO_NUDGE_STALL_MS: '5000',
+                }),
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf8').catch(() => '');
+            assert.doesNotMatch(tmuxLog, /send-keys -t %42 -l yes, proceed \[OMX_TMUX_INJECT\]/);
+            const watcherState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'notify-fallback-state.json'), 'utf-8'));
+            assert.equal(watcherState.pid, process.pid, 'authority backoff should preserve the primary watcher state owner');
+            assert.equal(watcherState.authority_only, false, 'authority backoff should not overwrite primary watcher ownership');
+            assert.equal(watcherState.authority_backoff?.active, true);
+            assert.equal(watcherState.authority_backoff?.reason, 'primary_watcher_healthy');
+            assert.equal(watcherState.authority_backoff?.primary_pid, process.pid);
+            assert.match(watcherState.dispatch_drain?.last_tick_at ?? '', /^\d{4}-\d{2}-\d{2}T/);
+            const logPath = join(wd, '.omx', 'logs', `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+            const logContent = await readFile(logPath, 'utf-8').catch(() => '');
+            assert.equal(logContent.trim(), '');
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('disables fallback watcher nudges when deep-interview state is active', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-deep-interview-suppressed-'));
         const fakeBinDir = join(wd, 'fake-bin');
@@ -600,7 +672,7 @@ describe('notify-fallback watcher', () => {
             });
             assert.equal(result.status, 0, result.stderr || result.stdout);
             const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            assert.match(tmuxLog, /send-keys -t %42 -l Team dispatch-team: leader stale/);
+            assert.match(tmuxLog, /send-keys -t %42 -l Team dispatch-team: leader stale, \d+ worker pane\(s\) still active\./);
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.poll_ms, 250);
@@ -614,6 +686,12 @@ describe('notify-fallback watcher', () => {
             assert.ok(nudgeEvent, 'expected leader_nudge_tick log event');
             assert.equal(nudgeEvent.leader_only, true);
             assert.equal(nudgeEvent.precomputed_leader_stale, true);
+            const deliveryLogPath = join(wd, '.omx', 'logs', `team-delivery-${new Date().toISOString().slice(0, 10)}.jsonl`);
+            const deliveryEntries = await readJsonLines(deliveryLogPath);
+            assert.ok(deliveryEntries.some((entry) => entry.event === 'nudge_triggered'
+                && entry.source === 'notify_fallback_watcher'
+                && entry.transport === 'send-keys'
+                && entry.result === 'sent'));
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -842,7 +920,7 @@ exit 0
             });
             assert.equal(result.status, 0, result.stderr || result.stdout);
             const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            assert.match(tmuxLog, /send-keys -t %42 -l Team dispatch-team: worker panes stalled, no progress 3m/);
+            assert.match(tmuxLog, /send-keys -t %42 -l Team dispatch-team: worker panes stalled, no progress 3m\./);
             assert.doesNotMatch(tmuxLog, /leader stale/);
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
@@ -1398,6 +1476,83 @@ exit 0
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('suppresses Ralph continue steer while tracked native subagents are still active', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-ralph-subagents-active-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const stateDir = join(wd, '.omx', 'state');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        const statePath = join(stateDir, 'notify-fallback-state.json');
+        const omxSessionId = 'sess-current';
+        const codexSessionId = 'codex-session-1';
+        try {
+            await mkdir(join(stateDir, 'sessions', omxSessionId), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            await writeSessionStart(wd, omxSessionId);
+            await writeFile(join(stateDir, 'sessions', omxSessionId, 'ralph-state.json'), JSON.stringify({
+                active: true,
+                current_phase: 'executing',
+                tmux_pane_id: '%42',
+                owner_omx_session_id: omxSessionId,
+                owner_codex_session_id: codexSessionId,
+            }, null, 2));
+            await writeFile(join(stateDir, 'hud-state.json'), JSON.stringify({
+                last_progress_at: new Date(Date.now() - 61_000).toISOString(),
+            }, null, 2));
+            await writeFile(statePath, JSON.stringify({
+                ralph_continue_steer: {
+                    last_sent_at: new Date(Date.now() - 61_000).toISOString(),
+                },
+            }, null, 2));
+            await writeFile(join(stateDir, 'subagent-tracking.json'), JSON.stringify({
+                schemaVersion: 1,
+                sessions: {
+                    [codexSessionId]: {
+                        session_id: codexSessionId,
+                        leader_thread_id: 'leader-thread',
+                        updated_at: new Date(Date.now() - 15_000).toISOString(),
+                        threads: {
+                            'leader-thread': {
+                                thread_id: 'leader-thread',
+                                kind: 'leader',
+                                first_seen_at: new Date(Date.now() - 30_000).toISOString(),
+                                last_seen_at: new Date(Date.now() - 15_000).toISOString(),
+                                turn_count: 1,
+                                mode: 'ralph',
+                            },
+                            'sub-thread-1': {
+                                thread_id: 'sub-thread-1',
+                                kind: 'subagent',
+                                first_seen_at: new Date(Date.now() - 30_000).toISOString(),
+                                last_seen_at: new Date(Date.now() - 15_000).toISOString(),
+                                turn_count: 1,
+                                mode: 'ralph',
+                            },
+                        },
+                    },
+                },
+            }, null, 2));
+            const watcherScript = new URL('../../../dist/scripts/notify-fallback-watcher.js', import.meta.url).pathname;
+            const notifyHook = new URL('../../../dist/scripts/notify-hook.js', import.meta.url).pathname;
+            const env = {
+                ...buildCleanNotifyEnv(),
+                PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+            };
+            const run = spawnSync(process.execPath, [watcherScript, '--once', '--cwd', wd, '--notify-script', notifyHook, '--poll-ms', '50'], { encoding: 'utf-8', env });
+            assert.equal(run.status, 0, run.stderr || run.stdout);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf8').catch(() => '');
+            const sends = tmuxLog.match(/send-keys -t %42 -l Ralph loop active continue \[OMX_TMUX_INJECT\]/g) || [];
+            assert.equal(sends.length, 0, 'active native subagents should block fallback continue steer');
+            const watcherState = JSON.parse(await readFile(statePath, 'utf-8'));
+            assert.equal(watcherState.ralph_continue_steer?.last_reason, 'subagents_active');
+            assert.equal(watcherState.ralph_continue_steer?.subagent_session_id, codexSessionId);
+            assert.deepEqual(watcherState.ralph_continue_steer?.active_subagent_thread_ids, ['sub-thread-1']);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('fails closed when Ralph hud progress is missing or invalid', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-ralph-progress-guard-'));
         const fakeBinDir = join(wd, 'fake-bin');
@@ -2263,6 +2418,85 @@ exit 0
             await rm(tempHome, { recursive: true, force: true });
         }
     });
+    it('backs off idle polling and resets to the base cadence after fresh rollout activity', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-idle-backoff-'));
+        const tempHome = await mkdtemp(join(tmpdir(), 'omx-fallback-idle-backoff-home-'));
+        const sid = randomUUID();
+        const sessionDir = todaySessionDir(tempHome);
+        const rolloutPath = join(sessionDir, `rollout-test-fallback-idle-backoff-${sid}.jsonl`);
+        const watcherScript = new URL('../../../dist/scripts/notify-fallback-watcher.js', import.meta.url).pathname;
+        const notifyHook = new URL('../../../dist/scripts/notify-hook.js', import.meta.url).pathname;
+        const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
+        const turnLogPath = join(wd, '.omx', 'logs', `turns-${new Date().toISOString().split('T')[0]}.jsonl`);
+        let child;
+        try {
+            await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(rolloutPath, `${JSON.stringify({
+                timestamp: new Date().toISOString(),
+                type: 'session_meta',
+                payload: { id: `thread-${sid}`, cwd: wd },
+            })}
+`);
+            child = spawn(process.execPath, [
+                watcherScript,
+                '--cwd',
+                wd,
+                '--notify-script',
+                notifyHook,
+                '--poll-ms',
+                '50',
+                '--idle-max-poll-ms',
+                '200',
+                '--parent-pid',
+                String(process.pid),
+                '--max-lifetime-ms',
+                '5000',
+            ], {
+                cwd: wd,
+                stdio: 'ignore',
+                env: buildCleanNotifyEnv({ HOME: tempHome, OMX_NOTIFY_FALLBACK_IDLE_MAX_POLL_MS: '200' }),
+            });
+            await waitFor(async () => {
+                try {
+                    const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
+                    return watcherState.adaptive_poll?.current_ms === 200 && watcherState.adaptive_poll?.idle_streak >= 2;
+                }
+                catch {
+                    return false;
+                }
+            }, 4000, 50);
+            const freshTurnId = `turn-fresh-${sid}`;
+            await appendLine(rolloutPath, {
+                timestamp: new Date().toISOString(),
+                type: 'event_msg',
+                payload: {
+                    type: 'task_complete',
+                    turn_id: freshTurnId,
+                    last_agent_message: 'fresh message after idle backoff',
+                },
+            });
+            await waitFor(async () => {
+                const turnLines = await readLines(turnLogPath);
+                if (!turnLines.some((line) => line.includes(freshTurnId)))
+                    return false;
+                const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
+                return watcherState.adaptive_poll?.current_ms === 50
+                    && watcherState.adaptive_poll?.idle_streak === 0
+                    && watcherState.adaptive_poll?.last_activity_reason === 'rollout_event';
+            }, 4000, 50);
+        }
+        finally {
+            if (child && isPidAlive(child.pid)) {
+                child.kill('SIGTERM');
+                await waitForExit(child, 4000).catch(() => { });
+            }
+            await rm(wd, { recursive: true, force: true });
+            await rm(tempHome, { recursive: true, force: true });
+            await rm(rolloutPath, { force: true });
+        }
+    });
     it('exits after the configured max lifetime', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-max-life-'));
         const tempHome = await mkdtemp(join(tmpdir(), 'omx-fallback-max-home-'));