@jstn-sdk/rcs 0.1.0 → 0.1.1

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

@@ -1,1510 +0,0 @@
-import { after, before, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmod, mkdtemp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
-import { setTimeout as sleep } from 'node:timers/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initTeamState, enqueueDispatchRequest, readDispatchRequest, listMailboxMessages, sendDirectMessage, readTeamConfig, saveTeamConfig, } from '../../team/state.js';
-import { pathToFileURL } from 'node:url';
-function buildFakeTmux(tmuxLogPath) {
-    return `#!/usr/bin/env bash
-set -eu
-echo "$@" >> "${tmuxLogPath}"
-cmd="$1"
-shift || true
-if [[ "$cmd" == "capture-pane" ]]; then
-  if [[ -n "\${RCS_TEST_CAPTURE_SEQUENCE_FILE:-}" && -f "\${RCS_TEST_CAPTURE_SEQUENCE_FILE}" ]]; then
-    counterFile="\${RCS_TEST_CAPTURE_COUNTER_FILE:-\${RCS_TEST_CAPTURE_SEQUENCE_FILE}.idx}"
-    idx=0
-    if [[ -f "$counterFile" ]]; then idx="$(cat "$counterFile")"; fi
-    lineNo=$((idx + 1))
-    line="$(sed -n "\${lineNo}p" "\${RCS_TEST_CAPTURE_SEQUENCE_FILE}" || true)"
-    if [[ -z "$line" ]]; then
-      line="$(tail -n 1 "\${RCS_TEST_CAPTURE_SEQUENCE_FILE}" || true)"
-    fi
-    printf "%s\\n" "$line"
-    echo "$lineNo" > "$counterFile"
-    exit 0
-  fi
-  if [[ -n "\${RCS_TEST_CAPTURE_FILE:-}" && -f "\${RCS_TEST_CAPTURE_FILE}" ]]; then
-    cat "\${RCS_TEST_CAPTURE_FILE}"
-    exit 0
-  fi
-  printf "› ready\\n"
-  exit 0
-fi
-if [[ "$cmd" == "display-message" ]]; then
-  target=""
-  fmt=""
-  while [[ "$#" -gt 0 ]]; do
-    case "$1" in
-      -t)
-        shift
-        target="$1"
-        ;;
-      *)
-        fmt="$1"
-        ;;
-    esac
-    shift || true
-  done
-  if [[ "$fmt" == "#{pane_in_mode}" ]]; then
-    echo "0"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_id}" ]]; then
-    echo "\${target:-%42}"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_path}" ]]; then
-    dirname "${tmuxLogPath}"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_start_command}" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_command}" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  if [[ "$fmt" == "#S" ]]; then
-    echo "session-test"
-    exit 0
-  fi
-  exit 0
-fi
-if [[ "$cmd" == "send-keys" ]]; then
-  exit 0
-fi
-if [[ "$cmd" == "list-panes" ]]; then
-  echo "%42 1"
-  exit 0
-fi
-exit 0
-`;
-}
-async function readTeamDeliveryLog(cwd) {
-    const path = join(cwd, '.rcs', 'logs', `team-delivery-${new Date().toISOString().slice(0, 10)}.jsonl`);
-    const raw = await readFile(path, 'utf-8').catch(() => '');
-    return raw
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => JSON.parse(line));
-}
-async function listDispatchProcessingLeases(cwd, teamName) {
-    const dispatchDir = join(cwd, '.rcs', 'state', 'team', teamName, 'dispatch');
-    return (await readdir(dispatchDir).catch(() => []))
-        .filter((entry) => entry.startsWith('.processing-'))
-        .sort();
-}
-async function writeCompatRuntimeFixture(runtimePath) {
-    await writeFile(runtimePath, `#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const argv = process.argv.slice(2);
-function argValue(prefix) {
-  const entry = argv.find((value) => value.startsWith(prefix));
-  return entry ? entry.slice(prefix.length) : null;
-}
-function stateDir() {
-  return argValue('--state-dir=') || process.cwd();
-}
-function readJson(file, fallback) {
-  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
-}
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\\n');
-}
-function nowIso() { return new Date().toISOString(); }
-if (argv[0] === 'schema') {
-  process.stdout.write(JSON.stringify({ schema_version: 1, commands: ['acquire-authority','renew-authority','queue-dispatch','mark-notified','mark-delivered','mark-failed','request-replay','capture-snapshot'], events: [], transport: 'tmux' }) + '\\n');
-  process.exit(0);
-}
-if (argv[0] !== 'exec') process.exit(1);
-const command = JSON.parse(argv[1] || '{}');
-const dir = stateDir();
-const dispatchPath = path.join(dir, 'dispatch.json');
-const mailboxPath = path.join(dir, 'mailbox.json');
-const dispatch = readJson(dispatchPath, { records: [] });
-const mailbox = readJson(mailboxPath, { records: [] });
-const timestamp = nowIso();
-switch (command.command) {
-  case 'QueueDispatch':
-    dispatch.records.push({ request_id: command.request_id, target: command.target, status: 'pending', created_at: timestamp, notified_at: null, delivered_at: null, failed_at: null, reason: null, metadata: command.metadata ?? null });
-    writeJson(dispatchPath, dispatch);
-    process.stdout.write(JSON.stringify({ event: 'DispatchQueued', request_id: command.request_id, target: command.target }) + '\\n');
-    process.exit(0);
-  case 'MarkNotified': {
-    const record = dispatch.records.find((entry) => entry.request_id === command.request_id);
-    if (record) {
-      record.status = 'notified';
-      record.notified_at = timestamp;
-      record.reason = command.channel;
-      writeJson(dispatchPath, dispatch);
-    }
-    process.stdout.write(JSON.stringify({ event: 'DispatchNotified', request_id: command.request_id, channel: command.channel }) + '\\n');
-    process.exit(0);
-  }
-  case 'CreateMailboxMessage':
-    mailbox.records.push({ message_id: command.message_id, from_worker: command.from_worker, to_worker: command.to_worker, body: command.body, created_at: timestamp, notified_at: null, delivered_at: null });
-    writeJson(mailboxPath, mailbox);
-    process.stdout.write(JSON.stringify({ event: 'MailboxMessageCreated', message_id: command.message_id, from_worker: command.from_worker, to_worker: command.to_worker }) + '\\n');
-    process.exit(0);
-  case 'MarkMailboxNotified': {
-    const record = mailbox.records.find((entry) => entry.message_id === command.message_id);
-    if (record) {
-      record.notified_at = timestamp;
-      writeJson(mailboxPath, mailbox);
-    }
-    process.stdout.write(JSON.stringify({ event: 'MailboxNotified', message_id: command.message_id }) + '\\n');
-    process.exit(0);
-  }
-  default:
-    process.stdout.write(JSON.stringify({ event: 'ok' }) + '\\n');
-    process.exit(0);
-}
-`);
-    await chmod(runtimePath, 0o755);
-}
-async function waitForMailboxNotifiedAt(teamName, workerName, messageId, cwd) {
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-        const mailbox = await listMailboxMessages(teamName, workerName, cwd);
-        const message = mailbox.find((entry) => entry.message_id === messageId);
-        if (message?.notified_at)
-            return message.notified_at;
-        if (attempt < 4)
-            await sleep(25);
-    }
-    return undefined;
-}
-describe('notify-hook team dispatch consumer', () => {
-    const originalTeamWorker = process.env.RCS_TEAM_WORKER;
-    const originalTeamStateRoot = process.env.RCS_TEAM_STATE_ROOT;
-    before(() => {
-        delete process.env.RCS_TEAM_WORKER;
-        delete process.env.RCS_TEAM_STATE_ROOT;
-    });
-    after(() => {
-        if (originalTeamWorker === undefined) {
-            delete process.env.RCS_TEAM_WORKER;
-        }
-        else {
-            process.env.RCS_TEAM_WORKER = originalTeamWorker;
-        }
-        if (originalTeamStateRoot === undefined) {
-            delete process.env.RCS_TEAM_STATE_ROOT;
-        }
-        else {
-            process.env.RCS_TEAM_STATE_ROOT = originalTeamStateRoot;
-        }
-    });
-    it('marks pending request as notified and preserves mailbox notified_at semantics', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'worker-1', 'hello', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                message_id: msg.message_id,
-                trigger_message: 'check mailbox',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-            assert.ok(request?.notified_at, 'expected dispatch state to record notified_at');
-            const mailbox = await listMailboxMessages('alpha', 'worker-1', cwd);
-            const mailboxMessage = mailbox.find((entry) => entry.message_id === msg.message_id);
-            assert.ok(mailboxMessage, 'expected the queued mailbox message to remain readable');
-            const notifiedAt = await waitForMailboxNotifiedAt('alpha', 'worker-1', msg.message_id, cwd);
-            assert.ok(notifiedAt || request.notified_at, 'expected dispatch state or mailbox shadow to record notified_at');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('leader-fixed dispatch remains pending with leader_pane_missing_deferred when pane missing', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'leader-fixed', 'hello leader', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'leader-fixed',
-                message_id: msg.message_id,
-                trigger_message: 'check leader mailbox',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 0);
-            assert.ok(result.skipped >= 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-            assert.equal(request?.last_reason, 'leader_pane_missing_deferred');
-            const mailbox = await listMailboxMessages('alpha', 'leader-fixed', cwd);
-            assert.equal(mailbox.length, 1);
-            assert.equal(mailbox[0]?.notified_at, undefined);
-            const eventsPath = join(cwd, '.rcs', 'state', 'team', 'alpha', 'events', 'events.ndjson');
-            const eventsRaw = await readFile(eventsPath, 'utf-8');
-            const events = eventsRaw.trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const deferred = events.find((event) => event.type === 'leader_notification_deferred'
-                && event.reason === 'leader_pane_missing_deferred'
-                && event.request_id === queued.request.request_id
-                && event.to_worker === 'leader-fixed');
-            assert.ok(deferred, 'expected leader_notification_deferred event for missing leader pane');
-            assert.equal(deferred.source_type, 'team_dispatch');
-            assert.equal(typeof deferred.tmux_session, 'string');
-            assert.ok(deferred.tmux_session.length > 0);
-            assert.equal(deferred.leader_pane_id, null);
-            assert.equal(deferred.tmux_injection_attempted, false);
-            const dispatchLogPath = join(cwd, '.rcs', 'logs', `team-dispatch-${new Date().toISOString().slice(0, 10)}.jsonl`);
-            const dispatchLogs = (await readFile(dispatchLogPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const deferredLog = dispatchLogs.find((entry) => entry.type === 'dispatch_deferred' && entry.request_id === queued.request.request_id);
-            assert.ok(deferredLog, 'expected dispatch_deferred log entry');
-            assert.equal(typeof deferredLog.tmux_session, 'string');
-            assert.ok(deferredLog.tmux_session.length > 0);
-            assert.equal(deferredLog.leader_pane_id, null);
-            assert.equal(deferredLog.tmux_injection_attempted, false);
-            const deliveryLog = await readTeamDeliveryLog(cwd);
-            assert.ok(deliveryLog.some((entry) => entry.event === 'dispatch_result'
-                && entry.source === 'notify-hook.team-dispatch'
-                && entry.request_id === queued.request.request_id
-                && entry.result === 'deferred'
-                && entry.reason === 'leader_pane_missing_deferred'));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not duplicate deferred leader artifacts across repeated drain ticks', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'leader-fixed', 'hello leader', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'leader-fixed',
-                message_id: msg.message_id,
-                trigger_message: 'check leader mailbox',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector: async () => ({ ok: true, reason: 'injected_for_test' }) });
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector: async () => ({ ok: true, reason: 'injected_for_test' }) });
-            const eventsPath = join(cwd, '.rcs', 'state', 'team', 'alpha', 'events', 'events.ndjson');
-            const events = (await readFile(eventsPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const deferredEvents = events.filter((event) => event.type === 'leader_notification_deferred' && event.request_id === queued.request.request_id);
-            assert.equal(deferredEvents.length, 1, 'should only write one deferred event per missing-pane request until state changes');
-            const dispatchLogPath = join(cwd, '.rcs', 'logs', `team-dispatch-${new Date().toISOString().slice(0, 10)}.jsonl`);
-            const dispatchLogs = (await readFile(dispatchLogPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const deferredLogs = dispatchLogs.filter((entry) => entry.type === 'dispatch_deferred' && entry.request_id === queued.request.request_id);
-            assert.equal(deferredLogs.length, 1, 'should only log one dispatch_deferred artifact per missing-pane request until state changes');
-            const deliveryLog = await readTeamDeliveryLog(cwd);
-            const deferredDeliveryLogs = deliveryLog.filter((entry) => entry.event === 'dispatch_result'
-                && entry.source === 'notify-hook.team-dispatch'
-                && entry.request_id === queued.request.request_id
-                && entry.result === 'deferred');
-            assert.equal(deferredDeliveryLogs.length, 1, 'should only log one deferred team-delivery artifact per missing-pane request until state changes');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('invokes rcs-runtime exec via shared bridge fallback', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const runtimeLogPath = join(cwd, 'runtime.log');
-        const previousPath = process.env.PATH;
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'rcs-runtime'), `#!/usr/bin/env bash
-set -eu
-printf '%s\n' "$*" >> "${runtimeLogPath}"
-if [[ "\${1:-}" == "schema" ]]; then
-  printf '{"schema_version":1,"commands":["acquire-authority","renew-authority","queue-dispatch","mark-notified","mark-delivered","mark-failed","request-replay","capture-snapshot"],"events":[],"transport":"tmux"}\n'
-  exit 0
-fi
-if [[ "\${1:-}" == "exec" ]]; then
-  printf '{"event":"DispatchNotified","request_id":"runtime-fallback","channel":"tmux"}\n'
-  exit 0
-fi
-exit 1
-`);
-            await chmod(join(fakeBinDir, 'rcs-runtime'), 0o755);
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_RUNTIME_BINARY = join(fakeBinDir, 'rcs-runtime');
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                pane_id: '%42',
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            const runtimeLog = await readFile(runtimeLogPath, 'utf8');
-            assert.match(runtimeLog, /^exec \{"command":"MarkNotified"/m);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            if (typeof previousRuntimeBinary === 'string')
-                process.env.RCS_RUNTIME_BINARY = previousRuntimeBinary;
-            else
-                delete process.env.RCS_RUNTIME_BINARY;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('marks bridge-authored mailbox state as notified on canonical hook success paths', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const runtimePath = join(fakeBinDir, 'rcs-runtime');
-        const previousPath = process.env.PATH;
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        const previousRuntimeBridge = process.env.RCS_RUNTIME_BRIDGE;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeCompatRuntimeFixture(runtimePath);
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_RUNTIME_BINARY = runtimePath;
-            process.env.RCS_RUNTIME_BRIDGE = '1';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'worker-1', 'hello', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                message_id: msg.message_id,
-                trigger_message: 'check mailbox',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-            const mailbox = await listMailboxMessages('alpha', 'worker-1', cwd);
-            assert.equal(mailbox.length, 1);
-            assert.ok(mailbox[0]?.notified_at, 'expected canonical bridge mailbox record to gain notified_at');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            if (typeof previousRuntimeBinary === 'string')
-                process.env.RCS_RUNTIME_BINARY = previousRuntimeBinary;
-            else
-                delete process.env.RCS_RUNTIME_BINARY;
-            if (typeof previousRuntimeBridge === 'string')
-                process.env.RCS_RUNTIME_BRIDGE = previousRuntimeBridge;
-            else
-                delete process.env.RCS_RUNTIME_BRIDGE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('logs structured evidence when bridge dispatch compat cannot be parsed and legacy requests are used', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const previousRuntimeBridge = process.env.RCS_RUNTIME_BRIDGE;
-        try {
-            process.env.RCS_RUNTIME_BRIDGE = '1';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            await writeFile(join(cwd, '.rcs', 'state', 'dispatch.json'), '{ broken bridge json');
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1, 'legacy request fallback must still process the pending request');
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-            const dispatchLogPath = join(cwd, '.rcs', 'logs', `team-dispatch-${new Date().toISOString().slice(0, 10)}.jsonl`);
-            const dispatchLogs = (await readFile(dispatchLogPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const fallback = dispatchLogs.find((entry) => entry.type === 'bridge_fallback' && entry.bridge_operation === 'readBridgeDispatchRequests' && entry.fallback === true);
-            assert.ok(fallback, 'expected structured bridge fallback evidence in dispatch log');
-            assert.equal(fallback.team, 'alpha');
-            assert.equal(fallback.fallback_target, 'legacy_dispatch_requests');
-            assert.equal(fallback.counter, 'team_dispatch_bridge_fallback_total');
-            assert.match(fallback.reason, /parse_failed|invalid_dispatch_compat/);
-            const deliveryLog = await readTeamDeliveryLog(cwd);
-            assert.ok(deliveryLog.some((entry) => entry.event === 'bridge_fallback'
-                && entry.source === 'notify-hook.team-dispatch'
-                && entry.bridge_operation === 'readBridgeDispatchRequests'
-                && entry.fallback_target === 'legacy_dispatch_requests'
-                && entry.counter === 'team_dispatch_bridge_fallback_total'));
-        }
-        finally {
-            if (typeof previousRuntimeBridge === 'string')
-                process.env.RCS_RUNTIME_BRIDGE = previousRuntimeBridge;
-            else
-                delete process.env.RCS_RUNTIME_BRIDGE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('logs structured evidence when runtimeExec fails and JS state remains authoritative', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        const previousRuntimeBridge = process.env.RCS_RUNTIME_BRIDGE;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'rcs-runtime'), `#!/usr/bin/env bash
-set -eu
-if [[ "\${1:-}" == "exec" ]]; then
-  echo "runtime schema drift" >&2
-  exit 43
-fi
-exit 0
-`);
-            await chmod(join(fakeBinDir, 'rcs-runtime'), 0o755);
-            process.env.RCS_RUNTIME_BINARY = join(fakeBinDir, 'rcs-runtime');
-            process.env.RCS_RUNTIME_BRIDGE = '1';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1, 'JS fallback path must still finish the dispatch');
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-            const dispatchLogPath = join(cwd, '.rcs', 'logs', `team-dispatch-${new Date().toISOString().slice(0, 10)}.jsonl`);
-            const dispatchLogs = (await readFile(dispatchLogPath, 'utf-8')).trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-            const fallback = dispatchLogs.find((entry) => entry.type === 'bridge_fallback' && entry.bridge_operation === 'runtimeExec' && entry.request_id === queued.request.request_id);
-            assert.ok(fallback, 'expected structured runtimeExec fallback evidence in dispatch log');
-            assert.equal(fallback.command, 'MarkNotified');
-            assert.equal(fallback.team, 'alpha');
-            assert.equal(fallback.fallback_target, 'js_state_mutation');
-            assert.equal(fallback.counter, 'team_dispatch_bridge_fallback_total');
-            assert.match(fallback.reason, /runtime schema drift|failed/);
-        }
-        finally {
-            if (typeof previousRuntimeBinary === 'string')
-                process.env.RCS_RUNTIME_BINARY = previousRuntimeBinary;
-            else
-                delete process.env.RCS_RUNTIME_BINARY;
-            if (typeof previousRuntimeBridge === 'string')
-                process.env.RCS_RUNTIME_BRIDGE = previousRuntimeBridge;
-            else
-                delete process.env.RCS_RUNTIME_BRIDGE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('leader-fixed dispatch uses pane target only when leader_pane_id exists', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const prevPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            process.env.PATH = `${fakeBinDir}:${prevPath || ''}`;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const cfg = await readTeamConfig('alpha', cwd);
-            assert.ok(cfg);
-            if (!cfg)
-                throw new Error('missing team config');
-            cfg.leader_pane_id = '%99';
-            await saveTeamConfig(cfg, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'leader-fixed', 'hello leader', cwd);
-            await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'leader-fixed',
-                message_id: msg.message_id,
-                trigger_message: 'Read .rcs/state/team/alpha/mailbox/leader-fixed.json; worker-1 sent a new message. Review it and decide the next concrete step.',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            assert.equal(result.processed, 1);
-            const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            assert.match(tmuxLog, /send-keys -t %99/);
-            assert.match(tmuxLog, /mailbox\/leader-fixed\.json; worker-1 sent a new message/);
-            assert.doesNotMatch(tmuxLog, /send-keys -t .*devsess/);
-        }
-        finally {
-            if (typeof prevPath === 'string')
-                process.env.PATH = prevPath;
-            else
-                delete process.env.PATH;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('leader-fixed dispatch prefers the canonical codex pane over a stale HUD leader pane id', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const prevPath = process.env.PATH;
-        const prevTmuxPane = process.env.TMUX_PANE;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            const fakeTmux = `#!/usr/bin/env bash
-set -eu
-echo "$@" >> "${tmuxLogPath}"
-cmd="$1"
-shift || true
-if [[ "$cmd" == "capture-pane" ]]; then
-  printf "› ready\\n"
-  exit 0
-fi
-if [[ "$cmd" == "display-message" ]]; then
-  target=""
-  fmt=""
-  while [[ "$#" -gt 0 ]]; do
-    case "$1" in
-      -t)
-        shift
-        target="$1"
-        ;;
-      *)
-        fmt="$1"
-        ;;
-    esac
-    shift || true
-  done
-  if [[ "$fmt" == "#{pane_in_mode}" ]]; then
-    echo "0"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_id}" ]]; then
-    echo "\${target:-%42}"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_path}" ]]; then
-    dirname "${tmuxLogPath}"
-    exit 0
-  fi
-  if [[ "$fmt" == "#S" ]]; then
-    echo "devsess"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_command}" && "$target" == "%42" ]]; then
-    echo "node"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_start_command}" && "$target" == "%91" ]]; then
-    echo "node dist/cli/rcs.js hud --watch"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_start_command}" && "$target" == "%42" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_command}" && "$target" == "%99" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_command}" && "$target" == "%42" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  exit 0
-fi
-if [[ "$cmd" == "send-keys" ]]; then
-  exit 0
-fi
-if [[ "$cmd" == "list-panes" ]]; then
-  printf "%%42\\t1\\tnode\\tcodex\\n%%91\\t0\\tnode\\tnode dist/cli/rcs.js hud --watch\\n"
-  exit 0
-fi
-exit 0
-`;
-            await writeFile(join(fakeBinDir, 'tmux'), fakeTmux);
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            process.env.PATH = `${fakeBinDir}:${prevPath || ''}`;
-            process.env.TMUX_PANE = '%42';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const cfg = await readTeamConfig('alpha', cwd);
-            assert.ok(cfg);
-            if (!cfg)
-                throw new Error('missing team config');
-            cfg.leader_pane_id = '%91';
-            await saveTeamConfig(cfg, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'leader-fixed', 'hello leader', cwd);
-            await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'leader-fixed',
-                message_id: msg.message_id,
-                trigger_message: 'Read .rcs/state/team/alpha/mailbox/leader-fixed.json; worker-1 sent a new message. Review it and decide the next concrete step.',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            assert.equal(result.processed, 1);
-            const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            assert.match(tmuxLog, /send-keys -t %42/);
-            assert.doesNotMatch(tmuxLog, /send-keys -t %91/);
-        }
-        finally {
-            if (typeof prevPath === 'string')
-                process.env.PATH = prevPath;
-            else
-                delete process.env.PATH;
-            if (typeof prevTmuxPane === 'string')
-                process.env.TMUX_PANE = prevTmuxPane;
-            else
-                delete process.env.TMUX_PANE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('leader-fixed dispatch fails without false notification when the resolved leader pane is in copy-mode', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const prevPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), `#!/usr/bin/env bash
-set -eu
-echo "$@" >> "${tmuxLogPath}"
-cmd="$1"
-shift || true
-if [[ "$cmd" == "display-message" ]]; then
-  target=""
-  fmt=""
-  while [[ "$#" -gt 0 ]]; do
-    case "$1" in
-      -t)
-        shift
-        target="$1"
-        ;;
-      *)
-        fmt="$1"
-        ;;
-    esac
-    shift || true
-  done
-  if [[ "$fmt" == "#{pane_in_mode}" && "$target" == "%77" ]]; then
-    echo "1"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_id}" && "$target" == "%77" ]]; then
-    echo "%77"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_path}" ]]; then
-    dirname "${tmuxLogPath}"
-    exit 0
-  fi
-  if [[ "$fmt" == "#{pane_current_command}" && "$target" == "%77" ]]; then
-    echo "codex"
-    exit 0
-  fi
-  if [[ "$fmt" == "#S" ]]; then
-    echo "devsess"
-    exit 0
-  fi
-  exit 0
-fi
-if [[ "$cmd" == "send-keys" ]]; then
-  exit 0
-fi
-if [[ "$cmd" == "list-panes" ]]; then
-  printf "%%77\\t1\\tcodex\\tcodex\\n"
-  exit 0
-fi
-exit 0
-`);
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            process.env.PATH = `${fakeBinDir}:${prevPath || ''}`;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const cfg = await readTeamConfig('alpha', cwd);
-            assert.ok(cfg);
-            if (!cfg)
-                throw new Error('missing team config');
-            cfg.leader_pane_id = '%77';
-            await saveTeamConfig(cfg, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'leader-fixed', 'hello leader', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'leader-fixed',
-                message_id: msg.message_id,
-                trigger_message: 'Read .rcs/state/team/alpha/mailbox/leader-fixed.json; worker-1 sent a new message. Review it and decide the next concrete step.',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            assert.equal(result.processed, 1);
-            assert.equal(result.failed, 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'failed');
-            assert.equal(request?.last_reason, 'scroll_active');
-            const mailbox = await listMailboxMessages('alpha', 'leader-fixed', cwd);
-            const mailboxMessage = mailbox.find((entry) => entry.message_id === msg.message_id);
-            assert.equal(mailboxMessage?.notified_at, undefined, 'guard failure should not mark leader mailbox message notified');
-            const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            assert.match(tmuxLog, /display-message -p -t %77 #\{pane_in_mode\}/);
-            assert.doesNotMatch(tmuxLog, /send-keys -t %77/, 'copy-mode leader pane must not receive injected keys');
-        }
-        finally {
-            if (typeof prevPath === 'string')
-                process.env.PATH = prevPath;
-            else
-                delete process.env.PATH;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('uses explicit stateDir when marking mailbox notified_at', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const stateDir = join(cwd, 'custom-state-root');
-        const previousStateRoot = process.env.RCS_TEAM_STATE_ROOT;
-        try {
-            process.env.RCS_TEAM_STATE_ROOT = './custom-state-root';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const msg = await sendDirectMessage('alpha', 'worker-1', 'worker-1', 'hello', cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                message_id: msg.message_id,
-                trigger_message: 'check mailbox',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                stateDir,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-            assert.ok(request?.notified_at, 'expected dispatch state to record notified_at');
-            const mailbox = await listMailboxMessages('alpha', 'worker-1', cwd);
-            const mailboxMessage = mailbox.find((entry) => entry.message_id === msg.message_id);
-            assert.ok(mailboxMessage, 'expected the queued mailbox message to remain readable');
-            const notifiedAt = await waitForMailboxNotifiedAt('alpha', 'worker-1', msg.message_id, cwd);
-            assert.ok(notifiedAt || request.notified_at, 'expected dispatch state or mailbox shadow to record notified_at');
-        }
-        finally {
-            if (typeof previousStateRoot === 'string')
-                process.env.RCS_TEAM_STATE_ROOT = previousStateRoot;
-            else
-                delete process.env.RCS_TEAM_STATE_ROOT;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('is idempotent across repeated ticks (no duplicate processing)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            const second = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(second.processed, 0);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'notified');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releases the global dispatch lock before slow tmux injection so mailbox sends do not wedge mid-run', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const previousLockTimeout = process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS;
-        const previousRuntimeBridge = process.env.RCS_RUNTIME_BRIDGE;
-        try {
-            process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS = '1000';
-            process.env.RCS_RUNTIME_BRIDGE = '0';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'startup ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const slowDrain = mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 1,
-                injector: async () => {
-                    await sleep(1_200);
-                    return { ok: true, reason: 'tmux_send_keys_confirmed' };
-                },
-            });
-            await sleep(100);
-            await assert.doesNotReject(async () => {
-                await enqueueDispatchRequest('alpha', {
-                    kind: 'mailbox',
-                    to_worker: 'worker-1',
-                    worker_index: 1,
-                    trigger_message: 'check mailbox',
-                    message_id: 'msg-1',
-                }, cwd);
-            });
-            const result = await slowDrain;
-            assert.equal(result.processed, 1);
-            assert.equal(result.failed, 0);
-            const requests = JSON.parse(await readFile(join(cwd, '.rcs', 'state', 'team', 'alpha', 'dispatch', 'requests.json'), 'utf-8'));
-            const mailboxRequest = requests.find((entry) => entry.kind === 'mailbox');
-            assert.equal(mailboxRequest?.status, 'pending');
-        }
-        finally {
-            if (typeof previousLockTimeout === 'string')
-                process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS = previousLockTimeout;
-            else
-                delete process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS;
-            if (typeof previousRuntimeBridge === 'string')
-                process.env.RCS_RUNTIME_BRIDGE = previousRuntimeBridge;
-            else
-                delete process.env.RCS_RUNTIME_BRIDGE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('reserves per-issue cooldown before releasing the dispatch lock to a concurrent drain', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const previousIssueCooldown = process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-        let markInjectorStarted = () => { };
-        const injectorStarted = new Promise((resolve) => {
-            markInjectorStarted = () => resolve();
-        });
-        let releaseInjector = () => { };
-        const blockFirstInjector = new Promise((resolve) => {
-            releaseInjector = () => resolve();
-        });
-        let injectCount = 0;
-        try {
-            process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = '900000';
-            await initTeamState('alpha', 'task', 'executor', 2, cwd);
-            const first = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'IND-123 first follow-up',
-            }, cwd);
-            const second = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-2',
-                worker_index: 2,
-                trigger_message: 'IND-123 second follow-up',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const slowDrain = mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 1,
-                injector: async () => {
-                    injectCount += 1;
-                    if (injectCount === 1) {
-                        markInjectorStarted();
-                        await blockFirstInjector;
-                    }
-                    return { ok: true, reason: 'tmux_send_keys_confirmed' };
-                },
-            });
-            await injectorStarted;
-            const concurrentDrain = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 1,
-                injector: async () => {
-                    injectCount += 1;
-                    return { ok: true, reason: 'tmux_send_keys_confirmed' };
-                },
-            });
-            releaseInjector();
-            const firstResult = await slowDrain;
-            assert.equal(injectCount, 1, 'concurrent drain must not inject same-issue follow-up while first claim is in flight');
-            assert.equal(firstResult.processed, 1);
-            assert.equal(concurrentDrain.processed, 0);
-            assert.ok(concurrentDrain.skipped >= 1);
-            const firstRequest = await readDispatchRequest('alpha', first.request.request_id, cwd);
-            const secondRequest = await readDispatchRequest('alpha', second.request.request_id, cwd);
-            assert.equal(firstRequest?.status, 'notified');
-            assert.equal(secondRequest?.status, 'pending');
-            assert.equal(secondRequest?.attempt_count, 0);
-        }
-        finally {
-            releaseInjector();
-            if (typeof previousIssueCooldown === 'string')
-                process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = previousIssueCooldown;
-            else
-                delete process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releases every preclaimed dispatch lease when a claimed injector throws', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 2, cwd);
-            const first = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'first request',
-            }, cwd);
-            const second = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-2',
-                worker_index: 2,
-                trigger_message: 'second request',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            let attempt = 0;
-            await assert.rejects(() => mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => {
-                    attempt += 1;
-                    if (attempt === 1)
-                        throw new Error('injector exploded');
-                    return { ok: true, reason: 'tmux_send_keys_confirmed' };
-                },
-            }), /injector exploded/);
-            assert.deepEqual(await listDispatchProcessingLeases(cwd, 'alpha'), []);
-            const retry = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'tmux_send_keys_confirmed' }),
-            });
-            assert.equal(retry.processed, 2, 'later drain should not be blocked by stale preclaimed leases');
-            const firstRequest = await readDispatchRequest('alpha', first.request.request_id, cwd);
-            const secondRequest = await readDispatchRequest('alpha', second.request.request_id, cwd);
-            assert.equal(firstRequest?.status, 'notified');
-            assert.equal(secondRequest?.status, 'notified');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('leaves unconfirmed injection as pending for retry (#391)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            // First tick: injector returns unconfirmed → should stay pending
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'tmux_send_keys_unconfirmed' }),
-            });
-            assert.equal(result.processed, 0, 'unconfirmed should not count as processed');
-            assert.ok(result.skipped >= 1, 'unconfirmed should be skipped for retry');
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending', 'status should remain pending');
-            assert.equal(request?.last_reason, 'tmux_send_keys_unconfirmed');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('marks unconfirmed as failed after max attempts (#391)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const injector = async () => ({ ok: true, reason: 'tmux_send_keys_unconfirmed' });
-            // Drain 3 times to exhaust max attempts (MAX_UNCONFIRMED_ATTEMPTS=3)
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector });
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector });
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector });
-            assert.equal(result.processed, 1, 'should transition to failed on 3rd attempt');
-            assert.equal(result.failed, 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'failed');
-            assert.equal(request?.last_reason, 'unconfirmed_after_max_retries');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('confirmed injection marks notified immediately (#391)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'tmux_send_keys_confirmed' }),
-            });
-            assert.equal(result.processed, 1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('keeps retry_pending derived-only and does not persist transient tags', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'tmux_send_keys_unconfirmed' }),
-            });
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-            assert.equal(request?.last_reason, 'tmux_send_keys_unconfirmed');
-            assert.notEqual(request?.status, 'retry_pending');
-            const rawRequests = JSON.parse(await readFile(join(cwd, '.rcs', 'state', 'team', 'alpha', 'dispatch', 'requests.json'), 'utf8'));
-            const persisted = rawRequests.find((entry) => entry?.request_id === queued.request.request_id);
-            assert.ok(persisted);
-            assert.equal(persisted.status, 'pending');
-            assert.ok(!('retry_mode' in persisted), 'retry_mode must not be persisted');
-            assert.ok(!('retry_tag' in persisted), 'retry_tag must not be persisted');
-            assert.ok(!('status_tag' in persisted), 'status_tag must not be persisted');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('retries submit with isolated C-m and does not retype when trigger already present', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const captureFile = join(cwd, 'capture.txt');
-        const previousPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            await writeFile(captureFile, '... ping ...');
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_TEST_CAPTURE_FILE = captureFile;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                pane_id: '%42',
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            const typeMatches = tmuxLog.match(/send-keys -t %42 -l ping/g) || [];
-            assert.equal(typeMatches.length, 1, 'fresh attempt should type once; retries with draft should be submit-only');
-            const cmMatches = tmuxLog.match(/send-keys -t %42 C-m/g) || [];
-            assert.ok(cmMatches.length > 0, 'submit should use C-m');
-            assert.ok(!/send-keys[^\n]*-l[^\n]*C-m/.test(tmuxLog), 'must not mix -l payload with C-m submit');
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-            assert.equal(request?.attempt_count, 2);
-            assert.equal(request?.last_reason, 'tmux_send_keys_unconfirmed');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            delete process.env.RCS_TEST_CAPTURE_FILE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('retypes on every retry when trigger is not in narrow input area', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const captureSeqFile = join(cwd, 'capture-seq.txt');
-        const captureCounterFile = join(cwd, 'capture-seq.idx');
-        const previousPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            // Shared preflight now adds one 80-line capture per tick before the
-            // narrow retry check. Pre-capture on retries still returns "ready"
-            // (no trigger) so the request is retyped on every retry.
-            await writeFile(captureSeqFile, [
-                // tick1: 1 shared preflight + 3 verify rounds × 2 captures = 7
-                'ready', 'ping', 'ping', 'ping', 'ping', 'ping', 'ping',
-                // tick2: 1 shared preflight + 1 pre-capture + 3 verify rounds × 2 captures = 8
-                'ready', 'ready', 'ping', 'ping', 'ping', 'ping', 'ping', 'ping',
-                // tick3: 1 shared preflight + 1 pre-capture + 3 verify rounds × 2 captures = 8
-                'ready', 'ready', 'ping', 'ping', 'ping', 'ping', 'ping', 'ping',
-            ].join('\n'));
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE = captureSeqFile;
-            process.env.RCS_TEST_CAPTURE_COUNTER_FILE = captureCounterFile;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                pane_id: '%42',
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            const tmuxLog = await readFile(tmuxLogPath, 'utf8');
-            const typeMatches = tmuxLog.match(/send-keys -t %42 -l ping/g) || [];
-            // With narrow capture, retypes on every retry when trigger is not in input area
-            assert.equal(typeMatches.length, 3, 'should retype on every retry when trigger not in narrow capture (fresh + 2 retries)');
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'failed');
-            assert.equal(request?.last_reason, 'unconfirmed_after_max_retries');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            delete process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE;
-            delete process.env.RCS_TEST_CAPTURE_COUNTER_FILE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not confirm when narrow misses but wide tail still has unsent trigger', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const captureSeqFile = join(cwd, 'capture-seq.txt');
-        const captureCounterFile = join(cwd, 'capture-seq.idx');
-        const previousPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            // Each verify round uses narrow + wide capture.
-            // Narrow captures are whitespace-only (trigger absent), while wide captures
-            // still include the trigger near tail => should remain unconfirmed.
-            await writeFile(captureSeqFile, [
-                '   ', 'ping',
-                '   ', 'ping',
-                '   ', 'ping',
-            ].join('\n'));
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE = captureSeqFile;
-            process.env.RCS_TEST_CAPTURE_COUNTER_FILE = captureCounterFile;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                pane_id: '%42',
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            assert.equal(result.processed, 0, 'must not mark notified when wide tail still shows trigger');
-            assert.ok(result.skipped >= 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-            assert.equal(request?.last_reason, 'tmux_send_keys_unconfirmed');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            delete process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE;
-            delete process.env.RCS_TEST_CAPTURE_COUNTER_FILE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not confirm while pane is still bootstrapping even when trigger is absent', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const fakeBinDir = join(cwd, 'fake-bin');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const captureSeqFile = join(cwd, 'capture-seq.txt');
-        const captureCounterFile = join(cwd, 'capture-seq.idx');
-        const previousPath = process.env.PATH;
-        try {
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            // verify rounds: narrow capture empty, wide capture still loading.
-            await writeFile(captureSeqFile, [
-                '   ', 'model: loading',
-                '   ', 'model: loading',
-                '   ', 'model: loading',
-            ].join('\n'));
-            process.env.PATH = `${fakeBinDir}:${previousPath || ''}`;
-            process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE = captureSeqFile;
-            process.env.RCS_TEST_CAPTURE_COUNTER_FILE = captureCounterFile;
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                pane_id: '%42',
-                trigger_message: 'ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5 });
-            assert.equal(result.processed, 0);
-            assert.ok(result.skipped >= 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-            assert.equal(request?.last_reason, 'tmux_send_keys_unconfirmed');
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            delete process.env.RCS_TEST_CAPTURE_SEQUENCE_FILE;
-            delete process.env.RCS_TEST_CAPTURE_COUNTER_FILE;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('applies per-issue cooldown to avoid repeated reinjection in one drain tick', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const previousIssueCooldown = process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-        try {
-            process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = '900000';
-            await initTeamState('alpha', 'task', 'executor', 2, cwd);
-            const first = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: '› IND-123 only...',
-            }, cwd);
-            const second = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-2',
-                worker_index: 2,
-                trigger_message: 'IND-123 only...',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 1);
-            assert.ok(result.skipped >= 1);
-            const firstReq = await readDispatchRequest('alpha', first.request.request_id, cwd);
-            const secondReq = await readDispatchRequest('alpha', second.request.request_id, cwd);
-            assert.equal(firstReq?.status, 'notified');
-            assert.equal(secondReq?.status, 'pending');
-            assert.equal(secondReq?.attempt_count, 0);
-        }
-        finally {
-            if (typeof previousIssueCooldown === 'string')
-                process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = previousIssueCooldown;
-            else
-                delete process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('skips repeated same-issue reinjection during per-issue cooldown window', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        const previousCooldown = process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-        let injectCount = 0;
-        try {
-            process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = '900000';
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const first = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'IND-123 only...',
-            }, cwd);
-            const second = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'IND-123 only: retry',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const injector = async () => {
-                injectCount += 1;
-                return { ok: true, reason: 'tmux_send_keys_unconfirmed' };
-            };
-            const firstTick = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector });
-            const secondTick = await mod.drainPendingTeamDispatch({ cwd, maxPerTick: 5, injector });
-            assert.equal(firstTick.processed, 0);
-            assert.ok(firstTick.skipped >= 1);
-            assert.equal(secondTick.processed, 0);
-            assert.ok(secondTick.skipped >= 2);
-            assert.equal(injectCount, 1, 'same issue should not be reinjected while cooldown is active');
-            const firstRequest = await readDispatchRequest('alpha', first.request.request_id, cwd);
-            const secondRequest = await readDispatchRequest('alpha', second.request.request_id, cwd);
-            assert.equal(firstRequest?.status, 'pending');
-            assert.equal(firstRequest?.attempt_count, 1);
-            assert.equal(secondRequest?.status, 'pending');
-            assert.equal(secondRequest?.attempt_count, 0, 'cooldown-blocked request should remain untouched');
-        }
-        finally {
-            if (typeof previousCooldown === 'string')
-                process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS = previousCooldown;
-            else
-                delete process.env.RCS_TEAM_DISPATCH_ISSUE_COOLDOWN_MS;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('resolves session-only dispatch targets without managed leader session context', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-dispatch-session-target-'));
-        const stateDir = join(cwd, '.rcs', 'state');
-        const logsDir = join(cwd, '.rcs', 'logs');
-        const tmuxLogPath = join(cwd, 'tmux.log');
-        const fakeBinDir = join(cwd, 'fake-bin');
-        try {
-            await mkdir(logsDir, { recursive: true });
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeFile(join(fakeBinDir, 'tmux'), buildFakeTmux(tmuxLogPath));
-            await chmod(join(fakeBinDir, 'tmux'), 0o755);
-            await initTeamState('session-target-team', 'task', 'executor', 1, cwd);
-            const cfg = await readTeamConfig('session-target-team', cwd);
-            assert.ok(cfg);
-            if (!cfg)
-                throw new Error('missing team config');
-            cfg.tmux_session = 'rcs-team-session-target';
-            cfg.leader_pane_id = '%42';
-            if (Array.isArray(cfg.workers) && cfg.workers[0]) {
-                delete cfg.workers[0].pane_id;
-            }
-            await saveTeamConfig(cfg, cwd);
-            await enqueueDispatchRequest('session-target-team', {
-                kind: 'nudge',
-                to_worker: 'worker-1',
-                trigger_message: 'dispatch ping',
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const prevPath = process.env.PATH;
-            process.env.PATH = `${fakeBinDir}:${prevPath || ''}`;
-            try {
-                await mod.drainPendingTeamDispatch({ cwd, stateDir, logsDir, maxPerTick: 5 });
-            }
-            finally {
-                process.env.PATH = prevPath;
-            }
-            const requests = JSON.parse(await readFile(join(stateDir, 'team', 'session-target-team', 'dispatch', 'requests.json'), 'utf-8'));
-            const request = requests.find((entry) => entry.to_worker === 'worker-1');
-            assert.notEqual(request?.status, 'failed');
-            assert.doesNotMatch(JSON.stringify(request), /target_resolution_failed/);
-            const tmuxLog = await readFile(tmuxLogPath, 'utf-8');
-            assert.match(tmuxLog, /list-panes -t rcs-team-session-target/);
-            assert.match(tmuxLog, /send-keys -t %42 -l dispatch ping/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('skips non-hook transport preferences in hook consumer', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-hook-team-dispatch-'));
-        try {
-            await initTeamState('alpha', 'task', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('alpha', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                worker_index: 1,
-                trigger_message: 'ping',
-                transport_preference: 'transport_direct',
-                fallback_allowed: false,
-            }, cwd);
-            const modulePath = new URL('../../../dist/scripts/notify-hook/team-dispatch.js', import.meta.url).pathname;
-            const mod = await import(pathToFileURL(modulePath).href);
-            const result = await mod.drainPendingTeamDispatch({
-                cwd,
-                maxPerTick: 5,
-                injector: async () => ({ ok: true, reason: 'injected_for_test' }),
-            });
-            assert.equal(result.processed, 0);
-            assert.equal(result.failed, 0);
-            assert.ok(result.skipped >= 1);
-            const request = await readDispatchRequest('alpha', queued.request.request_id, cwd);
-            assert.equal(request?.status, 'pending');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-});
-//# sourceMappingURL=notify-hook-team-dispatch.test.js.map