oh-my-codex 0.12.4 → 0.12.6

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

@@ -1,7 +1,7 @@
 import { describe, it } from 'node:test';
 import { once } from 'node:events';
 import assert from 'node:assert/strict';
-import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
@@ -9,6 +9,7 @@ import { randomUUID } from 'node:crypto';
 import { initTeamState, enqueueDispatchRequest, readDispatchRequest } from '../../team/state.js';
 import { buildWindowsMsysBackgroundHelperBootstrapScript } from '../../cli/index.js';
 import { writeSessionStart } from '../session.js';
+const DEFAULT_AUTO_NUDGE_RESPONSE = 'continue with the current task only if it is already authorized';
 async function appendLine(path, line) {
     const prev = await readFile(path, 'utf-8');
     const content = prev + `${JSON.stringify(line)}\n`;
@@ -30,6 +31,80 @@ async function readJsonLines(path) {
         .filter(Boolean)
         .map((line) => JSON.parse(line));
 }
+async function writeCanonicalWatcherTeamFixture(wd, { teamName = 'dispatch-team', sessionId = 'sess-current', ownerSessionId = sessionId, coarseState = 'missing', terminal = false, } = {}) {
+    const stateDir = join(wd, '.omx', 'state');
+    const teamDir = join(stateDir, 'team', teamName);
+    const nowIso = new Date().toISOString();
+    await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
+    await mkdir(join(teamDir, 'workers'), { recursive: true });
+    await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+    if (coarseState !== 'missing') {
+        await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({
+            active: coarseState === 'active',
+            team_name: teamName,
+            current_phase: terminal ? 'complete' : 'team-exec',
+            ...(terminal ? { completed_at: nowIso } : {}),
+        }, null, 2));
+    }
+    await writeFile(join(stateDir, 'hud-state.json'), JSON.stringify({
+        last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+        turn_count: 3,
+    }, null, 2));
+    const manifest = {
+        schema_version: 2,
+        name: teamName,
+        task: 'canonical watcher fallback repro',
+        leader: {
+            session_id: ownerSessionId,
+            worker_id: 'leader-fixed',
+            role: 'coordinator',
+        },
+        policy: {
+            worker_launch_mode: 'interactive',
+            display_mode: 'split_pane',
+            dispatch_mode: 'hook_preferred_with_fallback',
+            dispatch_ack_timeout_ms: 2000,
+        },
+        governance: {
+            delegation_only: false,
+            plan_approval_required: false,
+            nested_teams_allowed: false,
+            one_team_per_leader_session: true,
+            cleanup_requires_all_workers_inactive: true,
+        },
+        lifecycle_profile: 'default',
+        permissions_snapshot: {
+            approval_mode: 'never',
+            sandbox_mode: 'danger-full-access',
+            network_access: true,
+        },
+        tmux_session: `${teamName}:0`,
+        leader_pane_id: '%42',
+        hud_pane_id: null,
+        resize_hook_name: null,
+        resize_hook_target: null,
+        worker_count: 1,
+        next_task_id: 1,
+        workers: [
+            { name: 'worker-1', index: 1, pane_id: '%42', role: 'executor' },
+        ],
+        created_at: nowIso,
+    };
+    await writeFile(join(teamDir, 'manifest.v2.json'), JSON.stringify(manifest, null, 2));
+    await writeFile(join(teamDir, 'config.json'), JSON.stringify({
+        name: teamName,
+        tmux_session: `${teamName}:0`,
+        leader_pane_id: '%42',
+        workers: [
+            { name: 'worker-1', pane_id: '%42' },
+        ],
+    }, null, 2));
+    await writeFile(join(teamDir, 'phase.json'), JSON.stringify({
+        current_phase: terminal ? 'complete' : 'team-exec',
+        updated_at: nowIso,
+        transitions: terminal ? [{ from: 'team-exec', to: 'complete', at: nowIso }] : [],
+    }, null, 2));
+}
 async function sleep(ms) {
     await new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -63,6 +138,9 @@ async function waitForExit(child, timeoutMs = 4000) {
         }),
     ]);
 }
+function defaultAutoNudgePattern(targetPane) {
+    return new RegExp(`send-keys -t ${targetPane} -l ${DEFAULT_AUTO_NUDGE_RESPONSE.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')} \\[OMX_TMUX_INJECT\\]`);
+}
 function buildFakeTmux(tmuxLogPath, options = {}) {
     return `#!/usr/bin/env bash
 set -eu
@@ -530,10 +608,11 @@ describe('notify-fallback watcher', () => {
                 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({
+            await mkdir(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback', '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.',
+                last_agent_output: 'Keep going and finish the cleanup from here.',
             }, null, 2));
             await writeFile(join(wd, '.omx', 'state', 'notify-fallback.pid'), JSON.stringify({
                 pid: process.pid,
@@ -562,7 +641,7 @@ describe('notify-fallback watcher', () => {
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
             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');
@@ -578,6 +657,52 @@ describe('notify-fallback watcher', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('treats symlinked cwd aliases as the same primary watcher during authority handoff', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-cwd-alias-'));
+        const aliasWd = `${wd}-alias`;
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        try {
+            await symlink(wd, aliasWd, process.platform === 'win32' ? 'junction' : 'dir');
+            await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            await writeSessionStart(wd, 'sess-cwd-alias');
+            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', aliasWd, '--notify-script', notifyHook, '--poll-ms', '50'], {
+                encoding: 'utf-8',
+                env: buildCleanNotifyEnv({
+                    PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                    OMX_SESSION_ID: 'sess-cwd-alias',
+                    TMUX: '1',
+                    TMUX_PANE: '%42',
+                }),
+            });
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const watcherState = JSON.parse(await readFile(join(wd, '.omx', 'state', 'notify-fallback-state.json'), 'utf-8'));
+            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);
+        }
+        finally {
+            await rm(aliasWd, { recursive: true, force: true });
+            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');
@@ -623,7 +748,7 @@ describe('notify-fallback watcher', () => {
             const tmuxLog = await readFile(tmuxLogPath, 'utf8').catch(() => '');
             assert.doesNotMatch(tmuxLog, /Ralph loop active continue/);
             assert.doesNotMatch(tmuxLog, /Team dispatch-team:/);
-            assert.doesNotMatch(tmuxLog, /yes, proceed \[OMX_TMUX_INJECT\]/);
+            assert.doesNotMatch(tmuxLog, new RegExp(`${DEFAULT_AUTO_NUDGE_RESPONSE.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')} \\[OMX_TMUX_INJECT\\]`));
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -686,7 +811,7 @@ describe('notify-fallback watcher', () => {
             const tmuxLog = await readFile(tmuxLogPath, 'utf8').catch(() => '');
             assert.doesNotMatch(tmuxLog, /Ralph loop active continue/);
             assert.doesNotMatch(tmuxLog, /Team dispatch-team:/);
-            assert.doesNotMatch(tmuxLog, /yes, proceed \[OMX_TMUX_INJECT\]/);
+            assert.doesNotMatch(tmuxLog, new RegExp(`${DEFAULT_AUTO_NUDGE_RESPONSE.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')} \\[OMX_TMUX_INJECT\\]`));
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -722,6 +847,7 @@ describe('notify-fallback watcher', () => {
                 encoding: 'utf-8',
                 env: buildCleanNotifyEnv({
                     PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                    OMX_SESSION_ID: 'sess-canonical-inactive',
                 }),
             });
             assert.equal(result.status, 0, result.stderr || result.stdout);
@@ -751,6 +877,37 @@ describe('notify-fallback watcher', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('runs leader nudge checks from canonical fallback when coarse team-state is inactive', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-leader-nudge-canonical-inactive-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        try {
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalWatcherTeamFixture(wd, {
+                teamName: 'dispatch-team',
+                sessionId: 'sess-canonical-inactive',
+                ownerSessionId: 'sess-canonical-inactive',
+                coarseState: 'inactive',
+            });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            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', '--cwd', wd, '--notify-script', notifyHook], {
+                encoding: 'utf-8',
+                env: buildCleanNotifyEnv({
+                    PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                    OMX_SESSION_ID: 'sess-canonical-inactive',
+                }),
+            });
+            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, \d+ worker pane\(s\) still active\./);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('skips fallback watcher leader nudges when the leader is not stale even if mailbox messages exist', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-leader-nudge-fresh-'));
         const fakeBinDir = join(wd, 'fake-bin');
@@ -793,6 +950,7 @@ describe('notify-fallback watcher', () => {
                 encoding: 'utf-8',
                 env: buildCleanNotifyEnv({
                     PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                    OMX_SESSION_ID: 'sess-canonical-inactive',
                 }),
             });
             assert.equal(result.status, 0, result.stderr || result.stdout);
@@ -1003,10 +1161,11 @@ exit 0
                 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({
+            await mkdir(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback', '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.',
+                last_agent_output: 'Keep going and finish the cleanup from here.',
             }, 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;
@@ -1024,7 +1183,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 yes, proceed \[OMX_TMUX_INJECT\]/);
+            assert.match(tmuxLog, defaultAutoNudgePattern('%42'));
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.fallback_auto_nudge?.last_reason, 'sent');
@@ -1055,10 +1214,11 @@ exit 0
                 target: { type: 'pane', value: '%42' },
             }, null, 2));
             await writeSessionStart(wd, 'sess-managed-fallback');
-            await writeFile(join(wd, '.omx', 'state', 'hud-state.json'), JSON.stringify({
+            await mkdir(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback'), { recursive: true });
+            await writeFile(join(wd, '.omx', 'state', 'sessions', 'sess-managed-fallback', '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.',
+                last_agent_output: 'Keep going and finish the cleanup from here.',
             }, 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;
@@ -1075,7 +1235,7 @@ exit 0
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
         }
         finally {
             await rm(wd, { recursive: true, force: true });
@@ -1099,7 +1259,7 @@ exit 0
             await writeFile(join(wd, '.omx', 'state', 'hud-state.json'), JSON.stringify({
                 last_turn_at: new Date(Date.now() - 6_000).toISOString(),
                 turn_count: 9,
-                last_agent_output: 'If you want, I can keep going from here.',
+                last_agent_output: 'Keep going and finish the cleanup from here.',
             }, 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;
@@ -1115,7 +1275,7 @@ exit 0
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.fallback_auto_nudge?.last_reason, 'eligible_but_not_sent');
@@ -1145,7 +1305,7 @@ exit 0
             await writeFile(join(wd, '.omx', 'state', 'hud-state.json'), JSON.stringify({
                 last_turn_at: new Date(Date.now() - 1_000).toISOString(),
                 turn_count: 8,
-                last_agent_output: 'If you want, I can keep going from here.',
+                last_agent_output: 'Keep going and finish the cleanup from here.',
             }, 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;
@@ -1161,7 +1321,7 @@ exit 0
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.fallback_auto_nudge?.last_reason, 'recent_turn_activity');
@@ -1177,7 +1337,7 @@ exit 0
         const tmuxLogPath = join(wd, 'tmux.log');
         const codexHome = join(wd, 'codex-home');
         const lastTurnAt = new Date(Date.now() - 6_000).toISOString();
-        const lastMessage = 'If you want, I can keep going from here.';
+        const lastMessage = 'Keep going and finish the cleanup from here.';
         try {
             await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
             await mkdir(join(wd, '.omx', 'state'), { recursive: true });
@@ -1213,7 +1373,7 @@ exit 0
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.fallback_auto_nudge?.last_reason, 'already_nudged_for_signature');
@@ -1229,7 +1389,7 @@ exit 0
         const tmuxLogPath = join(wd, 'tmux.log');
         const codexHome = join(wd, 'codex-home');
         const lastTurnAt = '2026-03-01T00:00:00.000Z';
-        const lastMessage = 'If you want, I can keep going from here.';
+        const lastMessage = 'Keep going and finish the cleanup from here.';
         try {
             await mkdir(join(wd, '.omx', 'logs'), { recursive: true });
             await mkdir(join(wd, '.omx', 'state'), { recursive: true });
@@ -1265,7 +1425,7 @@ exit 0
             });
             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\]/);
+            assert.doesNotMatch(tmuxLog, defaultAutoNudgePattern('%42'));
             const watcherStatePath = join(wd, '.omx', 'state', 'notify-fallback-state.json');
             const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
             assert.equal(watcherState.fallback_auto_nudge?.last_reason, 'already_nudged_for_signature');
@@ -1530,6 +1690,53 @@ exit 0
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('suppresses Ralph continue steer when session-scoped Ralph is stuck in stale starting phase', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-ralph-starting-stale-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        const stateDir = join(wd, '.omx', 'state');
+        const sessionId = 'sess-starting-stale';
+        const sessionStateDir = join(stateDir, 'sessions', sessionId);
+        const watcherStatePath = join(stateDir, 'notify-fallback-state.json');
+        try {
+            await mkdir(sessionStateDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            await writeSessionStart(wd, sessionId);
+            await writeFile(join(sessionStateDir, 'ralph-state.json'), JSON.stringify({
+                active: true,
+                current_phase: 'starting',
+                started_at: new Date(Date.now() - 180_000).toISOString(),
+                tmux_pane_id: '%42',
+            }, null, 2));
+            await writeFile(join(sessionStateDir, 'hud-state.json'), JSON.stringify({
+                last_progress_at: new Date(Date.now() - 180_000).toISOString(),
+            }, null, 2));
+            await writeFile(watcherStatePath, JSON.stringify({
+                ralph_continue_steer: {
+                    last_sent_at: new Date(Date.now() - 61_000).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 run = spawnSync(process.execPath, [watcherScript, '--once', '--cwd', wd, '--notify-script', notifyHook, '--poll-ms', '50'], {
+                encoding: 'utf-8',
+                env: buildCleanNotifyEnv({
+                    PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                }),
+            });
+            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, 'stale starting phase should suppress continue steer');
+            const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
+            assert.equal(watcherState.ralph_continue_steer?.last_reason, 'starting_stale');
+        }
+        finally {
+            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');
@@ -1551,7 +1758,7 @@ exit 0
                 owner_omx_session_id: omxSessionId,
                 owner_codex_session_id: codexSessionId,
             }, null, 2));
-            await writeFile(join(stateDir, 'hud-state.json'), JSON.stringify({
+            await writeFile(join(stateDir, 'sessions', omxSessionId, 'hud-state.json'), JSON.stringify({
                 last_progress_at: new Date(Date.now() - 61_000).toISOString(),
             }, null, 2));
             await writeFile(statePath, JSON.stringify({
@@ -1846,6 +2053,52 @@ exit 0
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('treats a long-running starting phase as terminal so Ralph steer stops', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-starting-phase-stale-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        const stateDir = join(wd, '.omx', 'state');
+        const watcherStatePath = join(stateDir, 'notify-fallback-state.json');
+        const staleStartedAt = new Date(Date.now() - 3 * 60_000).toISOString();
+        try {
+            await mkdir(stateDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            await writeFile(join(stateDir, 'ralph-state.json'), JSON.stringify({
+                active: true,
+                current_phase: 'starting',
+                started_at: staleStartedAt,
+                tmux_pane_id: '%42',
+            }, null, 2));
+            await writeFile(join(stateDir, 'hud-state.json'), JSON.stringify({
+                last_progress_at: new Date(Date.now() - 5 * 60_000).toISOString(),
+            }, null, 2));
+            await writeFile(watcherStatePath, JSON.stringify({
+                ralph_continue_steer: {
+                    last_sent_at: new Date(Date.now() - 61_000).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 run = spawnSync(process.execPath, [watcherScript, '--once', '--cwd', wd, '--notify-script', notifyHook, '--poll-ms', '50'], {
+                encoding: 'utf-8',
+                env: buildCleanNotifyEnv({
+                    PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+                }),
+            });
+            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, 'stale starting phase should block Ralph continue steer');
+            const watcherState = JSON.parse(await readFile(watcherStatePath, 'utf-8'));
+            assert.equal(watcherState.ralph_continue_steer?.active, false);
+            assert.equal(watcherState.ralph_continue_steer?.last_reason, 'terminal');
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('globally debounces Ralph continue steer across concurrent watcher instances', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-ralph-global-debounce-'));
         const fakeBinDir = join(wd, 'fake-bin');
@@ -2178,7 +2431,7 @@ exit 0
                 current_phase: 'executing',
                 tmux_pane_id: '%42',
             }, null, 2));
-            await writeFile(join(stateDir, 'hud-state.json'), JSON.stringify({
+            await writeFile(join(sessionStateDir, 'hud-state.json'), JSON.stringify({
                 last_progress_at: new Date(Date.now() - 61_000).toISOString(),
             }, null, 2));
             await writeFile(join(stateDir, 'notify-fallback-state.json'), JSON.stringify({
@@ -2320,6 +2573,123 @@ exit 0
             await rm(tempHome, { recursive: true, force: true });
         }
     });
+    it('stays alive after parent exit when coarse team-state is missing but canonical team is active for the current session', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-canonical-team-'));
+        const tempHome = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-canonical-home-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        let child;
+        try {
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalWatcherTeamFixture(wd, {
+                teamName: 'dispatch-team',
+                sessionId: 'sess-parent-canonical',
+                ownerSessionId: 'sess-parent-canonical',
+            });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            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 logPath = join(wd, '.omx', 'logs', `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+            const shortLivedParent = spawn(process.execPath, ['-e', 'setTimeout(() => process.exit(0), 10)'], {
+                stdio: 'ignore',
+            });
+            assert.ok(shortLivedParent.pid, 'expected short-lived parent pid');
+            const parentPid = shortLivedParent.pid;
+            await once(shortLivedParent, 'exit');
+            child = spawn(process.execPath, [
+                watcherScript,
+                '--cwd',
+                wd,
+                '--notify-script',
+                notifyHook,
+                '--poll-ms',
+                '50',
+                '--parent-pid',
+                String(parentPid),
+                '--max-lifetime-ms',
+                '5000',
+            ], {
+                cwd: wd,
+                stdio: 'ignore',
+                env: buildCleanNotifyEnv({ HOME: tempHome, PATH: `${fakeBinDir}:${process.env.PATH || ''}` }),
+            });
+            await waitFor(async () => isPidAlive(child?.pid), 4000, 50);
+            await waitFor(async () => {
+                const logEntries = (await readFile(logPath, 'utf-8').catch(() => ''))
+                    .trim()
+                    .split('\n')
+                    .filter(Boolean)
+                    .map((line) => JSON.parse(line));
+                return logEntries.some((entry) => (entry.type === 'watcher_parent_guard' && entry.reason === 'parent_gone_deferred_for_active_team'));
+            }, 4000, 50);
+            assert.ok(isPidAlive(child.pid), 'expected watcher to stay alive while canonical team panes remain active');
+        }
+        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 });
+        }
+    });
+    it('does not defer parent-loss shutdown when canonical owner session is blank and coarse team-state is missing', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-ownerless-team-'));
+        const tempHome = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-ownerless-home-'));
+        const fakeBinDir = join(wd, 'fake-bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        let child;
+        try {
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalWatcherTeamFixture(wd, {
+                teamName: 'dispatch-team',
+                sessionId: 'sess-parent-ownerless',
+                ownerSessionId: '',
+            });
+            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
+            await chmod(join(fakeBinDir, 'tmux'), 0o755);
+            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 logPath = join(wd, '.omx', 'logs', `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+            const shortLivedParent = spawn(process.execPath, ['-e', 'setTimeout(() => process.exit(0), 10)'], {
+                stdio: 'ignore',
+            });
+            assert.ok(shortLivedParent.pid, 'expected short-lived parent pid');
+            const parentPid = shortLivedParent.pid;
+            await once(shortLivedParent, 'exit');
+            child = spawn(process.execPath, [
+                watcherScript,
+                '--cwd',
+                wd,
+                '--notify-script',
+                notifyHook,
+                '--poll-ms',
+                '50',
+                '--parent-pid',
+                String(parentPid),
+                '--max-lifetime-ms',
+                '5000',
+            ], {
+                cwd: wd,
+                stdio: 'ignore',
+                env: buildCleanNotifyEnv({ HOME: tempHome, PATH: `${fakeBinDir}:${process.env.PATH || ''}` }),
+            });
+            await waitForExit(child, 4000);
+            assert.equal(child.exitCode, 0);
+            const logEntries = (await readFile(logPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+            assert.ok(logEntries.some((entry) => (entry.type === 'watcher_stop' && entry.reason === 'parent_gone')));
+            assert.ok(!logEntries.some((entry) => (entry.type === 'watcher_parent_guard' && entry.reason === 'parent_gone_deferred_for_active_team')), 'ownerless canonical team must not defer parent-loss shutdown');
+        }
+        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 });
+        }
+    });
     it('does not defer parent-loss shutdown for a team that is already terminal in phase.json', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-terminal-team-'));
         const tempHome = await mkdtemp(join(tmpdir(), 'omx-fallback-parent-gone-terminal-team-home-'));