@jstn-sdk/rcs 0.1.0

package/dist/hooks/__tests__/notify-hook-team-leader-nudge.test.js

@@ -0,0 +1,2879 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { initTeamState, enqueueDispatchRequest, readDispatchRequest } from '../../team/state.js';
+const NOTIFY_HOOK_SCRIPT = new URL('../../../dist/scripts/notify-hook.js', import.meta.url);
+async function withTempWorkingDir(run) {
+    const cwd = await mkdtemp(join(tmpdir(), 'rcs-notify-team-nudge-'));
+    try {
+        await run(cwd);
+    }
+    finally {
+        await rm(cwd, { recursive: true, force: true });
+    }
+}
+async function writeJson(path, value) {
+    await writeFile(path, JSON.stringify(value, null, 2));
+}
+async function writeCanonicalTeamFixture(cwd, { teamName, sessionId, ownerSessionId, coarseState = 'missing', }) {
+    const stateDir = join(cwd, '.rcs', 'state');
+    const teamDir = join(stateDir, 'team', teamName);
+    const workersDir = join(teamDir, 'workers');
+    const nowIso = new Date().toISOString();
+    await mkdir(join(cwd, '.rcs', 'logs'), { recursive: true });
+    await mkdir(workersDir, { recursive: true });
+    await writeJson(join(stateDir, 'session.json'), { session_id: sessionId });
+    if (coarseState !== 'missing') {
+        await writeJson(join(stateDir, 'team-state.json'), {
+            active: coarseState === 'active',
+            team_name: teamName,
+            current_phase: 'team-exec',
+        });
+    }
+    await writeJson(join(stateDir, 'hud-state.json'), {
+        last_turn_at: nowIso,
+        turn_count: 1,
+    });
+    await writeJson(join(teamDir, 'manifest.v2.json'), {
+        schema_version: 2,
+        name: teamName,
+        task: 'canonical notify 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: '%97',
+        hud_pane_id: null,
+        resize_hook_name: null,
+        resize_hook_target: null,
+        worker_count: 2,
+        next_task_id: 1,
+        workers: [
+            { name: 'worker-1', index: 1, pane_id: '%1', role: 'executor' },
+            { name: 'worker-2', index: 2, pane_id: '%2', role: 'executor' },
+        ],
+        created_at: nowIso,
+    });
+    await writeJson(join(teamDir, 'phase.json'), {
+        current_phase: 'team-exec',
+        updated_at: nowIso,
+        transitions: [],
+    });
+    for (const worker of ['worker-1', 'worker-2']) {
+        await mkdir(join(workersDir, worker), { recursive: true });
+        await writeJson(join(workersDir, worker, 'status.json'), {
+            state: 'idle',
+            updated_at: nowIso,
+        });
+    }
+}
+async function readTeamDeliveryLog(cwd) {
+    const path = join(cwd, '.rcs', '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));
+}
+function buildFakeTmux(tmuxLogPath) {
+    return `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  echo "%2 12346"
+  exit 0
+fi
+exit 0
+`;
+}
+function buildFakeTmuxWithListPanes(tmuxLogPath, listPaneLines) {
+    const escapedLines = listPaneLines
+        .map((line) => line.replaceAll('\\', '\\\\').replaceAll('"', '\\"'))
+        .join('\\n');
+    return `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  printf "%b\\n" "${escapedLines}"
+  exit 0
+fi
+exit 0
+`;
+}
+function runNotifyHook(cwd, fakeBinDir, extraEnv = {}) {
+    const payload = {
+        cwd,
+        type: 'agent-turn-complete',
+        'thread-id': 'thread-test',
+        'turn-id': `turn-${Date.now()}`,
+        'input-messages': ['test'],
+        'last-assistant-message': 'output',
+    };
+    return spawnSync(process.execPath, [NOTIFY_HOOK_SCRIPT.pathname, JSON.stringify(payload)], {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            PATH: `${fakeBinDir}:${process.env.PATH || ''}`,
+            RCS_TEAM_LEADER_NUDGE_MS: '10000',
+            RCS_TEAM_LEADER_STALE_MS: '10000',
+            RCS_TEAM_WORKER: '',
+            RCS_TEAM_STATE_ROOT: '',
+            RCS_TEAM_LEADER_CWD: '',
+            RCS_MODEL_INSTRUCTIONS_FILE: '',
+            TMUX: '',
+            TMUX_PANE: '',
+            ...extraEnv,
+        },
+    });
+}
+describe('notify-hook leader-side authority handoff', () => {
+    it('does not inject leader nudge from notify-hook when team is active and stale', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'handoff-alpha';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'handoff-sess:0',
+                leader_pane_id: '%91',
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 1,
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'ACK',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-missing',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8').catch(() => '');
+            assert.match(tmuxLog, /send-keys/, 'current implementation nudges the leader directly in this stale-leader path');
+        });
+    });
+    it('does not drain pending dispatch requests from notify-hook leader context', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(join(cwd, '.rcs', 'logs'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            await initTeamState('handoff-dispatch', 'task', 'executor', 1, cwd);
+            const queued = await enqueueDispatchRequest('handoff-dispatch', {
+                kind: 'inbox',
+                to_worker: 'worker-1',
+                worker_index: 1,
+                trigger_message: 'dispatch ping',
+            }, cwd);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-inactive',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const request = await readDispatchRequest('handoff-dispatch', queued.request.request_id, cwd);
+            assert.equal(request?.status, 'failed');
+        });
+    });
+    it('does not nudge stale leader when recent team status activity proves the leader is active', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'beta-active-status';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-beta-active-status',
+                leader_pane_id: '%92',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 5,
+            });
+            await writeJson(join(stateDir, 'leader-runtime-activity.json'), {
+                last_activity_at: new Date(Date.now() - 5_000).toISOString(),
+                last_team_status_at: new Date(Date.now() - 5_000).toISOString(),
+                last_source: 'team_status',
+                last_team_name: teamName,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: new Date().toISOString(),
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-current',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /Team beta-active-status:/);
+                assert.doesNotMatch(tmuxLog, /leader stale/);
+            }
+        });
+    });
+});
+describe('notify-hook team leader nudge', () => {
+    it('disables leader nudges when deep-interview state is active', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'deep-interview-suppressed';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'deep-interview-state.json'), {
+                active: true,
+                mode: 'deep-interview',
+                current_phase: 'deep-interview',
+            });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'deep-interview-suppressed:0',
+                leader_pane_id: '%97',
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 1,
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [{ message_id: 'msg-1', from_worker: 'worker-1', to_worker: 'leader-fixed', body: 'review', created_at: new Date().toISOString() }],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-missing',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8').catch(() => '');
+            assert.doesNotMatch(tmuxLog, /send-keys -t %97 -l Team deep-interview-suppressed:/);
+        });
+    });
+    it('sends immediate all-workers-idle nudge for active team (leader context)', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'idle-alpha';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-sess:0',
+                leader_pane_id: '%99',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: [] },
+                    { name: 'worker-2', index: 2, role: 'executor', assigned_tasks: [] },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 1,
+            });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'idle',
+                updated_at: new Date().toISOString(),
+            });
+            await mkdir(join(workersDir, 'worker-2'), { recursive: true });
+            await writeJson(join(workersDir, 'worker-2', 'status.json'), {
+                state: 'idle',
+                updated_at: new Date().toISOString(),
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-inactive',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /-t %99/, 'should target leader pane when present');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/, 'should emit all-workers-idle nudge');
+            assert.doesNotMatch(tmuxLog, /\[RCS_INTENT:/, 'should keep orchestration intent out of injected display text');
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/, 'should include injection marker');
+            const submitMatches = tmuxLog.match(/send-keys -t %99 C-m/g) || [];
+            assert.equal(submitMatches.length, 2, 'leader nudge should submit with isolated double C-m');
+            assert.ok(!/send-keys[^\n]*-l[^\n]*C-m/.test(tmuxLog), 'must not mix literal payload with submit keypresses');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            assert.ok(existsSync(eventsPath), 'events.ndjson should exist');
+            const eventsContent = await readFile(eventsPath, 'utf-8');
+            const events = eventsContent.trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.ok(nudgeEvent, 'should have team_leader_nudge event');
+            assert.equal(nudgeEvent.reason, 'done_waiting_on_leader');
+            assert.equal(nudgeEvent.orchestration_intent, 'done-review-or-shutdown');
+        });
+    });
+    it('suggests shutdown when all workers are idle and the current task set is complete', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'idle-shutdown';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-shutdown:0',
+                leader_pane_id: '%96',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                    { name: 'worker-2', index: 2, pane_id: '%11', role: 'executor' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 1,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Done',
+                description: 'completed work item',
+                status: 'completed',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: nowIso,
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-missing',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle\./);
+            assert.match(tmuxLog, /Team idle-shutdown looks complete\./);
+            assert.match(tmuxLog, /Next: decide whether to reconcile\/merge results or gracefully shut down: rcs team shutdown idle-shutdown\./);
+            assert.doesNotMatch(tmuxLog, /keep polling/);
+        });
+    });
+    it('suggests reusing the team when follow-up tasks are pending and worker panes are still reusable', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'idle-followup-reuse';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-followup-reuse:0',
+                leader_pane_id: '%97',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                    { name: 'worker-2', index: 2, pane_id: '%11', role: 'executor' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 1,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'queued follow-up task',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: nowIso,
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-inactive',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/);
+            assert.match(tmuxLog, /Team idle-followup-reuse has idle workers ready\./);
+            assert.match(tmuxLog, /Next: assign the next follow-up task to this idle team\./);
+            assert.doesNotMatch(tmuxLog, /launch a new team/);
+        });
+    });
+    it('suggests launching a new team when follow-up tasks are pending but worker panes are no longer reusable', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'idle-followup-relaunch';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-followup-relaunch:0',
+                leader_pane_id: '%98',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                    { name: 'worker-2', index: 2, pane_id: '%11', role: 'executor' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 1,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'queued follow-up task',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: nowIso,
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%98 12349']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/);
+            assert.match(tmuxLog, /Team idle-followup-relaunch has follow-up work ready\./);
+            assert.match(tmuxLog, /Next: launch a new team for the next task set\./);
+            assert.doesNotMatch(tmuxLog, /idle workers ready/);
+        });
+    });
+    it('falls back to global team-state when session-scoped state is active but team-state.json remains global', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const sessionId = 'sess-idle-fallback';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const teamName = 'idle-global-fallback';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(sessionDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'session.json'), { session_id: sessionId });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-global:0',
+                leader_pane_id: '%97',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: [] },
+                    { name: 'worker-2', index: 2, role: 'executor', assigned_tasks: [] },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 1,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: new Date().toISOString(),
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /-t %97/, 'should still target the leader pane');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/, 'global team-state fallback should still fire idle nudge');
+        });
+    });
+    it('falls back to canonical team state when coarse team-state is missing', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalTeamFixture(cwd, {
+                teamName: 'canonical-missing',
+                sessionId: 'sess-canonical-missing',
+                ownerSessionId: 'sess-canonical-missing',
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-missing',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /-t %97/, 'should target canonical leader pane');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/, 'canonical fallback should still fire idle nudge');
+        });
+    });
+    it('falls back to canonical team state when coarse team-state is inactive', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalTeamFixture(cwd, {
+                teamName: 'canonical-inactive',
+                sessionId: 'sess-canonical-inactive',
+                ownerSessionId: 'sess-canonical-inactive',
+                coarseState: 'inactive',
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-inactive',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /-t %97/, 'should still target canonical leader pane');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/, 'inactive coarse state should still fall back canonically');
+        });
+    });
+    it('ignores invalid team_name before canonical leader follow-up team path joins', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalTeamFixture(cwd, {
+                teamName: 'canonical-safe',
+                sessionId: 'sess-canonical-safe',
+                ownerSessionId: 'sess-canonical-safe',
+                coarseState: 'inactive',
+            });
+            const teamRoot = join(cwd, '.rcs', 'state', 'team');
+            await mkdir(join(teamRoot, '..-bad-team'), { recursive: true });
+            await writeJson(join(teamRoot, '..-bad-team', 'manifest.v2.json'), {
+                schema_version: 2,
+                name: '..-bad-team',
+                task: 'invalid canonical fallback fixture',
+                leader: { session_id: 'sess-canonical-safe', worker_id: 'leader-fixed', role: 'coordinator' },
+                tmux_session: 'bad:0',
+                leader_pane_id: '%666',
+                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: '%666', role: 'executor' }],
+                created_at: new Date().toISOString(),
+                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,
+                },
+            });
+            await writeJson(join(teamRoot, '..-bad-team', 'phase.json'), {
+                current_phase: 'team-exec',
+                updated_at: new Date().toISOString(),
+                transitions: [],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-canonical-safe',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /-t %97/, 'should still target the valid canonical leader pane');
+            assert.doesNotMatch(tmuxLog, /%666/, 'invalid canonical team names must be ignored before joins');
+            assert.match(tmuxLog, /\[RCS\] All 2 workers idle/, 'valid canonical fallback should still fire idle nudge');
+        });
+    });
+    it('nudges leader via tmux send-keys when team is active and mailbox has messages', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'alpha';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'devsess:0',
+                leader_pane_id: '%91',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'ACK',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /-t %91/);
+            assert.doesNotMatch(tmuxLog, /-t devsess:0/);
+            assert.match(tmuxLog, /Team alpha:/);
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/, 'should include injection marker');
+            const deliveryLog = await readTeamDeliveryLog(cwd);
+            assert.ok(deliveryLog.some((entry) => entry.event === 'nudge_triggered'
+                && entry.source === 'notify_hook'
+                && entry.team === teamName
+                && entry.to_worker === 'leader-fixed'
+                && entry.transport === 'send-keys'
+                && entry.result === 'sent'));
+        });
+    });
+    it('injects leader nudge into a busy live Codex pane so the message can queue', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'busy-live-pane';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'busy-live-pane:0',
+                leader_pane_id: '%93',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'busy-msg-1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'Need leader review',
+                        created_at: '2026-03-12T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_in_mode}" && "$target" == "%93" ]]; then
+    echo "0"
+    exit 0
+  fi
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%93" ]]; then
+    echo "codex"
+    exit 0
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "capture-pane" ]]; then
+  cat <<'EOF'
+OpenAI Codex
+• Working… (esc to interrupt)
+›
+EOF
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /display-message -p -t %93 #\{pane_in_mode\}/);
+            assert.match(tmuxLog, /capture-pane -t %93 -p -S -80/);
+            assert.match(tmuxLog, /send-keys -t %93 -l .*Team busy-live-pane:/);
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/, 'should keep the injection marker on busy-pane sends');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            assert.ok(existsSync(eventsPath), 'events.ndjson should exist');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+            assert.ok(events.some((entry) => entry.type === 'team_leader_nudge' && entry.reason === 'new_mailbox_message'));
+            assert.ok(!events.some((entry) => entry.type === 'leader_notification_deferred' && entry.reason === 'pane_has_active_task'));
+        });
+    });
+    it('surfaces ack-like mailbox replies without work-start evidence as missing-start nudges', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'ack-missing-start';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'ack-sess:0',
+                leader_pane_id: '%94',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: ['1'] },
+                ],
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'ack-1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'on it',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /worker-1 said "on it"/);
+            assert.match(tmuxLog, /no start evidence/);
+            assert.match(tmuxLog, /status: unknown/);
+            assert.match(tmuxLog, /Next: check worker-1 msg\/output, confirm task in rcs team status ack-missing-start/);
+            assert.doesNotMatch(tmuxLog, /\[RCS_INTENT:/);
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge' && e.reason === 'ack_without_start_evidence');
+            assert.ok(nudgeEvent, 'should emit an ack_without_start_evidence leader nudge');
+            assert.equal(nudgeEvent.orchestration_intent, 'followup-relaunch');
+        });
+    });
+    it('does not classify ack-like replies as missing-start after a worker has claimed work', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'ack-with-start';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'ack-started:0',
+                leader_pane_id: '%95',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: ['1'] },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 1,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: new Date().toISOString(),
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate failure',
+                description: 'trace ack without start',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: new Date().toISOString(),
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'ack-2',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'on it',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.doesNotMatch(tmuxLog, /no start evidence/);
+            assert.match(tmuxLog, /Team ack-with-start: 1 msg\(s\) for leader\./);
+            assert.match(tmuxLog, /Next: read messages; keep orchestrating; if done, gracefully shut down: rcs team shutdown ack-with-start\./);
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.equal(nudgeEvent?.reason, 'new_mailbox_message');
+        });
+    });
+    it('does not re-nudge for the same fresh mailbox message on repeated notify-hook runs', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'fresh-mailbox-bounded';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'fresh-mailbox-bounded:0',
+                leader_pane_id: '%97',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: ['1'] },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 1,
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'same-msg-1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'please review',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const first = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_NUDGE_MS: '600000' });
+            assert.equal(first.status, 0, `notify-hook failed: ${first.stderr || first.stdout}`);
+            const second = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_NUDGE_MS: '600000' });
+            assert.equal(second.status, 0, `notify-hook failed: ${second.stderr || second.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            const sends = tmuxLog.match(/send-keys -t %97 -l Team fresh-mailbox-bounded: 1 msg\(s\) for leader\./g) || [];
+            assert.equal(sends.length, 1, 'same mailbox message should not trigger repeated non-stale nudges');
+        });
+    });
+    it('does not inject leader nudge into a shell pane', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'shell-guard';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'shell-guard:0',
+                leader_pane_id: '%71',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'ACK',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%71" ]]; then
+    echo "zsh"
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /display-message -p -t %71 #\{pane_current_command\}/);
+            assert.doesNotMatch(tmuxLog, /send-keys -t %71/, 'should not inject into a shell pane');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+            const deferred = events.find((entry) => entry.type === 'leader_notification_deferred' && entry.reason === 'leader_pane_shell_no_injection');
+            assert.ok(deferred, 'should emit deferred event for shell-pane leader');
+            assert.equal(deferred.pane_current_command, 'zsh');
+        });
+    });
+    it('injects leader nudge even while the leader pane has an active task', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'busy-leader-queue';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'busy-leader-queue:0',
+                leader_pane_id: '%73',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'please review queued message',
+                        created_at: '2026-03-12T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_in_mode}" && "$target" == "%73" ]]; then
+    echo "0"
+    exit 0
+  fi
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%73" ]]; then
+    echo "codex"
+    exit 0
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "capture-pane" ]]; then
+  printf "• Running tests (3m 12s • esc to interrupt)\\n"
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /capture-pane/);
+            assert.match(tmuxLog, /send-keys -t %73/, 'should inject into a busy leader pane so Codex can queue the message');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            if (existsSync(eventsPath)) {
+                const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+                const deferred = events.find((entry) => entry.type === 'leader_notification_deferred' && entry.reason === 'pane_has_active_task');
+                assert.equal(deferred, undefined, 'busy leader pane should no longer defer notifications');
+            }
+        });
+    });
+    it('injects leader nudge when capture-pane fails but the leader pane is a live codex pane', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'capture-failure-live-leader';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'capture-failure-live-leader:0',
+                leader_pane_id: '%74',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'please review capture failure path',
+                        created_at: '2026-03-12T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_in_mode}" && "$target" == "%74" ]]; then
+    echo "0"
+    exit 0
+  fi
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%74" ]]; then
+    echo "codex"
+    exit 0
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "capture-pane" ]]; then
+  echo "capture failed" >&2
+  exit 1
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /capture-pane -t %74 -p -S -80/);
+            assert.match(tmuxLog, /send-keys -t %74/, 'capture failures should not suppress leader injection into a live codex pane');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            if (existsSync(eventsPath)) {
+                const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+                const deferred = events.find((entry) => entry.type === 'leader_notification_deferred');
+                assert.equal(deferred, undefined, 'capture failure alone should not defer a live codex leader pane');
+            }
+        });
+    });
+    it('suppresses duplicate visible leader injection when the pane already shows the same classified state', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'same-classified-state';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'same-classified-state:0',
+                leader_pane_id: '%75',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'same-classified-msg',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'please review latest output',
+                        created_at: '2026-03-12T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_in_mode}" && "$target" == "%75" ]]; then
+    echo "0"
+    exit 0
+  fi
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%75" ]]; then
+    echo "codex"
+    exit 0
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "capture-pane" ]]; then
+  cat <<'EOF'
+Team same-classified-state: 1 msg(s) for leader. Next: read messages; keep orchestrating; if done, gracefully shut down: rcs team shutdown same-classified-state.
+EOF
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /capture-pane -t %75 -p -S -80/);
+            assert.doesNotMatch(tmuxLog, /send-keys -t %75 -l Team same-classified-state: 1 msg\(s\) for leader\./, 'same visible classified state should not be reinjected');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+            const nudgeEvent = events.find((entry) => entry.type === 'team_leader_nudge' && entry.reason === 'new_mailbox_message');
+            assert.ok(nudgeEvent, 'suppressed visible sends should still emit leader nudge events');
+            assert.equal(nudgeEvent.orchestration_intent, 'pending-mailbox-review');
+            const deliveryLog = await readTeamDeliveryLog(cwd);
+            assert.ok(deliveryLog.some((entry) => entry.event === 'nudge_triggered'
+                && entry.team === teamName
+                && entry.to_worker === 'leader-fixed'
+                && entry.result === 'suppressed'
+                && entry.reason === 'new_mailbox_message'
+                && entry.suppression_reason === 'pane_already_shows_same_classified_state'));
+        });
+    });
+    it('does not inject leader nudge while leader pane is in copy-mode', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'scroll-guard';
+            const teamDir = join(stateDir, 'team', teamName);
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'scroll-guard:0',
+                leader_pane_id: '%72',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'm1',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'follow up',
+                        created_at: '2026-03-12T00:00:00.000Z',
+                    },
+                ],
+            });
+            const fakeTmux = `#!/usr/bin/env bash
+set -eu
+echo "$@" >> "${tmuxLogPath}"
+cmd="$1"
+shift || true
+if [[ "$cmd" == "display-message" ]]; then
+  target=""
+  format=""
+  while (($#)); do
+    case "$1" in
+      -p) shift ;;
+      -t) target="$2"; shift 2 ;;
+      *) format="$1"; shift ;;
+    esac
+  done
+  if [[ "$format" == "#{pane_in_mode}" && "$target" == "%72" ]]; then
+    echo "1"
+    exit 0
+  fi
+  if [[ "$format" == "#{pane_current_command}" && "$target" == "%72" ]]; then
+    echo "codex"
+    exit 0
+  fi
+  exit 0
+fi
+if [[ "$cmd" == "send-keys" ]]; then
+  exit 0
+fi
+if [[ "$cmd" == "list-panes" ]]; then
+  echo "%1 12345"
+  exit 0
+fi
+exit 0
+`;
+            await writeFile(fakeTmuxPath, fakeTmux);
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /display-message -p -t %72 #\{pane_in_mode\}/);
+            assert.doesNotMatch(tmuxLog, /send-keys -t %72/, 'should not inject into a scrolling leader pane');
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
+            const deferred = events.find((entry) => entry.type === 'leader_notification_deferred' && entry.reason === 'scroll_active');
+            assert.ok(deferred, 'should emit deferred event for scrolling leader pane');
+        });
+    });
+    it('syncs stale root team-state to inactive when team-local phase is already terminal', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'terminal-sync';
+            const teamDir = join(stateDir, 'team', teamName);
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(teamDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'phase.json'), {
+                current_phase: 'complete',
+                transitions: [
+                    { from: 'team-verify', to: 'complete', at: '2026-03-09T19:20:19.088Z' },
+                ],
+                updated_at: '2026-03-09T19:20:19.088Z',
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const syncedState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
+            assert.equal(syncedState.active, false);
+            assert.equal(syncedState.current_phase, 'complete');
+            assert.equal(syncedState.completed_at, '2026-03-09T19:20:19.088Z');
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys/, 'must not nudge a terminal team');
+            }
+        });
+    });
+    it('does not nudge completed teams on reopen even when config and idle worker state still exist', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'completed-reopen';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const completedAt = '2026-03-21T08:40:35.471Z';
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: false,
+                team_name: teamName,
+                current_phase: 'complete',
+                completed_at: completedAt,
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'completed-reopen:0',
+                leader_pane_id: '%91',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                    { name: 'worker-2', index: 2, pane_id: '%11', role: 'executor' },
+                ],
+            });
+            await writeJson(join(teamDir, 'phase.json'), {
+                current_phase: 'complete',
+                transitions: [{ from: 'team-verify', to: 'complete', at: completedAt }],
+                updated_at: completedAt,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: new Date().toISOString(),
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys/, 'completed teams must not re-nudge on reopen');
+            }
+        });
+    });
+    it('does not nudge a team owned by another session', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'other-session-team';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'session.json'), { session_id: 'sess-current' });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'manifest.v2.json'), {
+                schema_version: 2,
+                name: teamName,
+                task: 'session ownership repro',
+                leader: {
+                    session_id: 'sess-other',
+                    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,
+                },
+                tmux_session: 'other-session-team:0',
+                leader_pane_id: '%94',
+                worker_count: 2,
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                    { name: 'worker-2', index: 2, pane_id: '%11', role: 'executor' },
+                ],
+                created_at: nowIso,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: nowIso,
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys/, 'must not nudge teams owned by another session');
+            }
+        });
+    });
+    it('does not nudge a canonical-only team when owner session is blank', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeCanonicalTeamFixture(cwd, {
+                teamName: 'ownerless-team',
+                sessionId: 'sess-current',
+                ownerSessionId: '',
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys/, 'ownerless canonical teams must not nudge');
+            }
+        });
+    });
+    it('nudges when worker panes are alive and leader is stale (no recent HUD turn)', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'beta';
+            const teamDir = join(stateDir, 'team', teamName);
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(join(teamDir, 'mailbox'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-beta',
+                leader_pane_id: '%92',
+            });
+            // Leader HUD state is stale (last turn 5 minutes ago)
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 5,
+            });
+            // No mailbox messages — but worker panes alive should trigger nudge
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /send-keys/);
+            assert.match(tmuxLog, /Team beta:/);
+            assert.match(tmuxLog, /leader stale, \d+ worker pane\(s\) still active\./);
+            assert.match(tmuxLog, /Next: check messages; keep orchestrating; if done, gracefully shut down: rcs team shutdown beta\./);
+            assert.doesNotMatch(tmuxLog, /keep polling/);
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/, 'should include injection marker');
+        });
+    });
+    it('nudges when team progress is stalled even if timing signals are fresh or missing (fallback threshold)', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'stalled-progress';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-stalled-progress',
+                leader_pane_id: '%90',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                    { name: 'worker-2', index: 2, pane_id: '%11' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 4,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate stall',
+                description: 'worker-1 owns the active task',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'still pending',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: nowIso,
+                turn_count: 2,
+                alive: true,
+            });
+            const stalledSignature = JSON.stringify({
+                tasks: [
+                    { id: '1', owner: 'worker-1', status: 'in_progress' },
+                    { id: '2', owner: '', status: 'pending' },
+                ],
+                workers: [
+                    {
+                        worker: 'worker-1',
+                        state: 'working',
+                        current_task_id: '1',
+                        status_missing: false,
+                        turn_count: 2,
+                        heartbeat_missing: false,
+                    },
+                    {
+                        worker: 'worker-2',
+                        state: 'unknown',
+                        current_task_id: '',
+                        status_missing: true,
+                        turn_count: null,
+                        heartbeat_missing: true,
+                    },
+                ],
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(Date.now() - 5_000).toISOString(),
+                        last_message_id: '',
+                        reason: 'new_mailbox_message',
+                    },
+                },
+                progress_by_team: {
+                    [teamName]: {
+                        signature: stalledSignature,
+                        last_progress_at: new Date(Date.now() - 180_000).toISOString(),
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /Team stalled-progress: leader stale, no progress 3m(?:\d+s)?\./);
+            assert.match(tmuxLog, /Next: rcs team status stalled-progress; read worker messages; unblock\/reassign or shutdown\./);
+            assert.doesNotMatch(tmuxLog, /keep polling/);
+            assert.doesNotMatch(tmuxLog, /\[RCS_INTENT:/);
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/);
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.equal(nudgeEvent?.reason, 'stuck_waiting_on_leader');
+            assert.equal(nudgeEvent?.orchestration_intent, 'stalled-unblock');
+        });
+    });
+    it('nudges when team progress is stalled before the leader becomes stale (fallback threshold)', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'stalled-before-stale';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-stalled-before-stale',
+                leader_pane_id: '%89',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                    { name: 'worker-2', index: 2, pane_id: '%11' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 4,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate stall',
+                description: 'worker-1 owns the active task',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'still pending',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: nowIso,
+                turn_count: 2,
+                alive: true,
+            });
+            const stalledSignature = JSON.stringify({
+                tasks: [
+                    { id: '1', owner: 'worker-1', status: 'in_progress' },
+                    { id: '2', owner: '', status: 'pending' },
+                ],
+                workers: [
+                    {
+                        worker: 'worker-1',
+                        state: 'working',
+                        current_task_id: '1',
+                        status_missing: false,
+                        turn_count: 2,
+                        heartbeat_missing: false,
+                    },
+                    {
+                        worker: 'worker-2',
+                        state: 'unknown',
+                        current_task_id: '',
+                        status_missing: true,
+                        turn_count: null,
+                        heartbeat_missing: true,
+                    },
+                ],
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(Date.now() - 5_000).toISOString(),
+                        last_message_id: '',
+                        reason: 'new_mailbox_message',
+                    },
+                },
+                progress_by_team: {
+                    [teamName]: {
+                        signature: stalledSignature,
+                        last_progress_at: new Date(Date.now() - 180_000).toISOString(),
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /Team stalled-before-stale: worker panes stalled, no progress 3m(?:\d+s)?\./);
+            assert.match(tmuxLog, /Next: rcs team status stalled-before-stale; read worker messages; unblock\/reassign or shutdown\./);
+            assert.doesNotMatch(tmuxLog, /keep polling/);
+            assert.doesNotMatch(tmuxLog, /leader stale/);
+            const eventsPath = join(teamDir, 'events', 'events.ndjson');
+            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.equal(nudgeEvent?.reason, 'stuck_waiting_on_leader');
+        });
+    });
+    it('nudges stalled team after configurable worker turn stall window elapses (primary threshold)', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'worker-turn-stall-threshold';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-worker-turn-stall-threshold',
+                leader_pane_id: '%86',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 4,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate stall',
+                description: 'worker-1 owns the active task',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: nowIso,
+                turn_count: 5,
+                alive: true,
+            });
+            const previousSignature = JSON.stringify({
+                tasks: [
+                    { id: '1', owner: 'worker-1', status: 'in_progress' },
+                ],
+                workers: [
+                    {
+                        worker: 'worker-1',
+                        state: 'working',
+                        current_task_id: '1',
+                        status_missing: false,
+                        turn_count: 5,
+                        heartbeat_missing: false,
+                    },
+                ],
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(Date.now() - 60_000).toISOString(),
+                        last_message_id: '',
+                        reason: 'new_mailbox_message',
+                    },
+                },
+                progress_by_team: {
+                    [teamName]: {
+                        signature: previousSignature,
+                        last_progress_at: new Date(Date.now() - 45_000).toISOString(),
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '120000',
+                RCS_TEAM_WORKER_TURN_STALL_MS: '30000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /Team worker-turn-stall-threshold: worker panes stalled, no progress 45s\./);
+        });
+    });
+    it('does not nudge stalled team when an in-progress worker is still advancing heartbeat turns', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'active-turns-no-stall';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-active-turns-no-stall',
+                leader_pane_id: '%87',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                    { name: 'worker-2', index: 2, pane_id: '%11' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 4,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate stall',
+                description: 'worker-1 owns the active task',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'still pending',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: nowIso,
+                turn_count: 8,
+                alive: true,
+            });
+            const previousSignature = JSON.stringify({
+                tasks: [
+                    { id: '1', owner: 'worker-1', status: 'in_progress' },
+                    { id: '2', owner: '', status: 'pending' },
+                ],
+                workers: [
+                    {
+                        worker: 'worker-1',
+                        state: 'working',
+                        current_task_id: '1',
+                        status_missing: false,
+                        turn_count: 2,
+                        heartbeat_missing: false,
+                    },
+                    {
+                        worker: 'worker-2',
+                        state: 'unknown',
+                        current_task_id: '',
+                        status_missing: true,
+                        turn_count: null,
+                        heartbeat_missing: true,
+                    },
+                ]
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(Date.now() - 5_000).toISOString(),
+                        last_message_id: '',
+                        reason: 'new_mailbox_message',
+                    },
+                },
+                progress_by_team: {
+                    [teamName]: {
+                        signature: previousSignature,
+                        last_progress_at: new Date(Date.now() - 180_000).toISOString(),
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.doesNotMatch(tmuxLog, /active-turns-no-stall: worker panes stalled, no progress/);
+            assert.doesNotMatch(tmuxLog, /active-turns-no-stall: leader stale, no progress/);
+        });
+    });
+    it('bounds repeated stalled-team nudges before leader stale by cooldown', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'stalled-before-stale-bounded';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-stalled-before-stale-bounded',
+                leader_pane_id: '%88',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                    { name: 'worker-2', index: 2, pane_id: '%11' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: nowIso,
+                turn_count: 4,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Investigate stall',
+                description: 'worker-1 owns the active task',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: nowIso,
+            });
+            await writeJson(join(tasksDir, 'task-2.json'), {
+                id: '2',
+                subject: 'Follow-up',
+                description: 'still pending',
+                status: 'pending',
+                created_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: nowIso,
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: nowIso,
+                turn_count: 2,
+                alive: true,
+            });
+            const stalledSignature = JSON.stringify({
+                tasks: [
+                    { id: '1', owner: 'worker-1', status: 'in_progress' },
+                    { id: '2', owner: '', status: 'pending' },
+                ],
+                workers: [
+                    {
+                        worker: 'worker-1',
+                        state: 'working',
+                        current_task_id: '1',
+                        status_missing: false,
+                        turn_count: 2,
+                        heartbeat_missing: false,
+                    },
+                    {
+                        worker: 'worker-2',
+                        state: 'unknown',
+                        current_task_id: '',
+                        status_missing: true,
+                        turn_count: null,
+                        heartbeat_missing: true,
+                    },
+                ],
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                progress_by_team: {
+                    [teamName]: {
+                        signature: stalledSignature,
+                        last_progress_at: new Date(Date.now() - 180_000).toISOString(),
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345', '%11 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const first = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(first.status, 0, `notify-hook failed: ${first.stderr || first.stdout}`);
+            const second = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(second.status, 0, `notify-hook failed: ${second.stderr || second.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            const sends = tmuxLog.match(/send-keys -t %88 -l Team stalled-before-stale-bounded: worker panes stalled, no progress/g) || [];
+            assert.equal(sends.length, 1, 'cooldown should keep repeated stalled-team nudges bounded');
+            assert.match(tmuxLog, /Next: rcs team status stalled-before-stale-bounded; read worker messages; unblock\/reassign or shutdown\./);
+        });
+    });
+    it('does not treat leader and HUD panes as active worker panes when worker pane ids are known', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'stale-no-workers';
+            const teamDir = join(stateDir, 'team', teamName);
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(join(teamDir, 'mailbox'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-stale-no-workers',
+                leader_pane_id: '%92',
+                hud_pane_id: '%93',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10' },
+                    { name: 'worker-2', index: 2, pane_id: '%11' },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 5,
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%92 12345', '%93 12346']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.doesNotMatch(tmuxLog, /send-keys -t %92 -l Team stale-no-workers: leader stale,/);
+        });
+    });
+    it('does not send a generic periodic leader nudge when the leader is not stale', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'fresh-leader';
+            const teamDir = join(stateDir, 'team', teamName);
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(join(teamDir, 'mailbox'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-fresh',
+                leader_pane_id: '%95',
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 2,
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_NUDGE_MS: '30000' });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /Team fresh-leader/, 'non-stale leader should not receive generic periodic follow-up');
+            }
+        });
+    });
+    it('uses a 30s cadence for stale leader follow-up nudges', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'stale-cadence';
+            const teamDir = join(stateDir, 'team', teamName);
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const now = Date.now();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(join(teamDir, 'mailbox'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-stale-cadence',
+                leader_pane_id: '%96',
+            });
+            const staleHud = {
+                last_turn_at: new Date(now - 300_000).toISOString(),
+                turn_count: 5,
+            };
+            await writeJson(join(stateDir, 'hud-state.json'), staleHud);
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(now - 20_000).toISOString(),
+                        last_message_id: '',
+                    },
+                },
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const blocked = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_NUDGE_MS: '30000' });
+            assert.equal(blocked.status, 0, `notify-hook failed: ${blocked.stderr || blocked.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const firstLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(firstLog, /Team stale-cadence:/, 'stale follow-up should be blocked inside the 30s window');
+            }
+            await writeJson(join(stateDir, 'hud-state.json'), staleHud);
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(now - 31_000).toISOString(),
+                        last_message_id: '',
+                    },
+                },
+            });
+            const allowed = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_NUDGE_MS: '30000' });
+            assert.equal(allowed.status, 0, `notify-hook failed: ${allowed.stderr || allowed.stdout}`);
+            const finalLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(finalLog, /Team stale-cadence:/);
+            assert.match(finalLog, /Team stale-cadence: leader stale, \d+ worker pane\(s\) still active\./);
+        });
+    });
+    it('suppresses stale leader follow-up when detached worktree progress is still fresh', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'fresh-detached-progress';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const tasksDir = join(teamDir, 'tasks');
+            const workerWorktree = join(cwd, 'worktrees', 'worker-1');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(tasksDir, { recursive: true });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await mkdir(join(workerWorktree, '.rcs', 'state'), { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-fresh-detached-progress',
+                leader_pane_id: '%99',
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', worktree_path: workerWorktree },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 5,
+            });
+            await writeJson(join(tasksDir, 'task-1.json'), {
+                id: '1',
+                subject: 'Apply detached fix',
+                description: 'keep going',
+                status: 'in_progress',
+                owner: 'worker-1',
+                created_at: new Date(Date.now() - 300_000).toISOString(),
+            });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'working',
+                current_task_id: '1',
+                updated_at: new Date(Date.now() - 300_000).toISOString(),
+            });
+            await writeJson(join(workersDir, 'worker-1', 'heartbeat.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 2,
+                alive: true,
+            });
+            await writeJson(join(stateDir, 'team-leader-nudge.json'), {
+                last_nudged_by_team: {
+                    [teamName]: {
+                        at: new Date(Date.now() - 60_000).toISOString(),
+                        last_message_id: '',
+                        reason: 'stale_leader_panes_alive',
+                    },
+                },
+                progress_by_team: {
+                    [teamName]: {
+                        signature: JSON.stringify({
+                            tasks: [{ id: '1', owner: 'worker-1', status: 'in_progress' }],
+                            workers: [{
+                                    worker: 'worker-1',
+                                    state: 'working',
+                                    current_task_id: '1',
+                                    status_missing: false,
+                                    turn_count: 2,
+                                    heartbeat_missing: false,
+                                }],
+                        }),
+                        last_progress_at: new Date(Date.now() - 300_000).toISOString(),
+                    },
+                },
+            });
+            await writeJson(join(workerWorktree, '.rcs', 'state', 'current-task-baseline.json'), {
+                version: 1,
+                tasks: [],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmuxWithListPanes(tmuxLogPath, ['%10 12345']));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_TEAM_PROGRESS_STALL_MS: '60000',
+                RCS_TEAM_LEADER_NUDGE_MS: '30000',
+                RCS_TEAM_LEADER_STALE_MS: '60000',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /Team fresh-detached-progress: leader stale,/);
+            }
+        });
+    });
+    it('emits team_leader_nudge event to events.ndjson when nudge fires', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'gamma';
+            const teamDir = join(stateDir, 'team', teamName);
+            const eventsDir = join(teamDir, 'events');
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(eventsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-gamma',
+                leader_pane_id: '%93',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'msg-99',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'Task complete',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            // Verify event was written
+            const eventsPath = join(eventsDir, 'events.ndjson');
+            assert.ok(existsSync(eventsPath), 'events.ndjson should exist after nudge');
+            const eventsContent = await readFile(eventsPath, 'utf-8');
+            const events = eventsContent.trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.ok(nudgeEvent, 'should have a team_leader_nudge event');
+            assert.equal(nudgeEvent.team, teamName);
+            assert.equal(nudgeEvent.worker, 'leader-fixed');
+            assert.ok(nudgeEvent.reason, 'event should have a reason');
+            assert.notEqual(nudgeEvent.reason, 'leader_pane_missing_no_injection');
+            assert.ok(nudgeEvent.orchestration_intent, 'event should record an orchestration intent');
+        });
+    });
+    it('defers leader nudge when leader_pane_id is missing', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'gamma-missing-pane';
+            const teamDir = join(stateDir, 'team', teamName);
+            const eventsDir = join(teamDir, 'events');
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(eventsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'devsess:0',
+            });
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'msg-missing-pane',
+                        from_worker: 'worker-1',
+                        to_worker: 'leader-fixed',
+                        body: 'Task complete',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys -t .*devsess/, 'must not fall back to session target');
+            }
+            const eventsPath = join(eventsDir, 'events.ndjson');
+            assert.ok(existsSync(eventsPath), 'events.ndjson should exist');
+            const eventsContent = await readFile(eventsPath, 'utf-8');
+            const events = eventsContent.trim().split('\n').map(line => JSON.parse(line));
+            const deferred = events.find((e) => e.type === 'leader_notification_deferred' && e.reason === 'leader_pane_missing_no_injection');
+            assert.ok(deferred);
+            assert.equal(deferred.type, 'leader_notification_deferred');
+            assert.equal(deferred.worker, 'leader-fixed');
+            assert.equal(deferred.to_worker, 'leader-fixed');
+            assert.equal(deferred.source_type, 'leader_nudge');
+            assert.equal(deferred.tmux_session, 'devsess:0');
+            assert.equal(deferred.leader_pane_id, null);
+            assert.equal(deferred.orchestration_intent, 'pending-mailbox-review');
+            assert.equal(deferred.tmux_injection_attempted, false);
+            const nudgeStatePath = join(stateDir, 'team-leader-nudge.json');
+            assert.ok(existsSync(nudgeStatePath), 'nudge state should still advance on deferred leader visibility');
+            const nudgeState = JSON.parse(await readFile(nudgeStatePath, 'utf-8'));
+            assert.ok(nudgeState.last_nudged_by_team?.[teamName]?.at);
+            assert.equal(nudgeState.last_nudged_by_team?.[teamName]?.orchestration_intent, 'pending-mailbox-review');
+            const leaderAttentionPath = join(stateDir, 'team', teamName, 'leader-attention.json');
+            assert.ok(existsSync(leaderAttentionPath), 'leader attention state should be written from notify-hook');
+            const leaderAttention = JSON.parse(await readFile(leaderAttentionPath, 'utf-8'));
+            assert.equal(leaderAttention.source, 'notify_hook');
+            assert.equal(leaderAttention.team_name, teamName);
+            assert.equal(leaderAttention.leader_decision_state, 'still_actionable');
+            assert.equal(leaderAttention.leader_attention_pending, true);
+            assert.equal(leaderAttention.leader_attention_reason, 'new_mailbox_message');
+            assert.deepEqual(leaderAttention.attention_reasons, ['new_mailbox_message']);
+            assert.equal(leaderAttention.leader_session_active, true);
+            assert.equal(leaderAttention.leader_session_stopped_at, null);
+        });
+    });
+    it('bounds repeated all-workers-idle nudges by cooldown', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'idle-bounded';
+            const teamDir = join(stateDir, 'team', teamName);
+            const workersDir = join(teamDir, 'workers');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'idle-bounded:0',
+                leader_pane_id: '%98',
+                workers: [
+                    { name: 'worker-1', index: 1, role: 'executor', assigned_tasks: [] },
+                    { name: 'worker-2', index: 2, role: 'executor', assigned_tasks: [] },
+                ],
+            });
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date().toISOString(),
+                turn_count: 1,
+            });
+            for (const worker of ['worker-1', 'worker-2']) {
+                await mkdir(join(workersDir, worker), { recursive: true });
+                await writeJson(join(workersDir, worker, 'status.json'), {
+                    state: 'idle',
+                    updated_at: new Date().toISOString(),
+                });
+            }
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const first = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_ALL_IDLE_COOLDOWN_MS: '600000' });
+            assert.equal(first.status, 0, `notify-hook failed: ${first.stderr || first.stdout}`);
+            const second = runNotifyHook(cwd, fakeBinDir, { RCS_TEAM_LEADER_ALL_IDLE_COOLDOWN_MS: '600000' });
+            assert.equal(second.status, 0, `notify-hook failed: ${second.stderr || second.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            const sends = tmuxLog.match(/send-keys -t %98 -l \[RCS\] All 2 workers idle/g) || [];
+            assert.equal(sends.length, 1, 'cooldown should keep repeated all-workers-idle leader nudges bounded');
+            assert.doesNotMatch(tmuxLog, /\[RCS_INTENT:/);
+        });
+    });
+    it('does not nudge when no active team state exists', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(stateDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            // No team-state.json — no active team
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            // tmux log should not contain display-message for any team nudge
+            const hasLog = existsSync(tmuxLogPath);
+            if (hasLog) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /Team .+: leader stale/);
+            }
+        });
+    });
+    it('includes stale_leader_with_messages reason when both conditions met', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const teamName = 'delta';
+            const teamDir = join(stateDir, 'team', teamName);
+            const eventsDir = join(teamDir, 'events');
+            const mailboxDir = join(teamDir, 'mailbox');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(eventsDir, { recursive: true });
+            await mkdir(mailboxDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: teamName,
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(teamDir, 'config.json'), {
+                name: teamName,
+                tmux_session: 'rcs-team-delta',
+                leader_pane_id: '%94',
+            });
+            // Leader stale
+            await writeJson(join(stateDir, 'hud-state.json'), {
+                last_turn_at: new Date(Date.now() - 300_000).toISOString(),
+                turn_count: 3,
+            });
+            // Mailbox has messages
+            await writeJson(join(mailboxDir, 'leader-fixed.json'), {
+                worker: 'leader-fixed',
+                messages: [
+                    {
+                        message_id: 'combo-msg',
+                        from_worker: 'worker-2',
+                        to_worker: 'leader-fixed',
+                        body: 'done',
+                        created_at: '2026-02-14T00:00:00.000Z',
+                    },
+                ],
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir);
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /Team delta: leader stale, \d+ pane\(s\) active, 1 msg\(s\) pending\./);
+            assert.match(tmuxLog, /Next: read messages; keep orchestrating; if done, gracefully shut down: rcs team shutdown delta\./);
+            assert.doesNotMatch(tmuxLog, /keep polling/);
+            assert.match(tmuxLog, /\[RCS_TMUX_INJECT\]/, 'should include injection marker');
+            // Verify event reason
+            const eventsPath = join(eventsDir, 'events.ndjson');
+            assert.ok(existsSync(eventsPath), 'events.ndjson should exist');
+            const eventsContent = await readFile(eventsPath, 'utf-8');
+            const events = eventsContent.trim().split('\n').map(line => JSON.parse(line));
+            const nudgeEvent = events.find((e) => e.type === 'team_leader_nudge');
+            assert.ok(nudgeEvent);
+            assert.equal(nudgeEvent.reason, 'stale_leader_with_messages');
+        });
+    });
+    it('rejects invalid team_name before leader follow-up team path joins', async () => {
+        await withTempWorkingDir(async (cwd) => {
+            const rcsDir = join(cwd, '.rcs');
+            const stateDir = join(rcsDir, 'state');
+            const logsDir = join(rcsDir, 'logs');
+            const fakeBinDir = join(cwd, 'fake-bin');
+            const fakeTmuxPath = join(fakeBinDir, 'tmux');
+            const tmuxLogPath = join(cwd, 'tmux.log');
+            const validTeamName = 'valid-team';
+            const validTeamDir = join(stateDir, 'team', validTeamName);
+            const workersDir = join(validTeamDir, 'workers');
+            const nowIso = new Date().toISOString();
+            await mkdir(logsDir, { recursive: true });
+            await mkdir(workersDir, { recursive: true });
+            await mkdir(fakeBinDir, { recursive: true });
+            await writeJson(join(stateDir, 'session.json'), { session_id: 'sess-current' });
+            await writeJson(join(stateDir, 'team-state.json'), {
+                active: true,
+                team_name: '../team/valid-team',
+                current_phase: 'team-exec',
+            });
+            await writeJson(join(validTeamDir, 'manifest.v2.json'), {
+                schema_version: 2,
+                name: validTeamName,
+                task: 'invalid team path repro',
+                leader: {
+                    session_id: 'sess-current',
+                    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,
+                },
+                tmux_session: 'valid-team:0',
+                leader_pane_id: '%94',
+                worker_count: 1,
+                workers: [
+                    { name: 'worker-1', index: 1, pane_id: '%10', role: 'executor' },
+                ],
+                created_at: nowIso,
+            });
+            await mkdir(join(workersDir, 'worker-1'), { recursive: true });
+            await writeJson(join(workersDir, 'worker-1', 'status.json'), {
+                state: 'idle',
+                updated_at: nowIso,
+            });
+            await writeFile(fakeTmuxPath, buildFakeTmux(tmuxLogPath));
+            await chmod(fakeTmuxPath, 0o755);
+            const result = runNotifyHook(cwd, fakeBinDir, {
+                RCS_SESSION_ID: 'sess-current',
+            });
+            assert.equal(result.status, 0, `notify-hook failed: ${result.stderr || result.stdout}`);
+            if (existsSync(tmuxLogPath)) {
+                const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+                assert.doesNotMatch(tmuxLog, /send-keys/, 'invalid team_name must not be used for leader follow-up path resolution');
+            }
+        });
+    });
+});
+//# sourceMappingURL=notify-hook-team-leader-nudge.test.js.map