@jstn-sdk/rcs 0.1.0

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

@@ -0,0 +1,1820 @@
+import { execFileSync } from 'node:child_process';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { buildLeaderMonitoringHints, parseTeamStartArgs, teamCommand } from '../team.js';
+import { readModeState } from '../../modes/base.js';
+import { DEFAULT_MAX_WORKERS } from '../../team/state.js';
+import { appendTeamEvent, createTask, initTeamState, readTeamConfig, saveTeamConfig, updateWorkerHeartbeat, writeMonitorSnapshot, writeTaskApproval, writeWorkerStatus, } from '../../team/state.js';
+import { isRealTmuxAvailable, withTempTmuxSession } from '../../team/__tests__/tmux-test-fixture.js';
+const RCS_CLI_PATH = fileURLToPath(new URL('../rcs.js', import.meta.url));
+const ORIGINAL_RCS_TEAM_WORKER = process.env.RCS_TEAM_WORKER;
+const ORIGINAL_RCS_TEAM_STATE_ROOT = process.env.RCS_TEAM_STATE_ROOT;
+beforeEach(() => {
+    delete process.env.RCS_TEAM_WORKER;
+    delete process.env.RCS_TEAM_STATE_ROOT;
+});
+afterEach(() => {
+    if (typeof ORIGINAL_RCS_TEAM_WORKER === 'string')
+        process.env.RCS_TEAM_WORKER = ORIGINAL_RCS_TEAM_WORKER;
+    else
+        delete process.env.RCS_TEAM_WORKER;
+    if (typeof ORIGINAL_RCS_TEAM_STATE_ROOT === 'string')
+        process.env.RCS_TEAM_STATE_ROOT = ORIGINAL_RCS_TEAM_STATE_ROOT;
+    else
+        delete process.env.RCS_TEAM_STATE_ROOT;
+});
+function withoutTeamTestWorkerEnv(fn) {
+    const previousTeamWorker = process.env.RCS_TEAM_WORKER;
+    const previousTeamStateRoot = process.env.RCS_TEAM_STATE_ROOT;
+    delete process.env.RCS_TEAM_WORKER;
+    delete process.env.RCS_TEAM_STATE_ROOT;
+    let restoreImmediately = true;
+    const restore = () => {
+        if (typeof previousTeamWorker === 'string')
+            process.env.RCS_TEAM_WORKER = previousTeamWorker;
+        else
+            delete process.env.RCS_TEAM_WORKER;
+        if (typeof previousTeamStateRoot === 'string')
+            process.env.RCS_TEAM_STATE_ROOT = previousTeamStateRoot;
+        else
+            delete process.env.RCS_TEAM_STATE_ROOT;
+    };
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            restoreImmediately = false;
+            return result.finally(restore);
+        }
+        return result;
+    }
+    finally {
+        if (restoreImmediately)
+            restore();
+    }
+}
+function withMockPromptModeCodexAllowed(fn) {
+    const previous = process.env.RCS_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+    process.env.RCS_TEST_ALLOW_NONTTY_CODEX_PROMPT = '1';
+    let restoreImmediately = true;
+    const restore = () => {
+        if (typeof previous === 'string')
+            process.env.RCS_TEST_ALLOW_NONTTY_CODEX_PROMPT = previous;
+        else
+            delete process.env.RCS_TEST_ALLOW_NONTTY_CODEX_PROMPT;
+    };
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            restoreImmediately = false;
+            return result.finally(restore);
+        }
+        return result;
+    }
+    finally {
+        if (restoreImmediately)
+            restore();
+    }
+}
+async function runNodeCli(args, options) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [RCS_CLI_PATH, ...args], {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.setEncoding('utf-8');
+        child.stderr.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', reject);
+        child.on('close', (code, signal) => {
+            resolve({ code, signal, stdout, stderr });
+        });
+    });
+}
+function skipUnlessTmux(t) {
+    if (!isRealTmuxAvailable()) {
+        t.skip('tmux is not available in this environment');
+    }
+}
+function runFixtureTmux(fixture, args) {
+    return execFileSync('tmux', args, {
+        encoding: 'utf-8',
+        env: {
+            ...process.env,
+            TMUX: fixture.env.TMUX,
+            TMUX_PANE: fixture.leaderPaneId,
+        },
+    }).trim();
+}
+function fixturePaneExists(fixture, paneId) {
+    try {
+        runFixtureTmux(fixture, ['display-message', '-p', '-t', paneId, '#{pane_id}']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForFileText(filePath, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (existsSync(filePath)) {
+            const text = await readFile(filePath, 'utf-8');
+            if (text.trim() !== '')
+                return text;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    throw new Error(`timed out waiting for ${filePath}`);
+}
+describe('parseTeamStartArgs', () => {
+    it('parses default team start args with automatic detached worktrees', () => {
+        const result = parseTeamStartArgs(['2:executor', 'build', 'feature']);
+        assert.deepEqual(result.worktreeMode, { enabled: true, detached: true, name: null });
+        assert.equal(result.parsed.workerCount, 2);
+        assert.equal(result.parsed.agentType, 'executor');
+        assert.equal(result.parsed.task, 'build feature');
+        assert.equal(result.parsed.teamName, 'build-feature');
+    });
+    it('parses detached worktree mode and strips the flag', () => {
+        const result = parseTeamStartArgs(['--worktree', '3:debugger', 'fix', 'bug']);
+        assert.deepEqual(result.worktreeMode, { enabled: true, detached: true, name: null });
+        assert.equal(result.parsed.workerCount, 3);
+        assert.equal(result.parsed.agentType, 'debugger');
+        assert.equal(result.parsed.task, 'fix bug');
+        assert.equal(result.parsed.teamName, 'fix-bug');
+    });
+    it('keeps explicit --worktree detached mode as a legacy-compatible override', () => {
+        const result = parseTeamStartArgs(['--worktree', '3:debugger', 'fix', 'bug']);
+        assert.deepEqual(result.worktreeMode, { enabled: true, detached: true, name: null });
+        assert.equal(result.parsed.workerCount, 3);
+        assert.equal(result.parsed.agentType, 'debugger');
+    });
+    it('rejects deprecated rcs team ralph syntax', () => {
+        assert.throws(() => parseTeamStartArgs(['ralph', '--worktree=feature/demo', '4:executor', 'ship', 'it']), /Deprecated usage: `rcs team ralph \.\.\.` has been removed/);
+    });
+    it('accepts the maximum supported worker count', () => {
+        const result = parseTeamStartArgs([`${DEFAULT_MAX_WORKERS}:executor`, 'ship', 'it']);
+        assert.equal(result.parsed.workerCount, DEFAULT_MAX_WORKERS);
+    });
+    it('rejects worker count above the supported maximum', () => {
+        assert.throws(() => parseTeamStartArgs([`${DEFAULT_MAX_WORKERS + 1}:executor`, 'ship', 'it']), new RegExp(`Expected 1-${DEFAULT_MAX_WORKERS}`));
+    });
+    it('reuses the approved team launch hint for a short English follow-up', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-followup-en-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831.md'), '# Test spec\n');
+            const result = parseTeamStartArgs(['team']);
+            assert.equal(result.parsed.task, 'Execute approved issue 831 plan');
+            assert.equal(result.parsed.workerCount, 3);
+            assert.equal(result.parsed.agentType, 'executor');
+            assert.equal(result.parsed.explicitWorkerCount, true);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('reuses the approved team launch hint for a short Korean follow-up', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-followup-ko-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831.md'), '# Test spec\n');
+            const result = parseTeamStartArgs(['team으로', '해줘']);
+            assert.equal(result.parsed.task, 'Execute approved issue 831 plan');
+            assert.equal(result.parsed.workerCount, 3);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed for a short team follow-up when the selected PRD lists multiple team launch hints', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-followup-ambiguous-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831-ambiguous.md'), [
+                '# Approved plan',
+                '',
+                'Launch via rcs team 3:executor "Execute approved issue 831 plan"',
+                'Launch via rcs team 5:debugger "Execute alternate issue 831 plan"',
+            ].join('\n'));
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831-ambiguous.md'), '# Test spec\n');
+            assert.throws(() => parseTeamStartArgs(['team']), /approved_execution_hint_ambiguous:team/);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('does not opt normal team startup into repo-aware DAG handoff even when a stale sidecar exists', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-dag-normal-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831.md'), '# Test spec\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'team-dag-issue-831.json'), '{"schema_version":1,"nodes":[{"id":"impl","subject":"Impl","description":"Impl"}]}\n');
+            const result = parseTeamStartArgs(['3:executor', 'fix', 'unrelated', 'bug']);
+            assert.equal(result.parsed.task, 'fix unrelated bug');
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, false);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('opts into repo-aware DAG handoff when the invocation matches the approved launch hint', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-dag-approved-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831.md'), '# Test spec\n');
+            const result = parseTeamStartArgs(['3:executor', 'Execute', 'approved', 'issue', '831', 'plan']);
+            assert.equal(result.parsed.allowRepoAwareDagHandoff, true);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('attaches approved repository context summary only for matching team launches', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-context-approved-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-2039.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 2039 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-2039.md'), '# Test spec\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'repo-context-issue-2039.md'), 'Key boundary: latest approved handoff only.\n');
+            const approved = parseTeamStartArgs(['3:executor', 'Execute', 'approved', 'issue', '2039', 'plan']);
+            assert.equal(approved.parsed.approvedRepositoryContextSummary?.content, 'Key boundary: latest approved handoff only.');
+            const unrelated = parseTeamStartArgs(['3:executor', 'fix', 'unrelated', 'bug']);
+            assert.equal(unrelated.parsed.approvedRepositoryContextSummary, undefined);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('preserves explicit team staffing overrides while reusing the approved plan task', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-followup-override-'));
+        const previousCwd = process.cwd();
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'plans'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'plans', 'prd-issue-831.md'), '# Approved plan\n\nLaunch via rcs team 3:executor "Execute approved issue 831 plan"\n');
+            await writeFile(join(wd, '.rcs', 'plans', 'test-spec-issue-831.md'), '# Test spec\n');
+            const result = parseTeamStartArgs(['2:debugger', 'team']);
+            assert.equal(result.parsed.task, 'Execute approved issue 831 plan');
+            assert.equal(result.parsed.workerCount, 2);
+            assert.equal(result.parsed.agentType, 'debugger');
+            assert.equal(result.parsed.explicitWorkerCount, true);
+            assert.equal(result.parsed.explicitAgentType, true);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+describe('teamCommand shutdown --force parsing', () => {
+    it('parses --force flag from shutdown args', () => {
+        const teamArgs = ['shutdown', 'my-team', '--force'];
+        const force = teamArgs.includes('--force');
+        assert.equal(force, true);
+    });
+    it('does not set force when --force is absent', () => {
+        const teamArgs = ['shutdown', 'my-team'];
+        const force = teamArgs.includes('--force');
+        assert.equal(force, false);
+    });
+    it('parses --force regardless of position after subcommand', () => {
+        const teamArgs = ['shutdown', '--force', 'my-team'];
+        const force = teamArgs.includes('--force');
+        assert.equal(force, true);
+    });
+    it('persists cancelled team mode state on shutdown even when no team mode state existed beforehand', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-mode-state-'));
+        const previousCwd = process.cwd();
+        const originalLog = console.log;
+        const originalWarn = console.warn;
+        const logs = [];
+        const warns = [];
+        try {
+            process.chdir(wd);
+            await mkdir(join(wd, '.rcs', 'state'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'state', 'session.json'), JSON.stringify({ session_id: 'sess-team-shutdown-state' }));
+            await initTeamState('team-shutdown-mode-state', 'persist cancelled team mode state after shutdown', 'executor', 1, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            console.warn = (...args) => warns.push(args.map(String).join(' '));
+            await teamCommand(['shutdown', 'team-shutdown-mode-state', '--force']);
+            const state = await readModeState('team', wd);
+            assert.ok(state);
+            assert.equal(state?.active, false);
+            assert.equal(state?.current_phase, 'cancelled');
+            assert.equal(state?.team_name, 'team-shutdown-mode-state');
+            assert.equal(warns.length, 0);
+            assert.ok(logs.some((line) => line.includes('Team shutdown complete: team-shutdown-mode-state')));
+        }
+        finally {
+            console.log = originalLog;
+            console.warn = originalWarn;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('persists cancelled session-scoped team mode state on shutdown', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-session-mode-state-'));
+        const previousCwd = process.cwd();
+        const teamName = 'team-shutdown-scoped';
+        try {
+            process.chdir(wd);
+            const stateDir = join(wd, '.rcs', 'state');
+            const sessionId = 'sess-team-shutdown-scoped';
+            const scopedStateDir = join(stateDir, 'sessions', sessionId);
+            await mkdir(scopedStateDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(scopedStateDir, 'team-state.json'), JSON.stringify({
+                active: true,
+                mode: 'team',
+                current_phase: 'team-exec',
+                team_name: teamName,
+            }, null, 2));
+            await initTeamState(teamName, 'persist cancelled session-scoped team mode state after shutdown', 'executor', 1, wd);
+            await teamCommand(['shutdown', teamName, '--force']);
+            const scopedState = JSON.parse(await readFile(join(scopedStateDir, 'team-state.json'), 'utf-8'));
+            assert.equal(scopedState.active, false);
+            assert.equal(scopedState.current_phase, 'cancelled');
+            assert.equal(scopedState.team_name, teamName);
+            assert.ok(typeof scopedState.completed_at === 'string' && scopedState.completed_at.length > 0);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('does not create session-scoped team mode state on shutdown when only root team mode state exists', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-root-mode-only-'));
+        const previousCwd = process.cwd();
+        const teamName = 'team-shutdown-root-only';
+        const sessionId = 'sess-team-shutdown-root-only';
+        try {
+            process.chdir(wd);
+            const stateDir = join(wd, '.rcs', 'state');
+            const scopedStatePath = join(stateDir, 'sessions', sessionId, 'team-state.json');
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({
+                active: true,
+                mode: 'team',
+                current_phase: 'team-exec',
+                team_name: teamName,
+            }, null, 2));
+            await initTeamState(teamName, 'shutdown should not create scoped team mode state from a root-only mode state', 'executor', 1, wd);
+            await teamCommand(['shutdown', teamName, '--force']);
+            assert.equal(existsSync(scopedStatePath), false);
+            const rootState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
+            assert.equal(rootState.active, false);
+            assert.equal(rootState.current_phase, 'cancelled');
+            assert.equal(rootState.team_name, teamName);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('does not create session-scoped team mode state on shutdown when a stale session.json remains', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-stale-session-json-'));
+        const previousCwd = process.cwd();
+        const teamName = 'team-shutdown-stale-session';
+        const staleSessionId = 'sess-team-shutdown-stale';
+        try {
+            process.chdir(wd);
+            const stateDir = join(wd, '.rcs', 'state');
+            const staleSessionDir = join(stateDir, 'sessions', staleSessionId);
+            const scopedStatePath = join(staleSessionDir, 'team-state.json');
+            await mkdir(staleSessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: staleSessionId }));
+            await writeFile(join(staleSessionDir, 'hud-state.json'), JSON.stringify({ turn_count: 12 }, null, 2));
+            await writeFile(join(stateDir, 'team-state.json'), JSON.stringify({
+                active: true,
+                mode: 'team',
+                current_phase: 'team-exec',
+                team_name: teamName,
+            }, null, 2));
+            await initTeamState(teamName, 'shutdown should ignore stale session.json when only root team mode state exists', 'executor', 1, wd);
+            await teamCommand(['shutdown', teamName, '--force']);
+            assert.equal(existsSync(scopedStatePath), false);
+            const rootState = JSON.parse(await readFile(join(stateDir, 'team-state.json'), 'utf-8'));
+            assert.equal(rootState.active, false);
+            assert.equal(rootState.current_phase, 'cancelled');
+            assert.equal(rootState.team_name, teamName);
+        }
+        finally {
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('parses --confirm-issues from shutdown args', () => {
+        const teamArgs = ['shutdown', 'my-team', '--confirm-issues'];
+        const confirmIssues = teamArgs.includes('--confirm-issues');
+        assert.equal(confirmIssues, true);
+    });
+    it('keeps the shutdown CLI alive while tearing down a shared leader tmux session', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-shared-cli-'));
+        const binDir = join(wd, 'bin');
+        const tmuxLogPath = join(wd, 'tmux.log');
+        const tmuxPath = join(binDir, 'tmux');
+        const previousPath = process.env.PATH;
+        await mkdir(binDir, { recursive: true });
+        await writeFile(tmuxPath, `#!/bin/sh
+set -eu
+printf '%s\\n' "$*" >> "${tmuxLogPath}"
+case "$1" in
+  -V)
+    echo "tmux 3.4"
+    exit 0
+    ;;
+  list-panes)
+    case "$*" in
+      *"-F #{pane_dead} #{pane_pid}"*)
+        exit 1
+        ;;
+      *"-t leader:0 -F #{pane_id}"*"#{pane_current_command}"*)
+        printf "%%11\\tzsh\\tzsh\\n%%12\\tnode\\tnode /tmp/bin/rcs.js hud --watch\\n%%13\\tcodex\\tcodex\\n%%14\\tcodex\\tcodex\\n"
+        exit 0
+        ;;
+      *"-t leader:0 -F #{pane_id}"*)
+        printf "%%11\\n%%12\\n%%13\\n%%14\\n"
+        exit 0
+        ;;
+      *)
+        exit 1
+        ;;
+    esac
+    ;;
+  split-window)
+    printf '%%44\\n'
+    exit 0
+    ;;
+  kill-pane)
+    # Shared-session runtime coverage should validate pane-targeted teardown
+    # only. Detached leader-wrapper signal behavior is covered separately in
+    # cli/index detached-session tests.
+    exit 0
+    ;;
+  resize-pane|select-pane|has-session|show-options|show-hooks|set-hook|set-option)
+    exit 0
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+`);
+        await chmod(tmuxPath, 0o755);
+        try {
+            await initTeamState('shared-shutdown-cli', 'shared shutdown cli test', 'executor', 2, wd);
+            const config = await readTeamConfig('shared-shutdown-cli', wd);
+            assert.ok(config);
+            if (!config)
+                return;
+            config.tmux_session = 'leader:0';
+            config.leader_pane_id = '%11';
+            config.hud_pane_id = '%12';
+            config.workers[0].pane_id = '%13';
+            config.workers[1].pane_id = '%14';
+            await saveTeamConfig(config, wd);
+            const result = await runNodeCli(['team', 'shutdown', 'shared-shutdown-cli', '--force'], {
+                cwd: wd,
+                env: {
+                    ...process.env,
+                    PATH: `${binDir}:${previousPath ?? ''}`,
+                    RCS_TEAM_STATE_ROOT: join(wd, '.rcs', 'state'),
+                },
+            });
+            assert.equal(result.signal, null, `shutdown CLI received signal ${result.signal ?? 'none'}\n${result.stderr}`);
+            assert.equal(result.code, 0, `shutdown CLI exit=${result.code}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+            assert.match(result.stdout, /Team shutdown complete: shared-shutdown-cli/);
+            assert.equal(existsSync(join(wd, '.rcs', 'state', 'team', 'shared-shutdown-cli')), false);
+            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
+            assert.match(tmuxLog, /kill-pane -t %12/);
+            assert.match(tmuxLog, /kill-pane -t %13/);
+            assert.match(tmuxLog, /kill-pane -t %14/);
+            assert.doesNotMatch(tmuxLog, /kill-pane -t %11/);
+        }
+        finally {
+            if (typeof previousPath === 'string')
+                process.env.PATH = previousPath;
+            else
+                delete process.env.PATH;
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('keeps the shutdown command alive when executed inside the leader pane PTY', { concurrency: false }, async (t) => {
+        skipUnlessTmux(t);
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-shutdown-shared-in-pane-'));
+        try {
+            await withTempTmuxSession(async (fixture) => {
+                const teamName = 'shared-shutdown-in-pane';
+                const teamStateRoot = join(wd, '.rcs', 'state');
+                const hudPaneId = runFixtureTmux(fixture, ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', fixture.windowTarget, 'sleep 300']);
+                const workerPaneOne = runFixtureTmux(fixture, ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', fixture.windowTarget, 'sleep 300']);
+                const workerPaneTwo = runFixtureTmux(fixture, ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', fixture.windowTarget, 'sleep 300']);
+                await initTeamState(teamName, 'shared shutdown in-pane test', 'executor', 2, wd);
+                const config = await readTeamConfig(teamName, wd);
+                assert.ok(config);
+                if (!config)
+                    return;
+                config.tmux_session = fixture.windowTarget;
+                config.leader_pane_id = fixture.leaderPaneId;
+                config.hud_pane_id = hudPaneId;
+                config.workers[0].pane_id = workerPaneOne;
+                config.workers[1].pane_id = workerPaneTwo;
+                await saveTeamConfig(config, wd);
+                const result = await runNodeCli(['team', 'shutdown', teamName, '--force'], {
+                    cwd: wd,
+                    env: {
+                        ...process.env,
+                        RCS_AUTO_UPDATE: '0',
+                        RCS_TEAM_STATE_ROOT: teamStateRoot,
+                        TMUX: fixture.env.TMUX,
+                        TMUX_PANE: fixture.leaderPaneId,
+                    },
+                });
+                assert.equal(result.signal, null, `shutdown CLI received signal ${result.signal ?? 'none'}\n${result.stderr}`);
+                assert.equal(result.code, 0, `shutdown CLI exit=${result.code}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+                const stdout = result.stdout;
+                assert.match(stdout, new RegExp(`Team shutdown complete: ${teamName}`));
+                assert.equal(existsSync(join(teamStateRoot, 'team', teamName)), false);
+                assert.equal(fixturePaneExists(fixture, fixture.leaderPaneId), true, 'leader pane should remain alive');
+                // Exact HUD/worker-pane teardown is covered in runtime shutdown tests.
+                // This CLI test owns the stable operator contract: the command must not
+                // die by signal, it must exit 0, and explicit shutdown must remove team
+                // state while preserving leader survival in a real tmux client context.
+            });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+describe('teamCommand api', () => {
+    it('builds leader monitoring hints that keep team status visible while ON', () => {
+        const hints = buildLeaderMonitoringHints('My Team');
+        assert.equal(hints[0], 'leader_check: rcs team status my-team');
+        assert.match(hints[1] ?? '', /while ON, keep checking state/);
+        assert.match(hints[1] ?? '', /sleep 30 && rcs team status my-team/);
+    });
+    it('prints team-specific help for rcs team --help', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['--help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team \[N:agent-type\]/);
+            assert.match(logs[0] ?? '', /rcs team api <operation>/);
+            assert.match(logs[0] ?? '', /dedicated worktrees automatically by default/);
+            assert.match(logs[0] ?? '', /--worktree is deprecated/);
+            assert.match(logs[0] ?? '', /tmux-runtime surface by default/);
+            assert.match(logs[0] ?? '', /Codex App or plain outside-tmux sessions/);
+            assert.match(logs[0] ?? '', /native Codex subagents for small in-session fanout/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints team-specific help for rcs team help alias', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team \[N:agent-type\]/);
+            assert.match(logs[0] ?? '', /rcs team api <operation>/);
+            assert.match(logs[0] ?? '', /dedicated worktrees automatically by default/);
+            assert.match(logs[0] ?? '', /--worktree is deprecated/);
+            assert.match(logs[0] ?? '', /tmux-runtime surface by default/);
+            assert.match(logs[0] ?? '', /Codex App or plain outside-tmux sessions/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints team-api-specific help for rcs team api --help', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['api', '--help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team api <operation>/);
+            assert.match(logs[0] ?? '', /send-message/);
+            assert.match(logs[0] ?? '', /transition-task-status/);
+            assert.match(logs[0] ?? '', /read-idle-state/);
+            assert.match(logs[0] ?? '', /read-stall-state/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints team-api-specific help for rcs team api help alias', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['api', 'help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team api <operation>/);
+            assert.match(logs[0] ?? '', /send-message/);
+            assert.match(logs[0] ?? '', /transition-task-status/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints operation-specific help for rcs team api <operation> --help', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['api', 'send-message', '--help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team api send-message --input <json> \[--json\]/);
+            assert.match(logs[0] ?? '', /Required input fields/);
+            assert.match(logs[0] ?? '', /from_worker/);
+            assert.match(logs[0] ?? '', /to_worker/);
+            assert.match(logs[0] ?? '', /body/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints operation-specific help for rcs team api <operation> help alias', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['api', 'claim-task', 'help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team api claim-task --input <json> \[--json\]/);
+            assert.match(logs[0] ?? '', /expected_version/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('prints event query help for rcs team api read-events help alias', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand(['api', 'read-events', 'help']);
+            assert.equal(logs.length, 1);
+            assert.match(logs[0] ?? '', /Usage: rcs team api read-events --input <json> \[--json\]/);
+            assert.match(logs[0] ?? '', /after_event_id/);
+            assert.match(logs[0] ?? '', /wakeable_only/);
+            assert.match(logs[0] ?? '', /worker_idle/);
+        }
+        finally {
+            console.log = originalLog;
+        }
+    });
+    it('executes read-events via CLI api with canonical JSON results', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-read-events-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('api-read-events', 'api event test', 'executor', 1, wd);
+            await appendTeamEvent('api-read-events', {
+                type: 'worker_idle',
+                worker: 'worker-1',
+                task_id: '1',
+                prev_state: 'working',
+            }, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'read-events',
+                '--input',
+                JSON.stringify({
+                    team_name: 'api-read-events',
+                    type: 'worker_idle',
+                    worker: 'worker-1',
+                    task_id: '1',
+                }),
+                '--json',
+            ]);
+            assert.equal(logs.length, 1);
+            const envelope = JSON.parse(logs[0]);
+            assert.equal(envelope.command, 'rcs team api read-events');
+            assert.equal(envelope.ok, true);
+            assert.equal(envelope.operation, 'read-events');
+            assert.equal(envelope.data?.count, 1);
+            assert.equal(envelope.data?.events?.[0]?.type, 'worker_state_changed');
+            assert.equal(envelope.data?.events?.[0]?.source_type, 'worker_idle');
+            assert.equal(envelope.data?.events?.[0]?.worker, 'worker-1');
+            assert.equal(envelope.data?.events?.[0]?.task_id, '1');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('executes read-idle-state via CLI api with structured JSON results', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-read-idle-state-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('api-read-idle', 'api idle state test', 'executor', 2, wd);
+            await writeMonitorSnapshot('api-read-idle', {
+                taskStatusById: {},
+                workerAliveByName: { 'worker-1': true, 'worker-2': true },
+                workerStateByName: { 'worker-1': 'idle', 'worker-2': 'working' },
+                workerTurnCountByName: { 'worker-1': 2, 'worker-2': 4 },
+                workerTaskIdByName: { 'worker-1': '', 'worker-2': '1' },
+                mailboxNotifiedByMessageId: {},
+                completedEventTaskIds: {},
+            }, wd);
+            await appendTeamEvent('api-read-idle', {
+                type: 'worker_idle',
+                worker: 'worker-1',
+                task_id: '1',
+                prev_state: 'working',
+            }, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'read-idle-state',
+                '--input',
+                JSON.stringify({ team_name: 'api-read-idle' }),
+                '--json',
+            ]);
+            assert.equal(logs.length, 1);
+            const envelope = JSON.parse(logs[0]);
+            assert.equal(envelope.command, 'rcs team api read-idle-state');
+            assert.equal(envelope.ok, true);
+            assert.equal(envelope.operation, 'read-idle-state');
+            assert.equal(envelope.data?.all_workers_idle, false);
+            assert.equal(envelope.data?.idle_worker_count, 1);
+            assert.deepEqual(envelope.data?.idle_workers, ['worker-1']);
+            assert.deepEqual(envelope.data?.non_idle_workers, ['worker-2']);
+            assert.equal(envelope.data?.last_idle_transition_by_worker?.['worker-1']?.source_type, 'worker_idle');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('executes read-stall-state via CLI api with structured JSON results', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-read-stall-state-'));
+        const previousCwd = process.cwd();
+        const previousTeamStateRoot = process.env.RCS_TEAM_STATE_ROOT;
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            delete process.env.RCS_TEAM_STATE_ROOT;
+            process.chdir(wd);
+            await initTeamState('api-read-stall', 'api stall state test', 'executor', 2, wd);
+            const task = await createTask('api-read-stall', {
+                subject: 'Pending work',
+                description: 'Needs leader attention',
+                status: 'pending',
+            }, wd);
+            await writeWorkerStatus('api-read-stall', 'worker-1', {
+                state: 'working',
+                current_task_id: task.id,
+                updated_at: '2026-03-10T10:00:00.000Z',
+            }, wd);
+            await writeWorkerStatus('api-read-stall', 'worker-2', {
+                state: 'idle',
+                updated_at: '2026-03-10T10:00:00.000Z',
+            }, wd);
+            await updateWorkerHeartbeat('api-read-stall', 'worker-1', {
+                alive: true,
+                pid: 201,
+                turn_count: 1,
+                last_turn_at: '2026-03-10T10:00:00.000Z',
+            }, wd);
+            await updateWorkerHeartbeat('api-read-stall', 'worker-2', {
+                alive: true,
+                pid: 202,
+                turn_count: 1,
+                last_turn_at: '2026-03-10T10:00:00.000Z',
+            }, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'get-summary',
+                '--input',
+                JSON.stringify({ team_name: 'api-read-stall' }),
+                '--json',
+            ]);
+            logs.length = 0;
+            await updateWorkerHeartbeat('api-read-stall', 'worker-1', {
+                alive: true,
+                pid: 201,
+                turn_count: 8,
+                last_turn_at: '2026-03-10T10:05:00.000Z',
+            }, wd);
+            await writeMonitorSnapshot('api-read-stall', {
+                taskStatusById: { [task.id]: 'pending' },
+                workerAliveByName: { 'worker-1': true, 'worker-2': true },
+                workerStateByName: { 'worker-1': 'idle', 'worker-2': 'idle' },
+                workerTurnCountByName: { 'worker-1': 8, 'worker-2': 1 },
+                workerTaskIdByName: { 'worker-1': task.id, 'worker-2': '' },
+                mailboxNotifiedByMessageId: {},
+                completedEventTaskIds: {},
+            }, wd);
+            await mkdir(join(wd, '.rcs', 'state', 'team', 'api-read-stall'), { recursive: true });
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'api-read-stall', 'leader-attention.json'), JSON.stringify({
+                team_name: 'api-read-stall',
+                updated_at: '2026-03-10T10:05:00.000Z',
+                source: 'native_stop',
+                leader_decision_state: 'still_actionable',
+                leader_attention_pending: true,
+                leader_attention_reason: 'leader_session_stopped',
+                attention_reasons: ['leader_session_stopped'],
+                leader_stale: false,
+                leader_session_active: false,
+                leader_session_id: 'leader-session-1',
+                leader_session_stopped_at: '2026-03-10T10:05:00.000Z',
+                unread_leader_message_count: 1,
+                work_remaining: true,
+                stalled_for_ms: null,
+            }, null, 2));
+            await teamCommand([
+                'api',
+                'read-stall-state',
+                '--input',
+                JSON.stringify({ team_name: 'api-read-stall' }),
+                '--json',
+            ]);
+            assert.equal(logs.length, 1);
+            const envelope = JSON.parse(logs[0]);
+            assert.equal(envelope.command, 'rcs team api read-stall-state');
+            assert.equal(envelope.ok, true);
+            assert.equal(envelope.operation, 'read-stall-state');
+            assert.equal(envelope.data?.team_stalled, true);
+            assert.equal(envelope.data?.leader_stale, true);
+            assert.deepEqual(envelope.data?.stalled_workers, ['worker-1']);
+            assert.match((envelope.data?.reasons ?? []).join(' '), /leader_attention_pending:leader_session_stopped/);
+        }
+        finally {
+            if (typeof previousTeamStateRoot === 'string')
+                process.env.RCS_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.RCS_TEAM_STATE_ROOT;
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('executes CLI interop operation with stable JSON envelope', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('api-team', 'api test', 'executor', 1, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'send-message',
+                '--input',
+                JSON.stringify({
+                    team_name: 'api-team',
+                    from_worker: 'worker-1',
+                    to_worker: 'leader-fixed',
+                    body: 'ACK',
+                }),
+                '--json',
+            ]);
+            assert.equal(logs.length, 1);
+            const envelope = JSON.parse(logs[0]);
+            assert.equal(envelope.schema_version, '1.0');
+            assert.equal(typeof envelope.timestamp, 'string');
+            assert.equal(envelope.command, 'rcs team api send-message');
+            assert.equal(envelope.ok, true);
+            assert.equal(envelope.operation, 'send-message');
+            assert.equal(envelope.data?.message?.body, 'ACK');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('returns deterministic JSON errors for invalid api usage with --json', async () => {
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            process.exitCode = 0;
+            await teamCommand(['api', 'unknown-operation', '--json']);
+            assert.equal(logs.length, 1);
+            const envelope = JSON.parse(logs[0]);
+            assert.equal(envelope.schema_version, '1.0');
+            assert.equal(typeof envelope.timestamp, 'string');
+            assert.equal(envelope.command, 'rcs team api');
+            assert.equal(envelope.ok, false);
+            assert.equal(envelope.operation, 'unknown');
+            assert.equal(envelope.error?.code, 'invalid_input');
+            assert.match(envelope.error?.message ?? '', /Usage: rcs team api/);
+            assert.equal(process.exitCode, 1);
+        }
+        finally {
+            console.log = originalLog;
+            process.exitCode = 0;
+        }
+    });
+    it('supports claim-safe lifecycle via CLI api (create -> claim -> transition)', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-lifecycle-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('lifecycle-team', 'lifecycle test', 'executor', 1, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'create-task',
+                '--input',
+                JSON.stringify({
+                    team_name: 'lifecycle-team',
+                    subject: 'Lifecycle task',
+                    description: 'Created through CLI interop',
+                }),
+                '--json',
+            ]);
+            const created = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(created.ok, true);
+            const taskId = created.data?.task?.id;
+            assert.equal(typeof taskId, 'string');
+            await teamCommand([
+                'api',
+                'claim-task',
+                '--input',
+                JSON.stringify({
+                    team_name: 'lifecycle-team',
+                    task_id: taskId,
+                    worker: 'worker-1',
+                    expected_version: 1,
+                }),
+                '--json',
+            ]);
+            const claimed = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(claimed.ok, true);
+            const claimToken = claimed.data?.claimToken;
+            assert.equal(typeof claimToken, 'string');
+            await teamCommand([
+                'api',
+                'transition-task-status',
+                '--input',
+                JSON.stringify({
+                    team_name: 'lifecycle-team',
+                    task_id: taskId,
+                    from: 'in_progress',
+                    to: 'completed',
+                    claim_token: claimToken,
+                }),
+                '--json',
+            ]);
+            const transitioned = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(transitioned.ok, true);
+            assert.equal(transitioned.data?.ok, true);
+            assert.equal(transitioned.data?.task?.status, 'completed');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('accepts new canonical event types via CLI api append-event', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-api-event-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('event-team', 'event test', 'executor', 1, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await teamCommand([
+                'api',
+                'append-event',
+                '--input',
+                JSON.stringify({
+                    team_name: 'event-team',
+                    type: 'leader_notification_deferred',
+                    worker: 'worker-1',
+                    to_worker: 'leader-fixed',
+                    source_type: 'worker_idle',
+                    reason: 'leader_pane_missing_no_injection',
+                }),
+                '--json',
+            ]);
+            const envelope = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(envelope.ok, true);
+            assert.equal(envelope.data?.event?.type, 'leader_notification_deferred');
+            assert.equal(envelope.data?.event?.to_worker, 'leader-fixed');
+            assert.equal(envelope.data?.event?.source_type, 'worker_idle');
+            assert.equal(envelope.data?.event?.reason, 'leader_pane_missing_no_injection');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+describe('teamCommand status', () => {
+    it('prints pane ids and raw inspect hints when tmux panes are recorded', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-panes-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            const config = await withoutTeamTestWorkerEnv(() => initTeamState('pane-team', 'inspect worker panes', 'executor', 2, wd));
+            await withoutTeamTestWorkerEnv(() => createTask('pane-team', {
+                subject: 'Recover worker-1 progress',
+                description: 'Inspect worker-1 pane',
+                status: 'pending',
+                version: 3,
+                requires_code_change: true,
+                role: 'debugger',
+                owner: 'worker-1',
+            }, wd));
+            await withoutTeamTestWorkerEnv(() => createTask('pane-team', {
+                subject: 'Recover worker-2 progress',
+                description: 'Inspect worker-2 pane',
+                status: 'pending',
+                version: 4,
+                requires_code_change: false,
+                blocked_by: ['1'],
+                depends_on: ['1'],
+                role: 'test-engineer',
+                owner: 'worker-2',
+                result: 'waiting on worker-1',
+                error: 'blocked by dependency',
+            }, wd));
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-team', 'tasks', 'task-1.json'), `${JSON.stringify({
+                ...JSON.parse(await readFile(join(wd, '.rcs', 'state', 'team', 'pane-team', 'tasks', 'task-1.json'), 'utf-8')),
+                created_at: '2026-03-10T23:55:00.000Z',
+                claim: {
+                    owner: 'worker-1',
+                    token: 'claim-token-1',
+                    leased_until: '2026-03-11T00:10:00.000Z',
+                },
+            }, null, 2)}\n`);
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-team', 'tasks', 'task-2.json'), `${JSON.stringify({
+                ...JSON.parse(await readFile(join(wd, '.rcs', 'state', 'team', 'pane-team', 'tasks', 'task-2.json'), 'utf-8')),
+                created_at: '2026-03-10T23:56:00.000Z',
+                completed_at: '2026-03-11T00:06:00.000Z',
+            }, null, 2)}\n`);
+            config.workers[0].worker_cli = 'codex';
+            config.workers[1].worker_cli = 'gemini';
+            config.workers[0].pid = 101;
+            config.workers[1].pid = 102;
+            config.workers[0].assigned_tasks = ['1'];
+            config.workers[1].assigned_tasks = ['2', '3'];
+            config.leader_pane_id = '%10';
+            config.hud_pane_id = '%11';
+            config.workers[0].pane_id = '%21';
+            config.workers[1].pane_id = '%22';
+            config.workers[0].working_dir = '/tmp/pane-team/worker-1';
+            config.workers[1].working_dir = '/tmp/pane-team/worker-2';
+            config.workers[0].worktree_repo_root = '/tmp/pane-team/repo';
+            config.workers[1].worktree_repo_root = '/tmp/pane-team/repo';
+            config.workers[0].team_state_root = '/tmp/pane-team/.rcs/state';
+            config.workers[1].team_state_root = '/tmp/pane-team/.rcs/state';
+            config.workers[0].worktree_path = '/tmp/pane-team/worktrees/worker-1';
+            config.workers[1].worktree_path = '/tmp/pane-team/worktrees/worker-2';
+            config.workers[0].worktree_branch = 'feat/pane-team-worker-1';
+            config.workers[1].worktree_branch = 'feat/pane-team-worker-2';
+            config.workers[0].worktree_detached = false;
+            config.workers[1].worktree_detached = true;
+            config.workers[0].worktree_created = true;
+            config.workers[1].worktree_created = false;
+            await writeWorkerStatus('pane-team', 'worker-1', {
+                state: 'working',
+                current_task_id: '1',
+                reason: 'recovering progress',
+                updated_at: '2026-03-11T00:00:00.000Z',
+            }, wd);
+            await writeWorkerStatus('pane-team', 'worker-2', {
+                state: 'blocked',
+                current_task_id: '2',
+                reason: 'waiting for dependency 1',
+                updated_at: '2026-03-11T00:00:00.000Z',
+            }, wd);
+            await updateWorkerHeartbeat('pane-team', 'worker-1', {
+                pid: 101,
+                last_turn_at: '2026-03-11T00:01:00.000Z',
+                turn_count: 3,
+                alive: false,
+            }, wd);
+            await updateWorkerHeartbeat('pane-team', 'worker-2', {
+                pid: 102,
+                last_turn_at: '2026-03-11T00:02:00.000Z',
+                turn_count: 4,
+                alive: false,
+            }, wd);
+            await writeTaskApproval('pane-team', {
+                task_id: '1',
+                required: true,
+                status: 'approved',
+                reviewer: 'leader-fixed',
+                decision_reason: 'Looks good',
+                decided_at: '2026-03-11T00:05:00.000Z',
+            }, wd);
+            const manifestPath = join(wd, '.rcs', 'state', 'team', 'pane-team', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.leader_pane_id = config.leader_pane_id;
+            manifest.hud_pane_id = config.hud_pane_id;
+            manifest.workers = config.workers.map((worker) => ({
+                ...worker,
+                pane_id: worker.pane_id,
+            }));
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-team', 'config.json'), `${JSON.stringify(config, null, 2)}\n`);
+            await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-team']));
+            const output = logs.join('\n');
+            assert.match(output, /panes: leader=%10 hud=%11/);
+            assert.match(output, /worker_panes: worker-1=%21 worker-2=%22/);
+            assert.match(output, /inspect_hint: raw tmux capture commands are quota-free/);
+            assert.match(output, /inspect_leader: tmux capture-pane -p -t %10 -S -400/);
+            assert.match(output, /inspect_hud: tmux capture-pane -p -t %11 -S -400/);
+            assert.match(output, /inspect_worker-1: tmux capture-pane -p -t %21 -S -400/);
+            assert.match(output, /inspect_worker-2: tmux capture-pane -p -t %22 -S -400/);
+            assert.match(output, /inspect_summary: .*command=tmux capture-pane -p -t %21 -S -400/);
+            assert.doesNotMatch(output
+                .split('\n')
+                .filter((line) => !line.includes('--model-inspect'))
+                .join('\n'), /rcs sparkshell/);
+            logs.length = 0;
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-team', '--model-inspect']));
+            const modelInspectOutput = logs.join('\n');
+            assert.match(modelInspectOutput, /inspect_summary: .*command=rcs sparkshell --tmux-pane %21 --tail-lines 400/);
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('returns pane ids and sparkshell hint in JSON mode', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-json-'));
+        const previousCwd = process.cwd();
+        const previousTeamStateRoot = process.env.RCS_TEAM_STATE_ROOT;
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            delete process.env.RCS_TEAM_STATE_ROOT;
+            process.chdir(wd);
+            const config = await withoutTeamTestWorkerEnv(() => initTeamState('pane-json-team', 'inspect worker panes', 'executor', 1, wd));
+            await withoutTeamTestWorkerEnv(() => createTask('pane-json-team', {
+                subject: 'Recover worker-1 progress',
+                description: 'Inspect worker-1 pane',
+                status: 'pending',
+                version: 7,
+                requires_code_change: true,
+                role: 'debugger',
+                owner: 'worker-1',
+            }, wd));
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-json-team', 'tasks', 'task-1.json'), `${JSON.stringify({
+                ...JSON.parse(await readFile(join(wd, '.rcs', 'state', 'team', 'pane-json-team', 'tasks', 'task-1.json'), 'utf-8')),
+                created_at: '2026-03-10T23:57:00.000Z',
+                claim: {
+                    owner: 'worker-1',
+                    token: 'claim-token-1',
+                    leased_until: '2026-03-11T00:11:00.000Z',
+                },
+            }, null, 2)}\n`);
+            config.workers[0].worker_cli = 'claude';
+            config.workers[0].pid = 201;
+            config.workers[0].assigned_tasks = ['1', 'extra-2'];
+            config.leader_pane_id = '%30';
+            config.hud_pane_id = '%31';
+            config.workers[0].pane_id = '%41';
+            config.workers[0].working_dir = '/tmp/pane-json-team/worker-1';
+            config.workers[0].worktree_repo_root = '/tmp/pane-json-team/repo';
+            config.workers[0].team_state_root = '/tmp/pane-json-team/.rcs/state';
+            config.workers[0].worktree_path = '/tmp/pane-json-team/worktrees/worker-1';
+            config.workers[0].worktree_branch = 'feat/pane-json-team-worker-1';
+            config.workers[0].worktree_detached = false;
+            config.workers[0].worktree_created = true;
+            await writeWorkerStatus('pane-json-team', 'worker-1', {
+                state: 'working',
+                current_task_id: '1',
+                reason: 'recovering progress',
+                updated_at: '2026-03-11T00:00:00.000Z',
+            }, wd);
+            await updateWorkerHeartbeat('pane-json-team', 'worker-1', {
+                pid: 201,
+                last_turn_at: '2026-03-11T00:03:00.000Z',
+                turn_count: 5,
+                alive: false,
+            }, wd);
+            await writeTaskApproval('pane-json-team', {
+                task_id: '1',
+                required: true,
+                status: 'approved',
+                reviewer: 'leader-fixed',
+                decision_reason: 'Looks good',
+                decided_at: '2026-03-11T00:05:00.000Z',
+            }, wd);
+            const manifestPath = join(wd, '.rcs', 'state', 'team', 'pane-json-team', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.leader_pane_id = config.leader_pane_id;
+            manifest.hud_pane_id = config.hud_pane_id;
+            manifest.workers = config.workers.map((worker) => ({
+                ...worker,
+                pane_id: worker.pane_id,
+            }));
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-json-team', 'config.json'), `${JSON.stringify(config, null, 2)}\n`);
+            await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-json-team', '--json']));
+            const payload = JSON.parse(logs.at(-1) ?? '{}');
+            const expectedWd = process.platform === 'darwin' && wd.startsWith('/var/')
+                ? `/private${wd}`
+                : wd;
+            assert.equal(payload.schema_version, '1.0');
+            assert.equal(typeof payload.timestamp, 'string');
+            assert.equal(payload.command, 'rcs team status');
+            assert.equal(payload.team_name, 'pane-json-team');
+            assert.equal(payload.status, 'ok');
+            assert.deepEqual(payload.dead_workers, ['worker-1']);
+            assert.deepEqual(payload.non_reporting_workers, []);
+            assert.deepEqual(payload.panes?.recommended_inspect_targets, ['worker-1']);
+            assert.deepEqual(payload.panes?.recommended_inspect_reasons, { 'worker-1': 'dead_worker' });
+            assert.deepEqual(payload.panes?.recommended_inspect_clis, { 'worker-1': 'claude' });
+            assert.deepEqual(payload.panes?.recommended_inspect_roles, { 'worker-1': 'executor' });
+            assert.deepEqual(payload.panes?.recommended_inspect_indexes, { 'worker-1': 1 });
+            assert.deepEqual(payload.panes?.recommended_inspect_alive, { 'worker-1': false });
+            assert.deepEqual(payload.panes?.recommended_inspect_turn_counts, { 'worker-1': 5 });
+            assert.deepEqual(payload.panes?.recommended_inspect_turns_without_progress, { 'worker-1': 0 });
+            assert.deepEqual(payload.panes?.recommended_inspect_last_turn_at, { 'worker-1': '2026-03-11T00:03:00.000Z' });
+            assert.deepEqual(payload.panes?.recommended_inspect_status_updated_at, { 'worker-1': '2026-03-11T00:00:00.000Z' });
+            assert.deepEqual(payload.panes?.recommended_inspect_pids, { 'worker-1': 201 });
+            assert.deepEqual(payload.panes?.recommended_inspect_worktree_paths, { 'worker-1': '/tmp/pane-json-team/worktrees/worker-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_worktree_repo_roots, { 'worker-1': '/tmp/pane-json-team/repo' });
+            assert.deepEqual(payload.panes?.recommended_inspect_worktree_branches, { 'worker-1': 'feat/pane-json-team-worker-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_worktree_detached, { 'worker-1': false });
+            assert.deepEqual(payload.panes?.recommended_inspect_worktree_created, { 'worker-1': true });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_state_roots, { 'worker-1': '/tmp/pane-json-team/.rcs/state' });
+            assert.deepEqual(payload.panes?.recommended_inspect_workdirs, { 'worker-1': '/tmp/pane-json-team/worker-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_assigned_tasks, { 'worker-1': ['1', 'extra-2'] });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_statuses, { 'worker-1': 'pending' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_results, { 'worker-1': null });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_errors, { 'worker-1': null });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_versions, { 'worker-1': 1 });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_created_at, { 'worker-1': '2026-03-10T23:57:00.000Z' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_completed_at, { 'worker-1': null });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_depends_on, { 'worker-1': [] });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_claim_present, { 'worker-1': true });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_claim_owners, { 'worker-1': 'worker-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_claim_tokens, { 'worker-1': 'claim-token-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_claim_leases, { 'worker-1': '2026-03-11T00:11:00.000Z' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_required, { 'worker-1': true });
+            assert.deepEqual(payload.panes?.recommended_inspect_requires_code_change, { 'worker-1': true });
+            assert.deepEqual(payload.panes?.recommended_inspect_descriptions, { 'worker-1': 'Inspect worker-1 pane' });
+            assert.deepEqual(payload.panes?.recommended_inspect_blocked_by, { 'worker-1': [] });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_roles, { 'worker-1': 'debugger' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_owners, { 'worker-1': 'worker-1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_statuses, { 'worker-1': 'approved' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_reviewers, { 'worker-1': 'leader-fixed' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_reasons, { 'worker-1': 'Looks good' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_decided_at, { 'worker-1': '2026-03-11T00:05:00.000Z' });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_record_present, { 'worker-1': true });
+            assert.deepEqual(payload.panes?.recommended_inspect_states, { 'worker-1': 'working' });
+            assert.deepEqual(payload.panes?.recommended_inspect_state_reasons, { 'worker-1': 'recovering progress' });
+            assert.deepEqual(payload.panes?.recommended_inspect_tasks, { 'worker-1': '1' });
+            assert.deepEqual(payload.panes?.recommended_inspect_subjects, { 'worker-1': 'Recover worker-1 progress' });
+            assert.deepEqual(payload.panes?.recommended_inspect_task_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/tasks/task-1.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_approval_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/approvals/task-1.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_state_dirs, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_status_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/status.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_heartbeat_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/heartbeat.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_identity_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/identity.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_inbox_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/inbox.md` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_mailbox_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/mailbox/worker-1.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_shutdown_request_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/shutdown-request.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_worker_shutdown_ack_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/shutdown-ack.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_dir_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_config_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/config.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_manifest_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/manifest.v2.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_events_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/events/events.ndjson` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_dispatch_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/dispatch/requests.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_phase_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/phase.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_monitor_snapshot_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/monitor-snapshot.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_team_summary_snapshot_paths, { 'worker-1': `${expectedWd}/.rcs/state/team/pane-json-team/summary-snapshot.json` });
+            assert.deepEqual(payload.panes?.recommended_inspect_panes, { 'worker-1': '%41' });
+            assert.equal(payload.panes?.recommended_inspect_command, 'rcs sparkshell --tmux-pane %41 --tail-lines 400');
+            assert.deepEqual(payload.panes?.recommended_inspect_commands, ['rcs sparkshell --tmux-pane %41 --tail-lines 400']);
+            assert.equal(payload.panes?.recommended_inspect_summary, 'target=worker-1 pane=%41 cli=claude role=executor alive=false turn_count=5 turns_without_progress=0 reason=dead_worker state=working task=1 subject=Recover worker-1 progress command=rcs sparkshell --tmux-pane %41 --tail-lines 400');
+            assert.deepEqual(payload.panes?.recommended_inspect_items, [{
+                    target: 'worker-1',
+                    pane_id: '%41',
+                    worker_cli: 'claude',
+                    role: 'executor',
+                    index: 1,
+                    alive: false,
+                    turn_count: 5,
+                    turns_without_progress: 0,
+                    last_turn_at: '2026-03-11T00:03:00.000Z',
+                    status_updated_at: '2026-03-11T00:00:00.000Z',
+                    pid: 201,
+                    worktree_repo_root: '/tmp/pane-json-team/repo',
+                    worktree_path: '/tmp/pane-json-team/worktrees/worker-1',
+                    worktree_branch: 'feat/pane-json-team-worker-1',
+                    worktree_detached: false,
+                    worktree_created: true,
+                    team_state_root: '/tmp/pane-json-team/.rcs/state',
+                    working_dir: '/tmp/pane-json-team/worker-1',
+                    assigned_tasks: ['1', 'extra-2'],
+                    task_status: 'pending',
+                    task_result: null,
+                    task_error: null,
+                    task_version: 1,
+                    task_created_at: '2026-03-10T23:57:00.000Z',
+                    task_completed_at: null,
+                    task_depends_on: [],
+                    task_claim_present: true,
+                    task_claim_owner: 'worker-1',
+                    task_claim_token: 'claim-token-1',
+                    task_claim_leased_until: '2026-03-11T00:11:00.000Z',
+                    task_claim_lock_path: `${expectedWd}/.rcs/state/team/pane-json-team/claims/task-1.lock`,
+                    approval_required: true,
+                    requires_code_change: true,
+                    task_description: 'Inspect worker-1 pane',
+                    blocked_by: [],
+                    task_role: 'debugger',
+                    task_owner: 'worker-1',
+                    approval_status: 'approved',
+                    approval_reviewer: 'leader-fixed',
+                    approval_reason: 'Looks good',
+                    approval_decided_at: '2026-03-11T00:05:00.000Z',
+                    approval_record_present: true,
+                    reason: 'dead_worker',
+                    state: 'working',
+                    state_reason: 'recovering progress',
+                    task_id: '1',
+                    task_subject: 'Recover worker-1 progress',
+                    task_path: `${expectedWd}/.rcs/state/team/pane-json-team/tasks/task-1.json`,
+                    approval_path: `${expectedWd}/.rcs/state/team/pane-json-team/approvals/task-1.json`,
+                    worker_state_dir: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1`,
+                    worker_status_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/status.json`,
+                    worker_heartbeat_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/heartbeat.json`,
+                    worker_identity_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/identity.json`,
+                    worker_inbox_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/inbox.md`,
+                    worker_mailbox_path: `${expectedWd}/.rcs/state/team/pane-json-team/mailbox/worker-1.json`,
+                    worker_shutdown_request_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/shutdown-request.json`,
+                    worker_shutdown_ack_path: `${expectedWd}/.rcs/state/team/pane-json-team/workers/worker-1/shutdown-ack.json`,
+                    team_dir_path: `${expectedWd}/.rcs/state/team/pane-json-team`,
+                    team_config_path: `${expectedWd}/.rcs/state/team/pane-json-team/config.json`,
+                    team_manifest_path: `${expectedWd}/.rcs/state/team/pane-json-team/manifest.v2.json`,
+                    team_events_path: `${expectedWd}/.rcs/state/team/pane-json-team/events/events.ndjson`,
+                    team_dispatch_path: `${expectedWd}/.rcs/state/team/pane-json-team/dispatch/requests.json`,
+                    team_phase_path: `${expectedWd}/.rcs/state/team/pane-json-team/phase.json`,
+                    team_monitor_snapshot_path: `${expectedWd}/.rcs/state/team/pane-json-team/monitor-snapshot.json`,
+                    team_summary_snapshot_path: `${expectedWd}/.rcs/state/team/pane-json-team/summary-snapshot.json`,
+                    command: 'rcs sparkshell --tmux-pane %41 --tail-lines 400',
+                }]);
+            assert.equal(payload.panes?.leader_pane_id, '%30');
+            assert.equal(payload.panes?.hud_pane_id, '%31');
+            assert.deepEqual(payload.panes?.worker_panes, { 'worker-1': '%41' });
+            assert.equal(payload.panes?.sparkshell_hint, 'rcs sparkshell --tmux-pane <pane-id> --tail-lines 400');
+            assert.deepEqual(payload.panes?.sparkshell_commands, {
+                leader: 'rcs sparkshell --tmux-pane %30 --tail-lines 400',
+                hud: 'rcs sparkshell --tmux-pane %31 --tail-lines 400',
+                'worker-1': 'rcs sparkshell --tmux-pane %41 --tail-lines 400',
+            });
+        }
+        finally {
+            if (typeof previousTeamStateRoot === 'string')
+                process.env.RCS_TEAM_STATE_ROOT = previousTeamStateRoot;
+            else
+                delete process.env.RCS_TEAM_STATE_ROOT;
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('prints workspace_mode in text status output when present', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-workspace-mode-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            const config = await withoutTeamTestWorkerEnv(() => initTeamState('workspace-mode-team', 'inspect workspace mode', 'executor', 1, wd));
+            config.workspace_mode = 'worktree';
+            const teamDir = join(wd, '.rcs', 'state', 'team', 'workspace-mode-team');
+            const configPath = join(teamDir, 'config.json');
+            const manifestPath = join(teamDir, 'manifest.v2.json');
+            await mkdir(teamDir, { recursive: true });
+            await writeFile(configPath, JSON.stringify(config, null, 2));
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+            manifest.workspace_mode = 'worktree';
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'workspace-mode-team']));
+            assert.ok(logs.some((line) => /workspace_mode: worktree/.test(line)));
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('returns workspace_mode in JSON status output when present', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-json-workspace-mode-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            const config = await withoutTeamTestWorkerEnv(() => initTeamState('workspace-mode-json-team', 'inspect workspace mode', 'executor', 1, wd));
+            config.workspace_mode = 'worktree';
+            const teamDir = join(wd, '.rcs', 'state', 'team', 'workspace-mode-json-team');
+            const configPath = join(teamDir, 'config.json');
+            const manifestPath = join(teamDir, 'manifest.v2.json');
+            await mkdir(teamDir, { recursive: true });
+            await writeFile(configPath, JSON.stringify(config, null, 2));
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+            manifest.workspace_mode = 'worktree';
+            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'workspace-mode-json-team', '--json']));
+            const payload = JSON.parse(logs[0] ?? '{}');
+            assert.equal(payload.status, 'ok');
+            assert.equal(payload.workspace_mode, 'worktree');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('returns a missing envelope in JSON mode when team state is absent', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-missing-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'missing-team', '--json']));
+            const payload = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(payload.schema_version, '1.0');
+            assert.equal(typeof payload.timestamp, 'string');
+            assert.equal(payload.command, 'rcs team status');
+            assert.equal(payload.team_name, 'missing-team');
+            assert.equal(payload.status, 'missing');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('records leader runtime activity when team status is read', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-activity-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await withoutTeamTestWorkerEnv(() => initTeamState('activity-team', 'inspect activity', 'executor', 1, wd));
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'activity-team', '--json']));
+            const activity = JSON.parse(await readFile(join(wd, '.rcs', 'state', 'leader-runtime-activity.json'), 'utf-8'));
+            assert.equal(activity.last_source, 'team_status');
+            assert.equal(activity.last_team_name, 'activity-team');
+            assert.ok(typeof activity.last_activity_at === 'string' && activity.last_activity_at.length > 0);
+            assert.ok(typeof activity.last_team_status_at === 'string' && activity.last_team_status_at.length > 0);
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('supports custom tail lines for generated raw inspect commands', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-status-tail-lines-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            const config = await withoutTeamTestWorkerEnv(() => initTeamState('pane-tail-team', 'inspect worker panes', 'executor', 1, wd));
+            config.workers[0].pane_id = '%51';
+            const manifestPath = join(wd, '.rcs', 'state', 'team', 'pane-tail-team', 'manifest.v2.json');
+            const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+            manifest.workers = config.workers.map((worker) => ({
+                ...worker,
+                pane_id: worker.pane_id,
+            }));
+            await writeFile(join(wd, '.rcs', 'state', 'team', 'pane-tail-team', 'config.json'), `${JSON.stringify(config, null, 2)}\n`);
+            await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-tail-team', '--tail-lines', '600']));
+            assert.match(logs.join('\n'), /inspect_worker-1: tmux capture-pane -p -t %51 -S -600/);
+            logs.length = 0;
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-tail-team', '--model-inspect', '--tail-lines', '600']));
+            assert.match(logs.join('\n'), /inspect_worker-1: rcs sparkshell --tmux-pane %51 --tail-lines 600/);
+            logs.length = 0;
+            await withoutTeamTestWorkerEnv(() => teamCommand(['status', 'pane-tail-team', '--json', '--tail-lines=550']));
+            const payload = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(payload.tail_lines, 550);
+            assert.equal(payload.panes?.sparkshell_commands?.['worker-1'], 'rcs sparkshell --tmux-pane %51 --tail-lines 550');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+describe('teamCommand await', () => {
+    it('returns next canonical event for a team in JSON mode', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-await-'));
+        const previousCwd = process.cwd();
+        const logs = [];
+        const originalLog = console.log;
+        try {
+            process.chdir(wd);
+            await initTeamState('await-team', 'await test', 'executor', 1, wd);
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            const waitPromise = teamCommand(['await', 'await-team', '--json', '--timeout-ms', '500']);
+            setTimeout(() => {
+                void appendTeamEvent('await-team', {
+                    type: 'worker_state_changed',
+                    worker: 'worker-1',
+                    state: 'blocked',
+                    prev_state: 'working',
+                    reason: 'needs_follow_up',
+                }, wd);
+            }, 50);
+            await waitPromise;
+            const payload = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(payload.team_name, 'await-team');
+            assert.equal(payload.status, 'event');
+            assert.equal(typeof payload.cursor, 'string');
+            assert.equal(payload.event?.type, 'worker_state_changed');
+            assert.equal(payload.event?.state, 'blocked');
+            assert.equal(payload.event?.prev_state, 'working');
+            assert.equal(payload.event?.reason, 'needs_follow_up');
+        }
+        finally {
+            console.log = originalLog;
+            process.chdir(previousCwd);
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('returns a dead-worker event for the prompt-launch smoke path instead of timing out', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-await-prompt-dead-'));
+        const binDir = join(wd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        const previousCwd = process.cwd();
+        const previousPath = process.env.PATH;
+        const previousTmux = process.env.TMUX;
+        const previousLaunchMode = process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.RCS_TEAM_WORKER_CLI;
+        const logs = [];
+        const stderr = [];
+        const originalLog = console.log;
+        const originalStderrWrite = process.stderr.write.bind(process.stderr);
+        const teamTask = 'issue 662 prompt dead worker smoke';
+        const teamName = parseTeamStartArgs(['1:executor', teamTask]).parsed.teamName;
+        await mkdir(binDir, { recursive: true });
+        await writeFile(fakeCodexPath, `#!/usr/bin/env node
+setTimeout(() => process.exit(0), 0);
+process.stdin.resume();
+process.on('SIGTERM', () => process.exit(0));
+`);
+        await chmod(fakeCodexPath, 0o755);
+        try {
+            process.chdir(wd);
+            process.env.PATH = `${binDir}:${previousPath ?? ''}`;
+            delete process.env.TMUX;
+            process.env.RCS_TEAM_WORKER_LAUNCH_MODE = 'prompt';
+            process.env.RCS_TEAM_WORKER_CLI = 'codex';
+            console.log = (...args) => logs.push(args.map(String).join(' '));
+            process.stderr.write = ((chunk) => {
+                stderr.push(String(chunk));
+                return true;
+            });
+            await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
+            const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
+            let statusOutput = '';
+            for (let attempt = 0; attempt < 50; attempt += 1) {
+                logs.length = 0;
+                stderr.length = 0;
+                await withoutTeamTestWorkerEnv(() => teamCommand(['status', runtimeTeamName]));
+                statusOutput = logs.join('\n');
+                if (/phase=failed/.test(statusOutput))
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, 20));
+            }
+            assert.match(statusOutput, /phase=failed/);
+            assert.doesNotMatch(stderr.join('\n'), /ESRCH/);
+            logs.length = 0;
+            await withoutTeamTestWorkerEnv(() => teamCommand(['await', runtimeTeamName, '--json', '--timeout-ms', '250']));
+            const payload = JSON.parse(logs.at(-1) ?? '{}');
+            assert.equal(payload.team_name, runtimeTeamName);
+            assert.equal(payload.status, 'event');
+            assert.equal(payload.event?.type, 'worker_stopped');
+            assert.equal(payload.event?.worker, 'worker-1');
+        }
+        finally {
+            console.log = originalLog;
+            process.stderr.write = originalStderrWrite;
+            process.chdir(previousCwd);
+            if (typeof previousPath === 'string')
+                process.env.PATH = previousPath;
+            else
+                delete process.env.PATH;
+            if (typeof previousTmux === 'string')
+                process.env.TMUX = previousTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof previousLaunchMode === 'string')
+                process.env.RCS_TEAM_WORKER_LAUNCH_MODE = previousLaunchMode;
+            else
+                delete process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof previousWorkerCli === 'string')
+                process.env.RCS_TEAM_WORKER_CLI = previousWorkerCli;
+            else
+                delete process.env.RCS_TEAM_WORKER_CLI;
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('initializes and rehydrates active team mode state on start and resume', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-mode-state-'));
+        const binDir = join(wd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        const previousCwd = process.cwd();
+        const previousPath = process.env.PATH;
+        const previousTmux = process.env.TMUX;
+        const previousLaunchMode = process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.RCS_TEAM_WORKER_CLI;
+        const teamTask = 'issue 771 rehydrate team mode state';
+        const teamName = parseTeamStartArgs(['1:executor', teamTask]).parsed.teamName;
+        await mkdir(binDir, { recursive: true });
+        await writeFile(fakeCodexPath, `#!/usr/bin/env node
+setTimeout(() => process.exit(0), 3000);
+process.stdin.resume();
+process.on('SIGTERM', () => process.exit(0));
+`);
+        await chmod(fakeCodexPath, 0o755);
+        try {
+            process.chdir(wd);
+            process.env.PATH = `${binDir}:${previousPath ?? ''}`;
+            delete process.env.TMUX;
+            process.env.RCS_TEAM_WORKER_LAUNCH_MODE = 'prompt';
+            process.env.RCS_TEAM_WORKER_CLI = 'codex';
+            await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
+            const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
+            assert.equal(startedState?.active, true);
+            assert.equal(startedState?.team_name, runtimeTeamName);
+            assert.equal(startedState?.display_name, teamName);
+            assert.equal(startedState?.current_phase, 'team-exec');
+            await rm(join(wd, '.rcs', 'state', 'team-state.json'), { force: true });
+            assert.equal(await readModeState('team', wd), null);
+            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', runtimeTeamName]));
+            const resumedState = await readModeState('team', wd);
+            assert.equal(resumedState?.active, true);
+            assert.equal(resumedState?.team_name, runtimeTeamName);
+            assert.equal(resumedState?.current_phase, 'team-exec');
+        }
+        finally {
+            process.chdir(previousCwd);
+            if (typeof previousPath === 'string')
+                process.env.PATH = previousPath;
+            else
+                delete process.env.PATH;
+            if (typeof previousTmux === 'string')
+                process.env.TMUX = previousTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof previousLaunchMode === 'string')
+                process.env.RCS_TEAM_WORKER_LAUNCH_MODE = previousLaunchMode;
+            else
+                delete process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof previousWorkerCli === 'string')
+                process.env.RCS_TEAM_WORKER_CLI = previousWorkerCli;
+            else
+                delete process.env.RCS_TEAM_WORKER_CLI;
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('does not resurrect active team mode state when canonical team phase is terminal on resume', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'rcs-team-mode-terminal-'));
+        const binDir = join(wd, 'bin');
+        const fakeCodexPath = join(binDir, 'codex');
+        const previousCwd = process.cwd();
+        const previousPath = process.env.PATH;
+        const previousTmux = process.env.TMUX;
+        const previousLaunchMode = process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+        const previousWorkerCli = process.env.RCS_TEAM_WORKER_CLI;
+        const teamTask = 'issue 772 terminal team mode state';
+        const teamName = parseTeamStartArgs(['1:executor', teamTask]).parsed.teamName;
+        await mkdir(binDir, { recursive: true });
+        await writeFile(fakeCodexPath, `#!/usr/bin/env node
+setTimeout(() => process.exit(0), 3000);
+process.stdin.resume();
+process.on('SIGTERM', () => process.exit(0));
+`);
+        await chmod(fakeCodexPath, 0o755);
+        try {
+            process.chdir(wd);
+            process.env.PATH = `${binDir}:${previousPath ?? ''}`;
+            delete process.env.TMUX;
+            process.env.RCS_TEAM_WORKER_LAUNCH_MODE = 'prompt';
+            process.env.RCS_TEAM_WORKER_CLI = 'codex';
+            await withMockPromptModeCodexAllowed(() => withoutTeamTestWorkerEnv(() => teamCommand(['1:executor', teamTask])));
+            const startedState = await readModeState('team', wd);
+            const runtimeTeamName = String(startedState?.team_name ?? teamName);
+            await writeFile(join(wd, '.rcs', 'state', 'team', runtimeTeamName, 'phase.json'), JSON.stringify({
+                current_phase: 'complete',
+                max_fix_attempts: 3,
+                current_fix_attempt: 0,
+                transitions: [],
+                updated_at: new Date().toISOString(),
+            }, null, 2));
+            await rm(join(wd, '.rcs', 'state', 'team-state.json'), { force: true });
+            await withoutTeamTestWorkerEnv(() => teamCommand(['resume', runtimeTeamName]));
+            const resumedState = await readModeState('team', wd);
+            assert.equal(resumedState?.active, false);
+            assert.equal(resumedState?.team_name, runtimeTeamName);
+            assert.equal(resumedState?.current_phase, 'complete');
+        }
+        finally {
+            process.chdir(previousCwd);
+            if (typeof previousPath === 'string')
+                process.env.PATH = previousPath;
+            else
+                delete process.env.PATH;
+            if (typeof previousTmux === 'string')
+                process.env.TMUX = previousTmux;
+            else
+                delete process.env.TMUX;
+            if (typeof previousLaunchMode === 'string')
+                process.env.RCS_TEAM_WORKER_LAUNCH_MODE = previousLaunchMode;
+            else
+                delete process.env.RCS_TEAM_WORKER_LAUNCH_MODE;
+            if (typeof previousWorkerCli === 'string')
+                process.env.RCS_TEAM_WORKER_CLI = previousWorkerCli;
+            else
+                delete process.env.RCS_TEAM_WORKER_CLI;
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('rejects legacy rcs team ralph launches at command entry', async () => {
+        await assert.rejects(() => withoutTeamTestWorkerEnv(() => teamCommand(['ralph', '1:executor', 'issue 742 linked ralph launch'])), /Deprecated usage: `rcs team ralph \.\.\.` has been removed/);
+    });
+});
+//# sourceMappingURL=team.test.js.map