@jstn-sdk/rcs 0.1.0 → 0.1.1

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

@@ -1,1859 +0,0 @@
-import { afterEach, beforeEach, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmod, mkdtemp, rm, writeFile, readFile, mkdir, utimes } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { existsSync, readFileSync } from 'fs';
-import { ABSOLUTE_MAX_WORKERS, DEFAULT_MAX_WORKERS, cleanupTeamState, createTask, claimTask, computeTaskReadiness, getTeamSummary, initTeamState, listTasks, migrateV1ToV2, readTask, readTeamConfig, readTeamManifestV2, transitionTaskStatus, releaseTaskClaim, reclaimExpiredTaskClaim, sendDirectMessage, broadcastMessage, markMessageDelivered, markMessageNotified, listMailboxMessages, writeTaskApproval, readTaskApproval, readWorkerHeartbeat, readWorkerStatus, updateTask, updateWorkerHeartbeat, writeAtomic, setWriteAtomicRenameForTests, resetWriteAtomicRenameForTests, writeWorkerInbox, enqueueDispatchRequest, listDispatchRequests, markDispatchRequestNotified, markDispatchRequestDelivered, transitionDispatchRequest, readDispatchRequest, readMonitorSnapshot, resolveDispatchLockTimeoutMs, } from '../state.js';
-import { normalizeDispatchRequest } from '../state/dispatch.js';
-const ORIGINAL_RCS_TEAM_STATE_ROOT = process.env.RCS_TEAM_STATE_ROOT;
-beforeEach(() => {
-    delete process.env.RCS_TEAM_STATE_ROOT;
-});
-afterEach(() => {
-    resetWriteAtomicRenameForTests();
-    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;
-});
-async function writeCompatRuntimeFixture(runtimePath, runtimeLogPath) {
-    await writeFile(runtimePath, `#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-
-const argv = process.argv.slice(2);
-fs.appendFileSync(${JSON.stringify(runtimeLogPath)}, argv.join(' ') + '\\n');
-
-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 ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-}
-
-function readJson(file, fallback) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return fallback;
-  }
-}
-
-function writeJson(file, value) {
-  ensureDir(path.dirname(file));
-  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, metadata: command.metadata ?? null }) + '\\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 'MarkDelivered': {
-    const record = dispatch.records.find((entry) => entry.request_id === command.request_id);
-    if (record) {
-      record.status = 'delivered';
-      record.delivered_at = timestamp;
-      writeJson(dispatchPath, dispatch);
-    }
-    process.stdout.write(JSON.stringify({ event: 'DispatchDelivered', request_id: command.request_id }) + '\\n');
-    process.exit(0);
-  }
-  case 'MarkFailed': {
-    const record = dispatch.records.find((entry) => entry.request_id === command.request_id);
-    if (record) {
-      record.status = 'failed';
-      record.failed_at = timestamp;
-      record.reason = command.reason;
-      writeJson(dispatchPath, dispatch);
-    }
-    process.stdout.write(JSON.stringify({ event: 'DispatchFailed', request_id: command.request_id, reason: command.reason }) + '\\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);
-  }
-  case 'MarkMailboxDelivered': {
-    const record = mailbox.records.find((entry) => entry.message_id === command.message_id);
-    if (record) {
-      record.delivered_at = timestamp;
-      writeJson(mailboxPath, mailbox);
-    }
-    process.stdout.write(JSON.stringify({ event: 'MailboxDelivered', message_id: command.message_id }) + '\\n');
-    process.exit(0);
-  }
-  default:
-    process.exit(1);
-}
-`);
-    await chmod(runtimePath, 0o755);
-}
-describe('team state', () => {
-    it('initTeamState creates correct directory structure and config.json', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            const cfg = await initTeamState('team-1', 'do stuff', 'executor', 2, cwd);
-            const root = join(cwd, '.rcs', 'state', 'team', 'team-1');
-            assert.equal(existsSync(root), true);
-            assert.equal(existsSync(join(root, 'workers')), true);
-            assert.equal(existsSync(join(root, 'workers', 'worker-1')), true);
-            assert.equal(existsSync(join(root, 'workers', 'worker-2')), true);
-            assert.equal(existsSync(join(root, 'tasks')), true);
-            assert.equal(existsSync(join(root, 'claims')), true);
-            assert.equal(existsSync(join(root, 'mailbox')), true);
-            assert.equal(existsSync(join(root, 'events')), true);
-            assert.equal(existsSync(join(root, 'manifest.v2.json')), true);
-            const configPath = join(root, 'config.json');
-            assert.equal(existsSync(configPath), true);
-            const diskCfg = JSON.parse(readFileSync(configPath, 'utf8'));
-            assert.equal(cfg.name, 'team-1');
-            assert.equal(diskCfg.name, 'team-1');
-            assert.equal(diskCfg.task, 'do stuff');
-            assert.equal(diskCfg.agent_type, 'executor');
-            assert.equal(diskCfg.worker_count, 2);
-            assert.equal(diskCfg.max_workers, DEFAULT_MAX_WORKERS);
-            assert.equal(diskCfg.tmux_session, 'rcs-team-team-1');
-            assert.equal(diskCfg.lifecycle_profile, 'default');
-            assert.equal(diskCfg.leader_pane_id, null);
-            assert.equal(diskCfg.hud_pane_id, null);
-            assert.equal(diskCfg.resize_hook_name, null);
-            assert.equal(diskCfg.resize_hook_target, null);
-            assert.equal(typeof diskCfg.next_task_id, 'number');
-            assert.ok(Array.isArray(diskCfg.workers));
-            assert.equal(diskCfg.workers.length, 2);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState persists the default lifecycle profile', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-lifecycle-profile-'));
-        try {
-            const cfg = await initTeamState('team-linked', 'do stuff', 'executor', 1, cwd, DEFAULT_MAX_WORKERS, process.env, {}, 'default');
-            assert.equal(cfg.lifecycle_profile, 'default');
-            const readCfg = await readTeamConfig('team-linked', cwd);
-            const manifest = await readTeamManifestV2('team-linked', cwd);
-            assert.equal(readCfg?.lifecycle_profile, 'default');
-            assert.equal(manifest?.lifecycle_profile, 'default');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('migrateV1ToV2 writes manifest.v2.json idempotently from legacy config.json', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-migrate-'));
-        try {
-            await initTeamState('team-mig', 't', 'executor', 1, cwd);
-            // Simulate a legacy team by removing v2 manifest.
-            const root = join(cwd, '.rcs', 'state', 'team', 'team-mig');
-            await rm(join(root, 'manifest.v2.json'), { force: true });
-            const m1 = await migrateV1ToV2('team-mig', cwd);
-            assert.ok(m1);
-            const onDisk1 = await readTeamManifestV2('team-mig', cwd);
-            assert.ok(onDisk1);
-            assert.equal(onDisk1?.lifecycle_profile, 'default');
-            const m2 = await migrateV1ToV2('team-mig', cwd);
-            assert.deepEqual(m2, onDisk1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('normalizes legacy manifest policy with dispatch defaults, timeout bounds, and governance split', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-manifest-policy-'));
-        try {
-            await initTeamState('team-policy', 't', 'executor', 1, cwd);
-            const manifestPath = join(cwd, '.rcs', 'state', 'team', 'team-policy', 'manifest.v2.json');
-            const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
-            const policy = (manifest.policy ?? {});
-            delete policy.dispatch_mode;
-            policy.dispatch_ack_timeout_ms = 999_999;
-            policy.delegation_only = true;
-            policy.nested_teams_allowed = true;
-            policy.cleanup_requires_all_workers_inactive = false;
-            policy.team_decomposition = { decomposition_source: 'dag_sidecar' };
-            manifest.policy = policy;
-            delete manifest.governance;
-            await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-            const loaded = await readTeamManifestV2('team-policy', cwd);
-            assert.equal(loaded?.policy.dispatch_mode, 'hook_preferred_with_fallback');
-            assert.equal(loaded?.policy.dispatch_ack_timeout_ms, 10_000);
-            assert.equal(loaded?.governance.delegation_only, true);
-            assert.equal(loaded?.governance.nested_teams_allowed, true);
-            assert.equal(loaded?.governance.cleanup_requires_all_workers_inactive, false);
-            assert.equal('delegation_only' in (loaded?.policy ?? {}), false);
-            assert.equal('nested_teams_allowed' in (loaded?.policy ?? {}), false);
-            assert.equal('cleanup_requires_all_workers_inactive' in (loaded?.policy ?? {}), false);
-            assert.equal('team_decomposition' in (loaded?.policy ?? {}), false);
-            assert.deepEqual(loaded?.team_decomposition, { decomposition_source: 'dag_sidecar' });
-            const freshCwd = await mkdtemp(join(tmpdir(), 'rcs-team-manifest-policy-default-'));
-            try {
-                await initTeamState('team-policy-default', 't', 'executor', 1, freshCwd);
-                const fresh = await readTeamManifestV2('team-policy-default', freshCwd);
-                assert.equal(fresh?.policy.dispatch_ack_timeout_ms, 2_000);
-                assert.equal(fresh?.governance.cleanup_requires_all_workers_inactive, true);
-                const freshManifestPath = join(freshCwd, '.rcs', 'state', 'team', 'team-policy-default', 'manifest.v2.json');
-                const persisted = JSON.parse(await readFile(freshManifestPath, 'utf8'));
-                assert.equal('delegation_only' in (persisted.policy ?? {}), false);
-                assert.equal(persisted.governance?.delegation_only, false);
-            }
-            finally {
-                await rm(freshCwd, { recursive: true, force: true });
-            }
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('dispatch bridge queue uses the same request id as the TS store', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-dispatch-bridge-sync-'));
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        try {
-            await initTeamState('team-dispatch-sync', 't', 'executor', 1, cwd);
-            const fakeBinDir = join(cwd, 'fake-bin');
-            const runtimeLogPath = join(cwd, 'runtime.log');
-            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":"DispatchQueued","request_id":"ok","target":"worker-1"}\n'
-  exit 0
-fi
-exit 1
-`);
-            await chmod(join(fakeBinDir, 'rcs-runtime'), 0o755);
-            process.env.RCS_RUNTIME_BINARY = join(fakeBinDir, 'rcs-runtime');
-            const queued = await enqueueDispatchRequest('team-dispatch-sync', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                trigger_message: 'ping',
-                intent: 'followup-relaunch',
-            }, cwd);
-            const runtimeLog = await readFile(runtimeLogPath, 'utf8');
-            const queueLine = runtimeLog.split('\n').find((line) => line.startsWith('exec {"command":"QueueDispatch"'));
-            assert.ok(queueLine, 'expected QueueDispatch bridge call');
-            const jsonStart = queueLine.indexOf('{');
-            const stateDirFlag = queueLine.lastIndexOf(' --state-dir=');
-            const jsonPayload = stateDirFlag > jsonStart ? queueLine.slice(jsonStart, stateDirFlag) : queueLine.slice(jsonStart);
-            const payload = JSON.parse(jsonPayload);
-            assert.equal(payload.request_id, queued.request.request_id);
-            assert.equal(payload.metadata?.intent, 'followup-relaunch');
-        }
-        finally {
-            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('dispatch request store enqueues, dedupes, and transitions idempotently', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-dispatch-store-'));
-        try {
-            await initTeamState('team-dispatch', 't', 'executor', 1, cwd);
-            const first = await enqueueDispatchRequest('team-dispatch', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                message_id: 'msg-1',
-                trigger_message: 'check mailbox',
-                intent: 'pending-mailbox-review',
-            }, cwd);
-            assert.equal(first.deduped, false);
-            const dup = await enqueueDispatchRequest('team-dispatch', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                message_id: 'msg-1',
-                trigger_message: 'check mailbox',
-            }, cwd);
-            assert.equal(dup.deduped, true);
-            assert.equal(dup.request.request_id, first.request.request_id);
-            const notified = await markDispatchRequestNotified('team-dispatch', first.request.request_id, {}, cwd);
-            assert.equal(notified?.status, 'notified');
-            const notifiedAgain = await markDispatchRequestNotified('team-dispatch', first.request.request_id, {}, cwd);
-            assert.equal(notifiedAgain?.status, 'notified');
-            const delivered = await markDispatchRequestDelivered('team-dispatch', first.request.request_id, {}, cwd);
-            assert.equal(delivered?.status, 'delivered');
-            const listed = await listDispatchRequests('team-dispatch', cwd);
-            assert.equal(listed.length, 1);
-            assert.equal(listed[0]?.message_id, 'msg-1');
-            assert.equal(listed[0]?.intent, 'pending-mailbox-review');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('prefers bridge-authored dispatch records without mutating the legacy requests file', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-dispatch-bridge-authority-'));
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        try {
-            await initTeamState('team-dispatch-bridge-authority', 't', 'executor', 1, cwd);
-            const fakeBinDir = join(cwd, 'fake-bin');
-            const runtimeLogPath = join(cwd, 'runtime.log');
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeCompatRuntimeFixture(join(fakeBinDir, 'rcs-runtime'), runtimeLogPath);
-            process.env.RCS_RUNTIME_BINARY = join(fakeBinDir, 'rcs-runtime');
-            const legacyPath = join(cwd, '.rcs', 'state', 'team', 'team-dispatch-bridge-authority', 'dispatch', 'requests.json');
-            const before = await readFile(legacyPath, 'utf8');
-            assert.equal(JSON.parse(before).length, 0);
-            const queued = await enqueueDispatchRequest('team-dispatch-bridge-authority', {
-                kind: 'mailbox',
-                to_worker: 'worker-1',
-                message_id: 'bridge-msg-1',
-                trigger_message: 'check mailbox',
-            }, cwd);
-            const requests = await listDispatchRequests('team-dispatch-bridge-authority', cwd);
-            assert.equal(requests.length, 1);
-            assert.equal(requests[0]?.request_id, queued.request.request_id);
-            assert.equal(requests[0]?.message_id, 'bridge-msg-1');
-            await markDispatchRequestNotified('team-dispatch-bridge-authority', queued.request.request_id, {}, cwd);
-            await markDispatchRequestDelivered('team-dispatch-bridge-authority', queued.request.request_id, {}, cwd);
-            const delivered = await readDispatchRequest('team-dispatch-bridge-authority', queued.request.request_id, cwd);
-            assert.equal(delivered?.status, 'delivered');
-            const after = await readFile(legacyPath, 'utf8');
-            assert.deepEqual(JSON.parse(after), [], 'bridge-success path should not rewrite legacy dispatch requests.json');
-        }
-        finally {
-            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('dispatch request store keeps failed requests failed while allowing reason patches', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-dispatch-store-failed-'));
-        try {
-            await initTeamState('team-dispatch-failed', 't', 'executor', 1, cwd);
-            const queued = await enqueueDispatchRequest('team-dispatch-failed', {
-                kind: 'inbox',
-                to_worker: 'worker-1',
-                trigger_message: 'ping',
-            }, cwd);
-            await transitionDispatchRequest('team-dispatch-failed', queued.request.request_id, 'pending', 'failed', { last_reason: 'initial_failure' }, cwd);
-            const recovered = await markDispatchRequestNotified('team-dispatch-failed', queued.request.request_id, { last_reason: 'fallback_confirmed:tmux_send_keys_sent', failed_at: undefined }, cwd);
-            assert.equal(recovered, null);
-            const patched = await transitionDispatchRequest('team-dispatch-failed', queued.request.request_id, 'failed', 'failed', { last_reason: 'fallback_confirmed_after_failed_receipt:tmux_send_keys_sent' }, cwd);
-            assert.equal(patched?.status, 'failed');
-            assert.equal(patched?.last_reason, 'fallback_confirmed_after_failed_receipt:tmux_send_keys_sent');
-            const reread = await readDispatchRequest('team-dispatch-failed', queued.request.request_id, cwd);
-            assert.equal(reread?.status, 'failed');
-            assert.equal(reread?.failed_at, patched?.failed_at);
-            assert.equal(reread?.last_reason, 'fallback_confirmed_after_failed_receipt:tmux_send_keys_sent');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState persists workspace metadata to config + manifest', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-metadata-'));
-        try {
-            const cfg = await initTeamState('team-meta', 't', 'executor', 1, cwd, DEFAULT_MAX_WORKERS, process.env, {
-                leader_cwd: '/tmp/leader',
-                team_state_root: '/tmp/leader/.rcs/state',
-                workspace_mode: 'worktree',
-                worktree_mode: { enabled: true, detached: false, name: 'feature/team-meta' },
-            });
-            assert.equal(cfg.leader_cwd, '/tmp/leader');
-            assert.equal(cfg.team_state_root, '/tmp/leader/.rcs/state');
-            assert.equal(cfg.workspace_mode, 'worktree');
-            assert.deepEqual(cfg.worktree_mode, { enabled: true, detached: false, name: 'feature/team-meta' });
-            const manifest = await readTeamManifestV2('team-meta', cwd);
-            assert.ok(manifest);
-            assert.equal(manifest?.leader_cwd, '/tmp/leader');
-            assert.equal(manifest?.team_state_root, '/tmp/leader/.rcs/state');
-            assert.equal(manifest?.workspace_mode, 'worktree');
-            assert.deepEqual(manifest?.worktree_mode, { enabled: true, detached: false, name: 'feature/team-meta' });
-            assert.equal(manifest?.lifecycle_profile, 'default');
-            assert.equal(manifest?.leader_pane_id, null);
-            assert.equal(manifest?.hud_pane_id, null);
-            assert.equal(manifest?.resize_hook_name, null);
-            assert.equal(manifest?.resize_hook_target, null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('resolves task/mailbox/approval paths under explicit RCS_TEAM_STATE_ROOT from a worker cwd (worker-env contamination regression)', async () => {
-        const root = await mkdtemp(join(tmpdir(), 'rcs-team-explicit-root-'));
-        const leaderCwd = join(root, 'leader');
-        const workerCwd = join(root, 'worker-worktree');
-        const explicitStateRoot = join(leaderCwd, '.rcs', 'state');
-        const prevRoot = process.env.RCS_TEAM_STATE_ROOT;
-        try {
-            await mkdir(leaderCwd, { recursive: true });
-            await mkdir(workerCwd, { recursive: true });
-            await initTeamState('team-explicit-root', 't', 'executor', 1, leaderCwd);
-            process.env.RCS_TEAM_STATE_ROOT = explicitStateRoot;
-            const task = await createTask('team-explicit-root', { subject: 'explicit root task', description: 'regression guard', status: 'pending' }, workerCwd);
-            const claim = await claimTask('team-explicit-root', task.id, 'worker-1', task.version ?? 1, workerCwd);
-            assert.equal(claim.ok, true);
-            await sendDirectMessage('team-explicit-root', 'worker-1', 'leader-fixed', 'hello from worker cwd', workerCwd);
-            const messages = await listMailboxMessages('team-explicit-root', 'leader-fixed', workerCwd);
-            assert.equal(messages.length, 1);
-            assert.equal(messages[0]?.body, 'hello from worker cwd');
-            const approvalRecord = {
-                task_id: task.id,
-                required: true,
-                status: 'approved',
-                reviewer: 'leader-fixed',
-                decision_reason: 'path guard uses resolved team state root',
-                decided_at: new Date().toISOString(),
-            };
-            await writeTaskApproval('team-explicit-root', approvalRecord, workerCwd);
-            const approval = await readTaskApproval('team-explicit-root', task.id, workerCwd);
-            assert.equal(approval?.status, 'approved');
-            assert.equal(approval?.reviewer, 'leader-fixed');
-            const explicitTeamRoot = join(explicitStateRoot, 'team', 'team-explicit-root');
-            assert.equal(existsSync(join(explicitTeamRoot, 'tasks', `task-${task.id}.json`)), true);
-            assert.equal(existsSync(join(explicitTeamRoot, 'mailbox', 'leader-fixed.json')), true);
-            assert.equal(existsSync(join(explicitTeamRoot, 'approvals', `task-${task.id}.json`)), true);
-            assert.equal(existsSync(join(workerCwd, '.rcs', 'state', 'team', 'team-explicit-root')), false);
-        }
-        finally {
-            if (typeof prevRoot === 'string')
-                process.env.RCS_TEAM_STATE_ROOT = prevRoot;
-            else
-                delete process.env.RCS_TEAM_STATE_ROOT;
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it('claimTask enforces dependency readiness (blocked_dependency)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-'));
-        try {
-            await initTeamState('team-deps', 't', 'executor', 1, cwd);
-            const dep = await createTask('team-deps', { subject: 'dep', description: 'd', status: 'pending' }, cwd);
-            const t = await createTask('team-deps', { subject: 'main', description: 'd', status: 'pending', depends_on: [dep.id] }, cwd);
-            const readiness = await computeTaskReadiness('team-deps', t.id, cwd);
-            assert.equal(readiness.ready, false);
-            const claim = await claimTask('team-deps', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, false);
-            assert.equal(claim.ok ? 'x' : claim.error, 'blocked_dependency');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask rejects in-progress claim takeover when expectedVersion is null (issue-172)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-inprogress-'));
-        try {
-            await initTeamState('team-claim-inprogress', 't', 'executor', 2, cwd);
-            const t = await createTask('team-claim-inprogress', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            // worker-1 claims the task successfully
-            const claim1 = await claimTask('team-claim-inprogress', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim1.ok, true);
-            // worker-2 tries to steal the claim with no expectedVersion (null) — must fail
-            const steal = await claimTask('team-claim-inprogress', t.id, 'worker-2', null, cwd);
-            assert.equal(steal.ok, false);
-            assert.equal(steal.ok ? 'x' : steal.error, 'claim_conflict');
-            // Verify worker-1 still owns the task
-            const task = await readTask('team-claim-inprogress', t.id, cwd);
-            assert.equal(task?.owner, 'worker-1');
-            assert.equal(task?.status, 'in_progress');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask rejects in-progress claim takeover even with a matching version', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-inprogress-ver-'));
-        try {
-            await initTeamState('team-claim-inprogress-ver', 't', 'executor', 2, cwd);
-            const t = await createTask('team-claim-inprogress-ver', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            // worker-1 claims the task, advancing version to 2
-            const claim1 = await claimTask('team-claim-inprogress-ver', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim1.ok, true);
-            const claimedVersion = claim1.ok ? claim1.task.version : 0;
-            // worker-2 tries to steal using the current (post-claim) version — must still fail
-            const steal = await claimTask('team-claim-inprogress-ver', t.id, 'worker-2', claimedVersion, cwd);
-            assert.equal(steal.ok, false);
-            assert.equal(steal.ok ? 'x' : steal.error, 'claim_conflict');
-            const task = await readTask('team-claim-inprogress-ver', t.id, cwd);
-            assert.equal(task?.owner, 'worker-1');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask claim locking yields deterministic claim_conflict', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-lock-'));
-        try {
-            // Use 2 workers so both claimants are registered in the team.
-            await initTeamState('team-lock', 't', 'executor', 2, cwd);
-            const t = await createTask('team-lock', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            // Both try to claim based on the same expected version; only one should succeed.
-            const [c1, c2] = await Promise.all([
-                claimTask('team-lock', t.id, 'worker-1', t.version ?? 1, cwd),
-                claimTask('team-lock', t.id, 'worker-2', t.version ?? 1, cwd),
-            ]);
-            const oks = [c1, c2].filter((c) => c.ok).length;
-            const conflicts = [c1, c2].filter((c) => !c.ok && c.error === 'claim_conflict').length;
-            assert.equal(oks, 1);
-            assert.equal(conflicts, 1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask recovers a stale task claim lock and proceeds', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-stale-lock-'));
-        try {
-            await initTeamState('team-stale-lock', 't', 'executor', 1, cwd);
-            const t = await createTask('team-stale-lock', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const staleLockDir = join(cwd, '.rcs', 'state', 'team', 'team-stale-lock', 'claims', `task-${t.id}.lock`);
-            await mkdir(staleLockDir, { recursive: true });
-            await writeFile(join(staleLockDir, 'owner'), 'stale-owner');
-            const staleTs = new Date(Date.now() - 10 * 60_000);
-            await utimes(staleLockDir, staleTs, staleTs);
-            const claim = await claimTask('team-stale-lock', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask owner write failure cleans up claim lock without orphan lock dir', { concurrency: false }, async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-owner-write-fail-'));
-        let previousUmask = null;
-        try {
-            await initTeamState('team-owner-write-fail', 't', 'executor', 1, cwd);
-            const t = await createTask('team-owner-write-fail', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            previousUmask = process.umask(0o222);
-            await assert.rejects(() => claimTask('team-owner-write-fail', t.id, 'worker-1', t.version ?? 1, cwd), /(EACCES|EPERM|permission denied)/i);
-            const lockDir = join(cwd, '.rcs', 'state', 'team', 'team-owner-write-fail', 'claims', `task-${t.id}.lock`);
-            assert.equal(existsSync(lockDir), false);
-        }
-        finally {
-            if (typeof previousUmask === 'number')
-                process.umask(previousUmask);
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask rejects a pending task with residual owner/claim metadata', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-residual-claim-'));
-        try {
-            await initTeamState('team-claim-residual', 't', 'executor', 1, cwd);
-            const t = await createTask('team-claim-residual', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-claim-residual', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.owner = 'worker-1';
-            current.claim = {
-                owner: 'worker-1',
-                token: 'stale-token',
-                leased_until: new Date(Date.now() + 5 * 60_000).toISOString(),
-            };
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            const claim = await claimTask('team-claim-residual', t.id, 'worker-1', null, cwd);
-            assert.equal(claim.ok, false);
-            assert.equal(claim.ok ? 'x' : claim.error, 'claim_conflict');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask allows a worker to claim its own pre-assigned pending task', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-assigned-owner-'));
-        try {
-            await initTeamState('team-claim-assigned-owner', 't', 'executor', 2, cwd);
-            const t = await createTask('team-claim-assigned-owner', { subject: 'a', description: 'd', status: 'pending', owner: 'worker-1' }, cwd);
-            const claim = await claimTask('team-claim-assigned-owner', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            assert.equal(claim.task.status, 'in_progress');
-            assert.equal(claim.task.owner, 'worker-1');
-            assert.ok(claim.task.claim);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask rejects pending task pre-assigned to a different worker', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-claim-owner-mismatch-'));
-        try {
-            await initTeamState('team-claim-owner-mismatch', 't', 'executor', 2, cwd);
-            const t = await createTask('team-claim-owner-mismatch', { subject: 'a', description: 'd', status: 'pending', owner: 'worker-1' }, cwd);
-            const claim = await claimTask('team-claim-owner-mismatch', t.id, 'worker-2', t.version ?? 1, cwd);
-            assert.equal(claim.ok, false);
-            assert.equal(claim.ok ? 'x' : claim.error, 'claim_conflict');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus returns invalid_transition for illegal transition', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-transition-'));
-        try {
-            await initTeamState('team-trans', 't', 'executor', 1, cwd);
-            const t = await createTask('team-trans', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-trans', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const bad = await transitionTaskStatus('team-trans', t.id, 'pending', 'completed', claim.claimToken, cwd);
-            assert.equal(bad.ok, false);
-            assert.equal(bad.ok ? 'x' : bad.error, 'invalid_transition');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus rejects non-terminal transitions from in_progress', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-transition-nonterminal-'));
-        try {
-            await initTeamState('team-trans-nonterminal', 't', 'executor', 1, cwd);
-            const t = await createTask('team-trans-nonterminal', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-trans-nonterminal', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const bad = await transitionTaskStatus('team-trans-nonterminal', t.id, 'in_progress', 'pending', claim.claimToken, cwd);
-            assert.equal(bad.ok, false);
-            assert.equal(bad.ok ? 'x' : bad.error, 'invalid_transition');
-            const reread = await readTask('team-trans-nonterminal', t.id, cwd);
-            assert.equal(reread?.status, 'in_progress');
-            assert.equal(reread?.owner, 'worker-1');
-            assert.ok(reread?.claim);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus returns claim_conflict when claim owner diverges from task owner', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-transition-owner-diverge-'));
-        try {
-            await initTeamState('team-trans-owner-diverge', 't', 'executor', 2, cwd);
-            const t = await createTask('team-trans-owner-diverge', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-trans-owner-diverge', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-trans-owner-diverge', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.owner = 'worker-2';
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            const result = await transitionTaskStatus('team-trans-owner-diverge', t.id, 'in_progress', 'completed', claim.claimToken, cwd);
-            assert.equal(result.ok, false);
-            assert.equal(result.ok ? 'x' : result.error, 'claim_conflict');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus appends task_completed event when task completes', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-events-'));
-        try {
-            await initTeamState('team-events', 't', 'executor', 1, cwd);
-            const t = await createTask('team-events', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-events', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            const token = claim.ok ? claim.claimToken : 'x';
-            const tr = await transitionTaskStatus('team-events', t.id, 'in_progress', 'completed', token, cwd);
-            assert.equal(tr.ok, true);
-            const eventsPath = join(cwd, '.rcs', 'state', 'team', 'team-events', 'events', 'events.ndjson');
-            const content = await readFile(eventsPath, 'utf-8');
-            assert.match(content, /\"type\":\"task_completed\"/);
-            assert.match(content, new RegExp(`\"task_id\":\"${t.id}\"`));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus rejects broad delegated completion without spawn evidence or skip reason', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-delegation-evidence-'));
-        try {
-            await initTeamState('team-delegation-evidence', 't', 'executor', 1, cwd);
-            const t = await createTask('team-delegation-evidence', {
-                subject: 'Investigate flaky runtime behavior',
-                description: 'Search runtime and debug flaky assignment behavior',
-                status: 'pending',
-                delegation: {
-                    mode: 'auto',
-                    required_parallel_probe: true,
-                    skip_allowed_reason_required: true,
-                },
-            }, cwd);
-            const claim = await claimTask('team-delegation-evidence', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const missing = await transitionTaskStatus('team-delegation-evidence', t.id, 'in_progress', 'completed', claim.claimToken, cwd, { result: 'Verification:\nPASS - focused regression' });
-            assert.equal(missing.ok, false);
-            assert.equal(missing.ok ? 'x' : missing.error, 'missing_delegation_compliance_evidence');
-            const reread = await readTask('team-delegation-evidence', t.id, cwd);
-            assert.equal(reread?.status, 'in_progress');
-            const completedWithSpawnEvidence = await transitionTaskStatus('team-delegation-evidence', t.id, 'in_progress', 'completed', claim.claimToken, cwd, {
-                result: [
-                    'Verification:',
-                    'PASS - focused regression',
-                    'Subagent spawn evidence: spawned 2 native subagents for runtime map and test probe',
-                ].join('\n'),
-            });
-            assert.equal(completedWithSpawnEvidence.ok, true);
-            assert.equal(completedWithSpawnEvidence.task.delegation_compliance?.status, 'spawned');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus requires evidence when optional delegation carries required parallel probe', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-optional-required-probe-'));
-        try {
-            await initTeamState('team-optional-required-probe', 't', 'executor', 1, cwd);
-            const t = await createTask('team-optional-required-probe', {
-                subject: 'Investigate optional delegated runtime behavior',
-                description: 'Optional mode was elevated by a required parallel probe from review enforcement',
-                status: 'pending',
-                delegation: {
-                    mode: 'optional',
-                    required_parallel_probe: true,
-                    skip_allowed_reason_required: true,
-                },
-            }, cwd);
-            const claim = await claimTask('team-optional-required-probe', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const missing = await transitionTaskStatus('team-optional-required-probe', t.id, 'in_progress', 'completed', claim.claimToken, cwd, { result: 'Verification:\nPASS - focused regression' });
-            assert.equal(missing.ok, false);
-            assert.equal(missing.ok ? 'x' : missing.error, 'missing_delegation_compliance_evidence');
-            const reread = await readTask('team-optional-required-probe', t.id, cwd);
-            assert.equal(reread?.status, 'in_progress');
-            const completed = await transitionTaskStatus('team-optional-required-probe', t.id, 'in_progress', 'completed', claim.claimToken, cwd, {
-                result: [
-                    'Verification:',
-                    'PASS - focused regression',
-                    'Subagent spawn evidence: spawned 1 native subagent for delegation evidence regression mapping',
-                ].join('\n'),
-            });
-            assert.equal(completed.ok, true);
-            assert.equal(completed.task.delegation_compliance?.status, 'spawned');
-            assert.equal(completed.task.delegation_compliance?.source, 'terminal_result');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus accepts documented skip reason for broad delegated completion', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-delegation-skip-'));
-        try {
-            await initTeamState('team-delegation-skip', 't', 'executor', 1, cwd);
-            const t = await createTask('team-delegation-skip', {
-                subject: 'Review focused regression',
-                description: 'Audit one already-isolated failing test',
-                status: 'pending',
-                delegation: {
-                    mode: 'auto',
-                    required_parallel_probe: true,
-                    skip_allowed_reason_required: true,
-                },
-            }, cwd);
-            const claim = await claimTask('team-delegation-skip', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const completed = await transitionTaskStatus('team-delegation-skip', t.id, 'in_progress', 'completed', claim.claimToken, cwd, {
-                result: [
-                    'Verification:',
-                    'PASS - focused regression',
-                    'Subagent skip reason: task scope collapsed to one isolated assertion; spawning would duplicate serial verification',
-                ].join('\n'),
-            });
-            assert.equal(completed.ok, true);
-            assert.equal(completed.task.delegation_compliance?.status, 'skipped');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus persists terminal result and error payloads', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-transition-payload-'));
-        try {
-            await initTeamState('team-transition-payload', 't', 'executor', 1, cwd);
-            const completedTask = await createTask('team-transition-payload', { subject: 'done', description: 'd', status: 'pending' }, cwd);
-            const completedClaim = await claimTask('team-transition-payload', completedTask.id, 'worker-1', completedTask.version ?? 1, cwd);
-            assert.equal(completedClaim.ok, true);
-            if (!completedClaim.ok)
-                return;
-            const completedResult = 'Verification:\nPASS - bootstrap state exists';
-            const completedTransition = await transitionTaskStatus('team-transition-payload', completedTask.id, 'in_progress', 'completed', completedClaim.claimToken, cwd, { result: completedResult });
-            assert.equal(completedTransition.ok, true);
-            const completedReread = await readTask('team-transition-payload', completedTask.id, cwd);
-            assert.equal(completedReread?.result, completedResult);
-            assert.equal(completedReread?.error, undefined);
-            const failedTask = await createTask('team-transition-payload', { subject: 'fail', description: 'd', status: 'pending' }, cwd);
-            const failedClaim = await claimTask('team-transition-payload', failedTask.id, 'worker-1', failedTask.version ?? 1, cwd);
-            assert.equal(failedClaim.ok, true);
-            if (!failedClaim.ok)
-                return;
-            const failedError = 'Verification failed: missing bootstrap evidence';
-            const failedTransition = await transitionTaskStatus('team-transition-payload', failedTask.id, 'in_progress', 'failed', failedClaim.claimToken, cwd, { error: failedError });
-            assert.equal(failedTransition.ok, true);
-            const failedReread = await readTask('team-transition-payload', failedTask.id, cwd);
-            assert.equal(failedReread?.error, failedError);
-            assert.equal(failedReread?.result, undefined);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus appends task_failed event (not worker_stopped) when task fails', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-failed-'));
-        try {
-            await initTeamState('team-failed', 't', 'executor', 1, cwd);
-            const t = await createTask('team-failed', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-failed', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            const token = claim.ok ? claim.claimToken : 'x';
-            const tr = await transitionTaskStatus('team-failed', t.id, 'in_progress', 'failed', token, cwd);
-            assert.equal(tr.ok, true);
-            const eventsPath = join(cwd, '.rcs', 'state', 'team', 'team-failed', 'events', 'events.ndjson');
-            const content = await readFile(eventsPath, 'utf-8');
-            assert.match(content, /\"type\":\"task_failed\"/);
-            assert.match(content, new RegExp(`\"task_id\":\"${t.id}\"`));
-            assert.doesNotMatch(content, /\"type\":\"worker_stopped\"/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim reverts a claimed task back to pending under claim lock', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-release-'));
-        try {
-            await initTeamState('team-release', 't', 'executor', 1, cwd);
-            const t = await createTask('team-release', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-release', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const released = await releaseTaskClaim('team-release', t.id, claim.claimToken, 'worker-1', cwd);
-            assert.equal(released.ok, true);
-            const reread = await readTask('team-release', t.id, cwd);
-            assert.equal(reread?.status, 'pending');
-            assert.equal(reread?.owner, undefined);
-            assert.equal(reread?.claim, undefined);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim returns claim_conflict when claim token changed, even for the owner', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-release-owner-'));
-        try {
-            await initTeamState('team-release-owner', 't', 'executor', 1, cwd);
-            const t = await createTask('team-release-owner', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-release-owner', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            // Simulate token drift while ownership/status remain in_progress.
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-release-owner', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.token = 'different-token';
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            const released = await releaseTaskClaim('team-release-owner', t.id, claim.claimToken, 'worker-1', cwd);
-            assert.equal(released.ok, false);
-            assert.equal(released.ok ? 'x' : released.error, 'claim_conflict');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim on a completed task returns already_terminal and does not reopen it', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-release-terminal-'));
-        try {
-            await initTeamState('team-release-terminal', 't', 'executor', 1, cwd);
-            const t = await createTask('team-release-terminal', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-release-terminal', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const tr = await transitionTaskStatus('team-release-terminal', t.id, 'in_progress', 'completed', claim.claimToken, cwd);
-            assert.equal(tr.ok, true);
-            // Verify claim was stripped on completion
-            const afterComplete = await readTask('team-release-terminal', t.id, cwd);
-            assert.equal(afterComplete?.status, 'completed');
-            assert.equal(afterComplete?.claim, undefined);
-            // Attempt to release the claim of a completed task — must be rejected
-            const released = await releaseTaskClaim('team-release-terminal', t.id, claim.claimToken, 'worker-1', cwd);
-            assert.equal(released.ok, false);
-            assert.equal(released.ok ? 'x' : released.error, 'already_terminal');
-            // Task must remain completed, not reopened
-            const reread = await readTask('team-release-terminal', t.id, cwd);
-            assert.equal(reread?.status, 'completed');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('transitionTaskStatus returns lease_expired when claim lease has passed', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-lease-trans-'));
-        try {
-            await initTeamState('team-lease-trans', 't', 'executor', 1, cwd);
-            const t = await createTask('team-lease-trans', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-lease-trans', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            // Backdate leased_until to the past to simulate expiry.
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-lease-trans', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            const result = await transitionTaskStatus('team-lease-trans', t.id, 'in_progress', 'completed', claim.claimToken, cwd);
-            assert.equal(result.ok, false);
-            assert.equal(result.ok ? 'x' : result.error, 'lease_expired');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim on a failed task returns already_terminal and does not reopen it', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-release-failed-'));
-        try {
-            await initTeamState('team-release-failed', 't', 'executor', 1, cwd);
-            const t = await createTask('team-release-failed', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-release-failed', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const tr = await transitionTaskStatus('team-release-failed', t.id, 'in_progress', 'failed', claim.claimToken, cwd);
-            assert.equal(tr.ok, true);
-            const released = await releaseTaskClaim('team-release-failed', t.id, claim.claimToken, 'worker-1', cwd);
-            assert.equal(released.ok, false);
-            assert.equal(released.ok ? 'x' : released.error, 'already_terminal');
-            const reread = await readTask('team-release-failed', t.id, cwd);
-            assert.equal(reread?.status, 'failed');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim returns lease_expired when lease has expired and caller is not the owner', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-lease-release-'));
-        try {
-            await initTeamState('team-lease-release', 't', 'executor', 1, cwd);
-            const t = await createTask('team-lease-release', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-lease-release', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            // Backdate leased_until and change owner so ownerMatches is also false.
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-lease-release', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            // Different worker tries to release with the expired token.
-            const result = await releaseTaskClaim('team-lease-release', t.id, claim.claimToken, 'worker-2', cwd);
-            assert.equal(result.ok, false);
-            assert.equal(result.ok ? 'x' : result.error, 'lease_expired');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('releaseTaskClaim returns lease_expired when lease has expired, even for the owner', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-lease-release-owner-'));
-        try {
-            await initTeamState('team-lease-release-owner', 't', 'executor', 1, cwd);
-            const t = await createTask('team-lease-release-owner', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-lease-release-owner', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            // Backdate leased_until so the claim token is no longer valid.
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-lease-release-owner', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            // Same worker releases — should now fail because owner-only bypass is removed.
-            const result = await releaseTaskClaim('team-lease-release-owner', t.id, claim.claimToken, 'worker-1', cwd);
-            assert.equal(result.ok, false);
-            assert.equal(result.ok ? 'x' : result.error, 'lease_expired');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('reclaimExpiredTaskClaim reopens an expired in-progress task so another worker can claim it', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-reclaim-expired-'));
-        try {
-            await initTeamState('team-reclaim-expired', 't', 'executor', 2, cwd);
-            const t = await createTask('team-reclaim-expired', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const claim = await claimTask('team-reclaim-expired', t.id, 'worker-1', t.version ?? 1, cwd);
-            assert.equal(claim.ok, true);
-            if (!claim.ok)
-                return;
-            const taskPath = join(cwd, '.rcs', 'state', 'team', 'team-reclaim-expired', 'tasks', `task-${t.id}.json`);
-            const current = JSON.parse(await readFile(taskPath, 'utf-8'));
-            current.claim.leased_until = new Date(Date.now() - 1000).toISOString();
-            await writeFile(taskPath, JSON.stringify(current, null, 2));
-            const reclaimed = await reclaimExpiredTaskClaim('team-reclaim-expired', t.id, cwd);
-            assert.equal(reclaimed.ok, true);
-            if (!reclaimed.ok)
-                return;
-            assert.equal(reclaimed.reclaimed, true);
-            assert.equal(reclaimed.task.status, 'pending');
-            assert.equal(reclaimed.task.claim, undefined);
-            const secondClaim = await claimTask('team-reclaim-expired', t.id, 'worker-2', reclaimed.task.version ?? null, cwd);
-            assert.equal(secondClaim.ok, true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('mailbox APIs: DM, broadcast, and mark delivered', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg', 't', 'executor', 2, cwd);
-            const dm = await sendDirectMessage('team-msg', 'worker-1', 'worker-2', 'hello', cwd);
-            assert.equal(dm.to_worker, 'worker-2');
-            const delivered = await markMessageDelivered('team-msg', 'worker-2', dm.message_id, cwd);
-            assert.equal(delivered, true);
-            const b = await broadcastMessage('team-msg', 'worker-1', 'all', cwd);
-            assert.equal(b.length, 1);
-            assert.equal(b[0]?.to_worker, 'worker-2');
-            const mailboxDisk = await readFile(join(cwd, '.rcs', 'state', 'team', 'team-msg', 'mailbox', 'worker-2.json'), 'utf8');
-            const parsed = JSON.parse(mailboxDisk);
-            assert.ok(parsed.messages.some((m) => typeof m.delivered_at === 'string'));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('uses bridge-authored mailbox records while shadowing legacy mailbox bodies for recovery', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-bridge-authority-'));
-        const previousRuntimeBinary = process.env.RCS_RUNTIME_BINARY;
-        try {
-            await initTeamState('team-mailbox-bridge-authority', 't', 'executor', 2, cwd);
-            const fakeBinDir = join(cwd, 'fake-bin');
-            const runtimeLogPath = join(cwd, 'runtime.log');
-            await mkdir(fakeBinDir, { recursive: true });
-            await writeCompatRuntimeFixture(join(fakeBinDir, 'rcs-runtime'), runtimeLogPath);
-            process.env.RCS_RUNTIME_BINARY = join(fakeBinDir, 'rcs-runtime');
-            const legacyPath = join(cwd, '.rcs', 'state', 'team', 'team-mailbox-bridge-authority', 'mailbox', 'worker-2.json');
-            assert.equal(existsSync(legacyPath), false);
-            const message = await sendDirectMessage('team-mailbox-bridge-authority', 'worker-1', 'worker-2', 'hello', cwd);
-            assert.equal(message.to_worker, 'worker-2');
-            await markMessageNotified('team-mailbox-bridge-authority', 'worker-2', message.message_id, cwd);
-            await markMessageDelivered('team-mailbox-bridge-authority', 'worker-2', message.message_id, cwd);
-            const messages = await listMailboxMessages('team-mailbox-bridge-authority', 'worker-2', cwd);
-            assert.equal(messages.length, 1);
-            assert.equal(messages[0]?.message_id, message.message_id);
-            assert.equal(messages[0]?.body, 'hello');
-            assert.equal(typeof messages[0]?.notified_at, 'string');
-            assert.equal(typeof messages[0]?.delivered_at, 'string');
-            assert.equal(existsSync(legacyPath), true, 'bridge-success path should shadow-write legacy mailbox JSON for body recovery');
-            const after = JSON.parse(await readFile(legacyPath, 'utf8'));
-            assert.equal(after.messages.length, 1);
-            assert.equal(after.messages[0]?.message_id, message.message_id);
-            assert.equal(after.messages[0]?.body, 'hello');
-            const compatPath = join(cwd, '.rcs', 'state', 'mailbox.json');
-            const compat = JSON.parse(await readFile(compatPath, 'utf8'));
-            const compatRecord = compat.records.find((entry) => entry.message_id === message.message_id);
-            assert.ok(compatRecord);
-            const runtimeLogBefore = await readFile(runtimeLogPath, 'utf8');
-            const deliveredCallsBefore = runtimeLogBefore.split('MarkMailboxDelivered').length - 1;
-            const deliveredAgain = await markMessageDelivered('team-mailbox-bridge-authority', 'worker-2', message.message_id, cwd);
-            assert.equal(deliveredAgain, true, 'already-delivered bridge message should be treated as delivered');
-            const runtimeLogAfter = await readFile(runtimeLogPath, 'utf8');
-            const deliveredCallsAfter = runtimeLogAfter.split('MarkMailboxDelivered').length - 1;
-            assert.equal(deliveredCallsAfter, deliveredCallsBefore, 'idempotent delivered calls should not invoke bridge a second time');
-            compatRecord.body = '';
-            await writeFile(compatPath, JSON.stringify(compat, null, 2));
-            const recovered = await listMailboxMessages('team-mailbox-bridge-authority', 'worker-2', cwd);
-            assert.equal(recovered.length, 1);
-            assert.equal(recovered[0]?.body, 'hello', 'legacy shadow mailbox should backfill blank compat bodies');
-        }
-        finally {
-            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('sendDirectMessage recreates mailbox directory when missing', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg-recreate-mailbox', 't', 'executor', 2, cwd);
-            await rm(join(cwd, '.rcs', 'state', 'team', 'team-msg-recreate-mailbox', 'mailbox'), {
-                recursive: true,
-                force: true,
-            });
-            const dm = await sendDirectMessage('team-msg-recreate-mailbox', 'worker-1', 'worker-2', 'hello', cwd);
-            assert.equal(dm.to_worker, 'worker-2');
-            assert.equal(existsSync(join(cwd, '.rcs', 'state', 'team', 'team-msg-recreate-mailbox', 'mailbox', 'worker-2.json')), true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('sendDirectMessage throws team not found after team cleanup', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg-missing-team', 't', 'executor', 2, cwd);
-            await rm(join(cwd, '.rcs', 'state', 'team', 'team-msg-missing-team'), {
-                recursive: true,
-                force: true,
-            });
-            await assert.rejects(() => sendDirectMessage('team-msg-missing-team', 'worker-1', 'worker-2', 'hello', cwd), /Team team-msg-missing-team not found/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('markMessageNotified stores notified_at without forcing delivered_at', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg-notify', 't', 'executor', 2, cwd);
-            const dm = await sendDirectMessage('team-msg-notify', 'worker-1', 'worker-2', 'hello', cwd);
-            const marked = await markMessageNotified('team-msg-notify', 'worker-2', dm.message_id, cwd);
-            assert.equal(marked, true);
-            const msgs = await listMailboxMessages('team-msg-notify', 'worker-2', cwd);
-            const msg = msgs.find((m) => m.message_id === dm.message_id);
-            assert.ok(msg);
-            assert.equal(typeof msg?.notified_at, 'string');
-            assert.equal(msg?.delivered_at, undefined);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('mailbox does not lose messages under concurrent sends', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg-concurrent', 't', 'executor', 3, cwd);
-            const sends = Array.from({ length: 25 }, (_, idx) => sendDirectMessage('team-msg-concurrent', 'worker-1', 'worker-2', `hello-${idx}`, cwd));
-            const delivered = await Promise.all(sends);
-            const expectedIds = new Set(delivered.map((m) => m.message_id));
-            assert.equal(expectedIds.size, 25);
-            const mailbox = await listMailboxMessages('team-msg-concurrent', 'worker-2', cwd);
-            const actualIds = new Set(mailbox.map((m) => m.message_id));
-            for (const id of expectedIds) {
-                assert.equal(actualIds.has(id), true);
-            }
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('sendDirectMessage reuses identical undelivered messages instead of appending duplicates', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-mailbox-'));
-        try {
-            await initTeamState('team-msg-dedupe', 't', 'executor', 2, cwd);
-            const first = await sendDirectMessage('team-msg-dedupe', 'worker-1', 'leader-fixed', 'same-body', cwd);
-            const second = await sendDirectMessage('team-msg-dedupe', 'worker-1', 'leader-fixed', 'same-body', cwd);
-            assert.equal(second.message_id, first.message_id);
-            const mailbox = await listMailboxMessages('team-msg-dedupe', 'leader-fixed', cwd);
-            assert.equal(mailbox.length, 1);
-            assert.equal(mailbox[0]?.body, 'same-body');
-            const delivered = await markMessageDelivered('team-msg-dedupe', 'leader-fixed', first.message_id, cwd);
-            assert.equal(delivered, true);
-            const third = await sendDirectMessage('team-msg-dedupe', 'worker-1', 'leader-fixed', 'same-body', cwd);
-            assert.notEqual(third.message_id, first.message_id);
-            const mailboxAfter = await listMailboxMessages('team-msg-dedupe', 'leader-fixed', cwd);
-            assert.equal(mailboxAfter.length, 2);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('writeTaskApproval writes record and emits approval_decision event', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-approval-'));
-        try {
-            await initTeamState('team-approval-record', 't', 'executor', 1, cwd);
-            const t = await createTask('team-approval-record', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            await writeTaskApproval('team-approval-record', {
-                task_id: t.id,
-                required: true,
-                status: 'approved',
-                reviewer: 'leader-fixed',
-                decision_reason: 'ok',
-                decided_at: new Date().toISOString(),
-            }, cwd);
-            const reread = await readTaskApproval('team-approval-record', t.id, cwd);
-            assert.ok(reread);
-            assert.equal(reread?.status, 'approved');
-            const eventsPath = join(cwd, '.rcs', 'state', 'team', 'team-approval-record', 'events', 'events.ndjson');
-            const content = await readFile(eventsPath, 'utf-8');
-            assert.match(content, /\"type\":\"approval_decision\"/);
-            assert.match(content, new RegExp(`\"task_id\":\"${t.id}\"`));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState rejects workerCount > max_workers', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await assert.rejects(() => initTeamState('team-2', 't', 'executor', DEFAULT_MAX_WORKERS + 1, cwd, DEFAULT_MAX_WORKERS), /exceeds maxWorkers/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState rejects maxWorkers > ABSOLUTE_MAX_WORKERS', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await assert.rejects(() => initTeamState('team-abs', 't', 'executor', 1, cwd, ABSOLUTE_MAX_WORKERS + 1), /exceeds ABSOLUTE_MAX_WORKERS/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('createTask auto-increments IDs', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-3', 't', 'executor', 1, cwd);
-            const t1 = await createTask('team-3', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            const t2 = await createTask('team-3', { subject: 'b', description: 'd', status: 'pending' }, cwd);
-            assert.equal(t1.id, '1');
-            assert.equal(t2.id, '2');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('createTask does not overwrite existing tasks when config next_task_id is missing (legacy)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-legacy', 't', 'executor', 1, cwd);
-            // Simulate legacy config by removing next_task_id field.
-            const configPath = join(cwd, '.rcs', 'state', 'team', 'team-legacy', 'config.json');
-            const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
-            delete cfg.next_task_id;
-            await writeAtomic(configPath, JSON.stringify(cfg, null, 2));
-            // Create an existing task-1.json, then create another task; it must get id=2.
-            const t1 = await createTask('team-legacy', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            assert.equal(t1.id, '1');
-            // Remove next_task_id again to simulate older config still missing field.
-            const cfg2 = JSON.parse(readFileSync(configPath, 'utf8'));
-            delete cfg2.next_task_id;
-            await writeAtomic(configPath, JSON.stringify(cfg2, null, 2));
-            const t2 = await createTask('team-legacy', { subject: 'b', description: 'd', status: 'pending' }, cwd);
-            assert.equal(t2.id, '2');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('createTask does not overwrite existing tasks when manifest/config next_task_id lags disk', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-stale-next-id', 't', 'executor', 1, cwd);
-            const first = await createTask('team-stale-next-id', { subject: 'first', description: 'd', status: 'pending' }, cwd);
-            assert.equal(first.id, '1');
-            const teamRoot = join(cwd, '.rcs', 'state', 'team', 'team-stale-next-id');
-            const configPath = join(teamRoot, 'config.json');
-            const manifestPath = join(teamRoot, 'manifest.v2.json');
-            const config = JSON.parse(readFileSync(configPath, 'utf8'));
-            config.next_task_id = 1;
-            await writeAtomic(configPath, JSON.stringify(config, null, 2));
-            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-            manifest.next_task_id = 1;
-            await writeAtomic(manifestPath, JSON.stringify(manifest, null, 2));
-            const second = await createTask('team-stale-next-id', { subject: 'second', description: 'd', status: 'pending' }, cwd);
-            assert.equal(second.id, '2');
-            const firstTask = JSON.parse(await readFile(join(teamRoot, 'tasks', 'task-1.json'), 'utf8'));
-            const secondTask = JSON.parse(await readFile(join(teamRoot, 'tasks', 'task-2.json'), 'utf8'));
-            assert.equal(firstTask.subject, 'first');
-            assert.equal(secondTask.subject, 'second');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('listTasks returns sorted by ID', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-4', 't', 'executor', 1, cwd);
-            await createTask('team-4', { subject: 'a', description: 'd', status: 'pending' }, cwd);
-            await createTask('team-4', { subject: 'b', description: 'd', status: 'pending' }, cwd);
-            await createTask('team-4', { subject: 'c', description: 'd', status: 'pending' }, cwd);
-            const tasks = await listTasks('team-4', cwd);
-            assert.deepEqual(tasks.map((t) => t.id), ['1', '2', '3']);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('listTasks reads task files in parallel', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-list-parallel-'));
-        try {
-            await initTeamState('team-parallel', 't', 'executor', 1, cwd);
-            const N = 20;
-            for (let i = 0; i < N; i++) {
-                await createTask('team-parallel', { subject: `task-${i}`, description: 'd', status: 'pending' }, cwd);
-            }
-            const tasks = await listTasks('team-parallel', cwd);
-            assert.equal(tasks.length, N);
-            // IDs should be consecutive strings '1'..'N' in sorted order
-            const ids = tasks.map((t) => t.id);
-            assert.deepEqual(ids, Array.from({ length: N }, (_, i) => String(i + 1)));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('listTasks ignores malformed and id-mismatched task payloads', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-list-validate-'));
-        try {
-            await initTeamState('team-list-validate', 't', 'executor', 1, cwd);
-            await createTask('team-list-validate', { subject: 'ok', description: 'd', status: 'pending' }, cwd);
-            // Internal payload id mismatches filename id -> should be ignored.
-            await writeFile(join(cwd, '.rcs', 'state', 'team', 'team-list-validate', 'tasks', 'task-2.json'), JSON.stringify({
-                id: '999',
-                subject: 'mismatch',
-                description: 'bad',
-                status: 'pending',
-                created_at: new Date().toISOString(),
-            }, null, 2));
-            // Malformed payload -> should be ignored.
-            await writeFile(join(cwd, '.rcs', 'state', 'team', 'team-list-validate', 'tasks', 'task-3.json'), JSON.stringify({ nope: true }, null, 2));
-            const tasks = await listTasks('team-list-validate', cwd);
-            assert.equal(tasks.length, 1);
-            assert.equal(tasks[0].id, '1');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('readTask returns null for non-existent task', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-5', 't', 'executor', 1, cwd);
-            const task = await readTask('team-5', '999', cwd);
-            assert.equal(task, null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('readTask returns null for malformed JSON', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-6', 't', 'executor', 1, cwd);
-            const badPath = join(cwd, '.rcs', 'state', 'team', 'team-6', 'tasks', 'task-1.json');
-            await writeFile(badPath, '{not json', 'utf8');
-            const task = await readTask('team-6', '1', cwd);
-            assert.equal(task, null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('updateTask merges updates correctly', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-7', 't', 'executor', 1, cwd);
-            const created = await createTask('team-7', { subject: 's', description: 'd', status: 'pending', owner: undefined }, cwd);
-            const updated = await updateTask('team-7', created.id, { status: 'completed', owner: 'worker-1', result: 'done', completed_at: new Date().toISOString() }, cwd);
-            assert.ok(updated);
-            assert.equal(updated?.id, created.id);
-            assert.equal(updated?.status, 'completed');
-            assert.equal(updated?.owner, 'worker-1');
-            assert.equal(updated?.result, 'done');
-            const reread = await readTask('team-7', created.id, cwd);
-            assert.equal(reread?.status, 'completed');
-            assert.equal(reread?.owner, 'worker-1');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('updateTask rejects empty string status and leaves task readable', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-upd-empty-status', 't', 'executor', 1, cwd);
-            const created = await createTask('team-upd-empty-status', { subject: 's', description: 'd', status: 'pending' }, cwd);
-            await assert.rejects(() => updateTask('team-upd-empty-status', created.id, { status: '' }, cwd), /Invalid task status/);
-            // Task must still be readable after the rejected update.
-            const reread = await readTask('team-upd-empty-status', created.id, cwd);
-            assert.ok(reread, 'task should still be readable after invalid update was rejected');
-            assert.equal(reread?.status, 'pending');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('updateTask coerces non-array depends_on to [] so claimTask does not crash', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-upd-bad-deps', 't', 'executor', 1, cwd);
-            const created = await createTask('team-upd-bad-deps', { subject: 's', description: 'd', status: 'pending' }, cwd);
-            // Pass a non-array depends_on to simulate a bad MCP payload.
-            await updateTask('team-upd-bad-deps', created.id, { depends_on: 'not-an-array' }, cwd);
-            // claimTask must not throw "deps.map is not a function".
-            const claim = await claimTask('team-upd-bad-deps', created.id, 'worker-1', null, cwd);
-            assert.equal(claim.ok, true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('updateTask is safe under concurrent calls (no lost updates)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-update-concurrent', 't', 'executor', 1, cwd);
-            const created = await createTask('team-update-concurrent', { subject: 's', description: 'd', status: 'pending', owner: undefined }, cwd);
-            await Promise.all([
-                updateTask('team-update-concurrent', created.id, { result: 'r1' }, cwd),
-                updateTask('team-update-concurrent', created.id, { error: 'e2' }, cwd),
-            ]);
-            const reread = await readTask('team-update-concurrent', created.id, cwd);
-            assert.equal(reread?.result, 'r1');
-            assert.equal(reread?.error, 'e2');
-            assert.ok((reread?.version ?? 0) >= 3);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('writeAtomic creates file and is safe to call concurrently (basic)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            const p = join(cwd, 'atomic.txt');
-            await Promise.all([writeAtomic(p, 'a'), writeAtomic(p, 'b')]);
-            assert.equal(existsSync(p), true);
-            const content = readFileSync(p, 'utf8');
-            assert.ok(content === 'a' || content === 'b');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('writeAtomic does not swallow ENOENT when destination content differs', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            const p = join(cwd, 'atomic-fallback.txt');
-            await writeFile(p, 'old', 'utf8');
-            setWriteAtomicRenameForTests(async () => {
-                const err = new Error('missing temp');
-                err.code = 'ENOENT';
-                throw err;
-            });
-            await assert.rejects(() => writeAtomic(p, 'new'), (error) => {
-                const err = error;
-                return err.code === 'ENOENT';
-            });
-            assert.equal(readFileSync(p, 'utf8'), 'old');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('writeAtomic keeps ENOENT fallback when destination already has expected content', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            const p = join(cwd, 'atomic-fallback-safe.txt');
-            await writeFile(p, 'same-content', 'utf8');
-            setWriteAtomicRenameForTests(async () => {
-                const err = new Error('missing temp');
-                err.code = 'ENOENT';
-                throw err;
-            });
-            await writeAtomic(p, 'same-content');
-            assert.equal(readFileSync(p, 'utf8'), 'same-content');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('readWorkerStatus returns {state:\'unknown\'} on missing file', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-8', 't', 'executor', 1, cwd);
-            const status = await readWorkerStatus('team-8', 'worker-1', cwd);
-            assert.equal(status.state, 'unknown');
-            assert.ok(!Number.isNaN(Date.parse(status.updated_at)));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('readWorkerHeartbeat returns null on missing file', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-9', 't', 'executor', 1, cwd);
-            const hb = await readWorkerHeartbeat('team-9', 'worker-1', cwd);
-            assert.equal(hb, null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('writeWorkerInbox writes content to the correct path', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-10', 't', 'executor', 1, cwd);
-            await writeWorkerInbox('team-10', 'worker-1', 'hello worker', cwd);
-            const inboxPath = join(cwd, '.rcs', 'state', 'team', 'team-10', 'workers', 'worker-1', 'inbox.md');
-            assert.equal(existsSync(inboxPath), true);
-            assert.equal(readFileSync(inboxPath, 'utf8'), 'hello worker');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('getTeamSummary aggregates task counts correctly', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-11', 't', 'executor', 2, cwd);
-            const t1 = await createTask('team-11', { subject: 'p', description: 'd', status: 'pending' }, cwd);
-            await createTask('team-11', { subject: 'ip', description: 'd', status: 'in_progress' }, cwd);
-            await createTask('team-11', { subject: 'c', description: 'd', status: 'completed' }, cwd);
-            await createTask('team-11', { subject: 'f', description: 'd', status: 'failed' }, cwd);
-            // Simulate a worker who is turning without progress on task 1.
-            await updateWorkerHeartbeat('team-11', 'worker-1', { pid: 123, last_turn_at: new Date().toISOString(), turn_count: 6, alive: true }, cwd);
-            const statusPath = join(cwd, '.rcs', 'state', 'team', 'team-11', 'workers', 'worker-1', 'status.json');
-            await writeAtomic(statusPath, JSON.stringify({
-                state: 'working',
-                current_task_id: t1.id,
-                updated_at: new Date().toISOString(),
-            }, null, 2));
-            const first = await getTeamSummary('team-11', cwd);
-            assert.ok(first);
-            assert.equal(first?.teamName, 'team-11');
-            assert.equal(first?.workerCount, 2);
-            assert.deepEqual(first?.tasks, {
-                total: 4,
-                pending: 1,
-                blocked: 0,
-                in_progress: 1,
-                completed: 1,
-                failed: 1,
-            });
-            const firstW1 = first?.workers.find((w) => w.name === 'worker-1');
-            assert.equal(firstW1?.alive, true);
-            assert.equal(firstW1?.turnsWithoutProgress, 0);
-            // Subsequent turns without task status progress should show delta.
-            await updateWorkerHeartbeat('team-11', 'worker-1', { pid: 123, last_turn_at: new Date().toISOString(), turn_count: 12, alive: true }, cwd);
-            const second = await getTeamSummary('team-11', cwd);
-            assert.ok(second?.nonReportingWorkers.includes('worker-1'));
-            const secondW1 = second?.workers.find((w) => w.name === 'worker-1');
-            assert.equal(secondW1?.turnsWithoutProgress, 6);
-            assert.ok(second?.performance);
-            assert.equal(second?.performance?.task_count, 4);
-            assert.equal(second?.performance?.worker_count, 2);
-            assert.ok((second?.performance?.tasks_loaded_ms ?? -1) >= 0);
-            assert.ok((second?.performance?.workers_polled_ms ?? -1) >= 0);
-            assert.ok((second?.performance?.total_ms ?? -1) >= 0);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('cleanupTeamState removes the directory', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-12', 't', 'executor', 1, cwd);
-            const root = join(cwd, '.rcs', 'state', 'team', 'team-12');
-            assert.equal(existsSync(root), true);
-            await cleanupTeamState('team-12', cwd);
-            assert.equal(existsSync(root), false);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('cleanupTeamState rejects unsafe team names before path construction', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-unsafe-'));
-        try {
-            const victim = join(cwd, '.rcs', 'state', 'victim');
-            await mkdir(victim, { recursive: true });
-            await writeFile(join(victim, 'keep.txt'), 'keep');
-            await assert.rejects(() => cleanupTeamState('../victim', cwd), /invalid_team_name/);
-            assert.equal(existsSync(join(victim, 'keep.txt')), true);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('validateTeamName rejects invalid names (via initTeamState throwing)', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await assert.rejects(() => initTeamState('Bad Name', 't', 'executor', 1, cwd), /Invalid team name/);
-            await assert.rejects(() => initTeamState('-bad', 't', 'executor', 1, cwd), /Invalid team name/);
-            await assert.rejects(() => initTeamState('a'.repeat(31), 't', 'executor', 1, cwd), /Invalid team name/);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState snapshots permissions and display mode from env', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await initTeamState('team-env', 't', 'executor', 1, cwd, DEFAULT_MAX_WORKERS, {
-                ...process.env,
-                RCS_TEAM_DISPLAY_MODE: 'tmux',
-                RCS_TEAM_WORKER_LAUNCH_MODE: 'prompt',
-                CODEX_APPROVAL_MODE: 'on-request',
-                CODEX_SANDBOX_MODE: 'workspace-write',
-                CODEX_NETWORK_ACCESS: '0',
-                RCS_SESSION_ID: 'session-xyz',
-            });
-            const manifest = await readTeamManifestV2('team-env', cwd);
-            const config = await readTeamConfig('team-env', cwd);
-            assert.ok(manifest);
-            assert.ok(config);
-            assert.equal(manifest?.policy.display_mode, 'split_pane');
-            assert.equal(manifest?.policy.worker_launch_mode, 'prompt');
-            assert.equal(manifest?.governance.cleanup_requires_all_workers_inactive, true);
-            assert.equal(config?.worker_launch_mode, 'prompt');
-            assert.equal(manifest?.permissions_snapshot.approval_mode, 'on-request');
-            assert.equal(manifest?.permissions_snapshot.sandbox_mode, 'workspace-write');
-            assert.equal(manifest?.permissions_snapshot.network_access, false);
-            assert.equal(manifest?.leader.session_id, 'session-xyz');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('initTeamState rejects invalid RCS_TEAM_WORKER_LAUNCH_MODE values', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-state-'));
-        try {
-            await assert.rejects(() => initTeamState('team-env-invalid', 't', 'executor', 1, cwd, DEFAULT_MAX_WORKERS, {
-                ...process.env,
-                RCS_TEAM_WORKER_LAUNCH_MODE: 'tmux',
-            }), /Invalid RCS_TEAM_WORKER_LAUNCH_MODE value/i);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('claimTask returns task_not_found for non-existent task id', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-claim-missing-'));
-        try {
-            await initTeamState('team-x', 'task', 'executor', 1, cwd);
-            const result = await claimTask('team-x', 'non-existent-999', 'worker-1', null, cwd);
-            assert.equal(result.ok, false);
-            assert.equal(result.error, 'task_not_found');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('resolveDispatchLockTimeoutMs returns default when env not set', () => {
-        assert.equal(resolveDispatchLockTimeoutMs({}), 15_000);
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '' }), 15_000);
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: 'not-a-number' }), 15_000);
-    });
-    it('resolveDispatchLockTimeoutMs reads from env and clamps to bounds', () => {
-        // Reads value from env
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '30000' }), 30_000);
-        // Clamps to minimum
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '0' }), 1_000);
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '-500' }), 1_000);
-        // Clamps to maximum
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '999999' }), 120_000);
-        // Floors non-integer
-        assert.equal(resolveDispatchLockTimeoutMs({ RCS_DISPATCH_LOCK_TIMEOUT_MS: '5000.9' }), 5_000);
-    });
-    it('dispatch lock error message includes timeout hint', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-dispatch-lock-timeout-'));
-        try {
-            await initTeamState('team-lock-hint', 'task', 'executor', 1, cwd);
-            // Hold the lock by creating the lock directory manually
-            const lockDir = join(cwd, '.rcs', 'state', 'team', 'team-lock-hint', 'dispatch', '.lock');
-            await mkdir(lockDir, { recursive: true });
-            // Use a very short timeout via env override so the test is fast
-            const origEnv = process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS;
-            process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS = '1000';
-            try {
-                await assert.rejects(() => enqueueDispatchRequest('team-lock-hint', { kind: 'inbox', to_worker: 'worker-1', trigger_message: 'test' }, cwd), (err) => {
-                    assert.ok(err.message.includes('RCS_DISPATCH_LOCK_TIMEOUT_MS'), `Expected hint in error, got: ${err.message}`);
-                    return true;
-                });
-            }
-            finally {
-                if (origEnv === undefined) {
-                    delete process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS;
-                }
-                else {
-                    process.env.RCS_DISPATCH_LOCK_TIMEOUT_MS = origEnv;
-                }
-                await rm(lockDir, { recursive: true, force: true });
-            }
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('treats dispatch status as authoritative over incompatible timestamps', () => {
-        const pending = normalizeDispatchRequest('team-contract-dispatch', {
-            kind: 'inbox',
-            to_worker: 'worker-1',
-            trigger_message: 'ping',
-            status: 'pending',
-            notified_at: '2026-04-04T00:00:00.000Z',
-            delivered_at: '2026-04-04T00:01:00.000Z',
-            failed_at: '2026-04-04T00:02:00.000Z',
-        });
-        assert.equal(pending?.status, 'pending');
-        assert.equal(pending?.notified_at, undefined);
-        assert.equal(pending?.delivered_at, undefined);
-        assert.equal(pending?.failed_at, undefined);
-        const notified = normalizeDispatchRequest('team-contract-dispatch', {
-            kind: 'inbox',
-            to_worker: 'worker-1',
-            trigger_message: 'ping',
-            status: 'notified',
-            notified_at: '2026-04-04T00:00:00.000Z',
-            delivered_at: '2026-04-04T00:01:00.000Z',
-            failed_at: '2026-04-04T00:02:00.000Z',
-        });
-        assert.equal(notified?.status, 'notified');
-        assert.equal(notified?.notified_at, '2026-04-04T00:00:00.000Z');
-        assert.equal(notified?.delivered_at, undefined);
-        assert.equal(notified?.failed_at, undefined);
-        const delivered = normalizeDispatchRequest('team-contract-dispatch', {
-            kind: 'inbox',
-            to_worker: 'worker-1',
-            trigger_message: 'ping',
-            status: 'delivered',
-            notified_at: '2026-04-04T00:00:00.000Z',
-            delivered_at: '2026-04-04T00:01:00.000Z',
-            failed_at: '2026-04-04T00:02:00.000Z',
-        });
-        assert.equal(delivered?.status, 'delivered');
-        assert.equal(delivered?.notified_at, '2026-04-04T00:00:00.000Z');
-        assert.equal(delivered?.delivered_at, '2026-04-04T00:01:00.000Z');
-        assert.equal(delivered?.failed_at, undefined);
-        const failed = normalizeDispatchRequest('team-contract-dispatch', {
-            kind: 'inbox',
-            to_worker: 'worker-1',
-            trigger_message: 'ping',
-            status: 'failed',
-            notified_at: '2026-04-04T00:00:00.000Z',
-            delivered_at: '2026-04-04T00:01:00.000Z',
-            failed_at: '2026-04-04T00:02:00.000Z',
-        });
-        assert.equal(failed?.status, 'failed');
-        assert.equal(failed?.notified_at, '2026-04-04T00:00:00.000Z');
-        assert.equal(failed?.delivered_at, undefined);
-        assert.equal(failed?.failed_at, '2026-04-04T00:02:00.000Z');
-    });
-    it('sanitizes persisted integration snapshot statuses to the contract', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'rcs-team-monitor-contract-'));
-        try {
-            await initTeamState('team-monitor-contract', 't', 'executor', 1, cwd);
-            const monitorPath = join(cwd, '.rcs', 'state', 'team', 'team-monitor-contract', 'monitor-snapshot.json');
-            await writeFile(monitorPath, JSON.stringify({
-                taskStatusById: {},
-                workerAliveByName: {},
-                workerStateByName: {},
-                workerTurnCountByName: {},
-                workerTaskIdByName: {},
-                mailboxNotifiedByMessageId: {},
-                completedEventTaskIds: {},
-                integrationByWorker: {
-                    'worker-1': {
-                        status: 'integrated',
-                        last_integrated_head: 'abc123',
-                    },
-                    'worker-2': {
-                        status: 'mystery_state',
-                        last_integrated_head: 'def456',
-                    },
-                },
-            }, null, 2));
-            const snapshot = await readMonitorSnapshot('team-monitor-contract', cwd);
-            assert.equal(snapshot?.integrationByWorker?.['worker-1']?.status, 'integrated');
-            assert.equal(snapshot?.integrationByWorker?.['worker-1']?.last_integrated_head, 'abc123');
-            assert.equal(snapshot?.integrationByWorker?.['worker-2']?.status, undefined);
-            assert.equal(snapshot?.integrationByWorker?.['worker-2']?.last_integrated_head, 'def456');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-});
-//# sourceMappingURL=state.test.js.map