@liangjie559567/ultrapower 5.5.13 → 5.5.14

package/dist/team/__tests__/edge-cases.test.js

@@ -1,737 +0,0 @@
-/**
- * Edge Case Tests for MCP Team Workers
- *
- * Covers gaps not addressed by the existing 69 tests:
- * - Malformed input handling (bad JSON, unexpected types, missing fields)
- * - Boundary conditions (empty strings, long names, special characters)
- * - File system edge cases (missing files, corrupt data)
- * - Offset cursor behavior when inbox is truncated mid-line
- * - Outbox rotation boundary conditions
- * - Heartbeat with invalid/edge-case timestamps
- * - Task status transition edge cases
- * - Registration with corrupt backing files
- * - Sanitization edge cases (unicode, empty, path traversal)
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, mkdtempSync, writeFileSync, rmSync, existsSync, readFileSync, appendFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-let TEST_BASE_DIR;
-vi.mock('../../utils/paths.js', async () => {
-    const actual = await vi.importActual('../../utils/paths.js');
-    return { ...actual, getClaudeConfigDir: () => TEST_BASE_DIR };
-});
-// --- task-file-ops imports ---
-import { readTask, updateTask, findNextTask, areBlockersResolved, writeTaskFailure, readTaskFailure, listTaskIds } from '../task-file-ops.js';
-// --- inbox-outbox imports ---
-import { appendOutbox, rotateOutboxIfNeeded, readNewInboxMessages, readAllInboxMessages, clearInbox, writeShutdownSignal, checkShutdownSignal, deleteShutdownSignal, cleanupWorkerFiles } from '../inbox-outbox.js';
-// --- heartbeat imports ---
-import { writeHeartbeat, readHeartbeat, listHeartbeats, isWorkerAlive, deleteHeartbeat, cleanupTeamHeartbeats } from '../heartbeat.js';
-// --- tmux-session imports ---
-import { sanitizeName, sessionName } from '../tmux-session.js';
-// --- team-registration imports ---
-import { readProbeResult, writeProbeResult, registerMcpWorker, unregisterMcpWorker, isMcpWorker, listMcpWorkers } from '../team-registration.js';
-// ============================================================
-// Shared test constants and helpers
-// ============================================================
-const EDGE_TEAM_TASKS = 'test-edge-tasks';
-const EDGE_TEAM_IO = 'test-edge-io';
-const REG_TEAM = 'test-edge-reg-team';
-let TASKS_DIR;
-let TEAMS_IO_DIR;
-let HB_DIR;
-let REG_DIR;
-let CONFIG_DIR;
-beforeEach(() => {
-    TEST_BASE_DIR = mkdtempSync(join(tmpdir(), 'edge-cases-test-'));
-    TASKS_DIR = join(TEST_BASE_DIR, 'tasks', EDGE_TEAM_TASKS);
-    TEAMS_IO_DIR = join(TEST_BASE_DIR, 'teams', EDGE_TEAM_IO);
-    HB_DIR = join(TEST_BASE_DIR, 'hb');
-    REG_DIR = join(TEST_BASE_DIR, 'reg');
-    CONFIG_DIR = join(TEST_BASE_DIR, 'teams', REG_TEAM);
-});
-afterEach(() => {
-    rmSync(TEST_BASE_DIR, { recursive: true, force: true });
-});
-function writeTaskHelper(task) {
-    mkdirSync(TASKS_DIR, { recursive: true });
-    writeFileSync(join(TASKS_DIR, `${task.id}.json`), JSON.stringify(task, null, 2));
-}
-function makeHeartbeat(overrides) {
-    return {
-        workerName: 'w1',
-        teamName: 'test-team',
-        provider: 'codex',
-        pid: 12345,
-        lastPollAt: new Date().toISOString(),
-        consecutiveErrors: 0,
-        status: 'polling',
-        ...overrides,
-    };
-}
-// ============================================================
-// 1. task-file-ops edge cases
-// ============================================================
-describe('task-file-ops edge cases', () => {
-    beforeEach(() => {
-        mkdirSync(TASKS_DIR, { recursive: true });
-    });
-    describe('updateTask on non-existent file', () => {
-        it('throws when task file does not exist', () => {
-            // updateTask calls readFileSync directly without existsSync guard
-            expect(() => updateTask(EDGE_TEAM_TASKS, 'nonexistent', { status: 'completed' }))
-                .toThrow();
-        });
-    });
-    describe('updateTask with empty updates object', () => {
-        it('preserves task unchanged when updates is empty', () => {
-            const task = {
-                id: '1', subject: 'Test', description: 'Desc', status: 'pending',
-                owner: 'w1', blocks: [], blockedBy: [],
-            };
-            writeTaskHelper(task);
-            updateTask(EDGE_TEAM_TASKS, '1', {});
-            const result = readTask(EDGE_TEAM_TASKS, '1');
-            expect(result).toEqual(task);
-        });
-    });
-    describe('updateTask skips undefined values', () => {
-        it('does not overwrite fields with undefined', () => {
-            const task = {
-                id: '1', subject: 'Test', description: 'Desc', status: 'pending',
-                owner: 'w1', blocks: [], blockedBy: [],
-            };
-            writeTaskHelper(task);
-            // Passing an update with owner set to undefined should not wipe the owner
-            updateTask(EDGE_TEAM_TASKS, '1', { owner: undefined, status: 'in_progress' });
-            const result = readTask(EDGE_TEAM_TASKS, '1');
-            expect(result?.owner).toBe('w1');
-            expect(result?.status).toBe('in_progress');
-        });
-    });
-    describe('listTaskIds with mixed numeric and alpha IDs', () => {
-        it('sorts numeric IDs numerically and alpha IDs lexicographically', () => {
-            writeTaskHelper({ id: '10', subject: 'T', description: 'D', status: 'pending', owner: 'w', blocks: [], blockedBy: [] });
-            writeTaskHelper({ id: '2', subject: 'T', description: 'D', status: 'pending', owner: 'w', blocks: [], blockedBy: [] });
-            writeTaskHelper({ id: 'abc', subject: 'T', description: 'D', status: 'pending', owner: 'w', blocks: [], blockedBy: [] });
-            writeTaskHelper({ id: '1', subject: 'T', description: 'D', status: 'pending', owner: 'w', blocks: [], blockedBy: [] });
-            const ids = listTaskIds(EDGE_TEAM_TASKS);
-            // Numeric ones should be sorted numerically; alpha falls to localeCompare
-            // The sort function: if both parse as number, numeric sort; else localeCompare
-            // Since '1','2','10' are numeric and 'abc' is NaN, mixed comparison uses localeCompare
-            // Let's verify the actual order
-            expect(ids.length).toBe(4);
-            // '1' and '2' and '10' are numeric; 'abc' is NaN
-            // When one is NaN and other is number, localeCompare is used
-            // localeCompare('1','abc') < 0, localeCompare('10','abc') < 0, localeCompare('2','abc') < 0
-            // So all numeric come before 'abc'
-            expect(ids[ids.length - 1]).toBe('abc');
-        });
-    });
-    describe('listTaskIds with only non-.json files', () => {
-        it('returns empty when directory has no .json files', () => {
-            writeFileSync(join(TASKS_DIR, 'README.md'), 'not a task');
-            writeFileSync(join(TASKS_DIR, 'notes.txt'), 'not a task');
-            expect(listTaskIds(EDGE_TEAM_TASKS)).toEqual([]);
-        });
-    });
-    describe('areBlockersResolved with nonexistent blocker', () => {
-        it('returns false when blocker task file does not exist', () => {
-            // Blocker ID references a task that was never created
-            expect(areBlockersResolved(EDGE_TEAM_TASKS, ['does-not-exist'])).toBe(false);
-        });
-    });
-    describe('areBlockersResolved with in_progress blocker', () => {
-        it('returns false when blocker is in_progress (not completed)', () => {
-            writeTaskHelper({
-                id: 'blocker', subject: 'B', description: 'D',
-                status: 'in_progress', owner: 'w', blocks: [], blockedBy: [],
-            });
-            expect(areBlockersResolved(EDGE_TEAM_TASKS, ['blocker'])).toBe(false);
-        });
-    });
-    describe('findNextTask returns null for nonexistent team', () => {
-        it('returns null gracefully when team directory missing', async () => {
-            expect(await findNextTask('completely_nonexistent_team_xyz', 'w1')).toBeNull();
-        });
-    });
-    describe('findNextTask with in_progress task', () => {
-        it('skips tasks that are already in_progress', async () => {
-            writeTaskHelper({
-                id: '1', subject: 'T', description: 'D',
-                status: 'in_progress', owner: 'w1', blocks: [], blockedBy: [],
-            });
-            expect(await findNextTask(EDGE_TEAM_TASKS, 'w1')).toBeNull();
-        });
-    });
-    describe('readTask with empty file', () => {
-        it('returns null for empty JSON file', () => {
-            writeFileSync(join(TASKS_DIR, 'empty.json'), '');
-            expect(readTask(EDGE_TEAM_TASKS, 'empty')).toBeNull();
-        });
-    });
-    describe('readTask with valid JSON but non-object', () => {
-        it('returns the parsed value (no schema validation)', () => {
-            writeFileSync(join(TASKS_DIR, 'array.json'), '[]');
-            // readTask just does JSON.parse and casts, so an array would be returned
-            const result = readTask(EDGE_TEAM_TASKS, 'array');
-            expect(result).toEqual([]);
-        });
-    });
-    describe('writeTaskFailure with malformed existing sidecar', () => {
-        it('creates fresh sidecar when existing file is corrupt', () => {
-            // Write corrupt sidecar
-            mkdirSync(TASKS_DIR, { recursive: true });
-            writeFileSync(join(TASKS_DIR, 'corrupt.failure.json'), '{not valid json');
-            // readTaskFailure returns null for corrupt -> retryCount starts at 1
-            writeTaskFailure(EDGE_TEAM_TASKS, 'corrupt', 'new error');
-            const failure = readTaskFailure(EDGE_TEAM_TASKS, 'corrupt');
-            expect(failure?.retryCount).toBe(1);
-            expect(failure?.lastError).toBe('new error');
-        });
-    });
-    describe('readTaskFailure with corrupt sidecar file', () => {
-        it('returns null for corrupt failure sidecar', () => {
-            mkdirSync(TASKS_DIR, { recursive: true });
-            writeFileSync(join(TASKS_DIR, 'bad.failure.json'), 'not json at all');
-            expect(readTaskFailure(EDGE_TEAM_TASKS, 'bad')).toBeNull();
-        });
-    });
-    describe('task ID with special characters', () => {
-        it('handles task ID with dots', () => {
-            // ID 'v1.2.3' creates file 'v1.2.3.json'
-            const task = {
-                id: 'v1.2.3', subject: 'Versioned', description: 'D',
-                status: 'pending', owner: 'w1', blocks: [], blockedBy: [],
-            };
-            writeTaskHelper(task);
-            const result = readTask(EDGE_TEAM_TASKS, 'v1.2.3');
-            expect(result?.id).toBe('v1.2.3');
-        });
-    });
-    describe('listTaskIds excludes .tmp files with various PIDs', () => {
-        it('filters out temp files regardless of PID suffix', () => {
-            writeTaskHelper({ id: '1', subject: 'T', description: 'D', status: 'pending', owner: 'w', blocks: [], blockedBy: [] });
-            writeFileSync(join(TASKS_DIR, '1.json.tmp.99999'), '{}');
-            writeFileSync(join(TASKS_DIR, '2.json.tmp.1'), '{}');
-            const ids = listTaskIds(EDGE_TEAM_TASKS);
-            expect(ids).toEqual(['1']);
-        });
-    });
-    describe('task status transition: completed -> pending', () => {
-        it('allows backward transition (no validation in updateTask)', () => {
-            // This tests that updateTask does NOT enforce valid transitions.
-            // In production, completed -> pending could be a logic bug, but
-            // updateTask is a low-level primitive that does not validate.
-            writeTaskHelper({
-                id: '1', subject: 'T', description: 'D',
-                status: 'completed', owner: 'w1', blocks: [], blockedBy: [],
-            });
-            updateTask(EDGE_TEAM_TASKS, '1', { status: 'pending' });
-            const result = readTask(EDGE_TEAM_TASKS, '1');
-            expect(result?.status).toBe('pending');
-        });
-    });
-    describe('findNextTask with multiple pending tasks returns first by sorted ID', () => {
-        it('returns the lowest-sorted pending task', async () => {
-            writeTaskHelper({ id: '3', subject: 'T3', description: 'D', status: 'pending', owner: 'w1', blocks: [], blockedBy: [] });
-            writeTaskHelper({ id: '1', subject: 'T1', description: 'D', status: 'pending', owner: 'w1', blocks: [], blockedBy: [] });
-            writeTaskHelper({ id: '2', subject: 'T2', description: 'D', status: 'pending', owner: 'w1', blocks: [], blockedBy: [] });
-            const result = await findNextTask(EDGE_TEAM_TASKS, 'w1');
-            expect(result?.id).toBe('1');
-        });
-    });
-});
-// ============================================================
-// 2. inbox-outbox edge cases
-// ============================================================
-describe('inbox-outbox edge cases', () => {
-    beforeEach(() => {
-        mkdirSync(join(TEAMS_IO_DIR, 'inbox'), { recursive: true });
-        mkdirSync(join(TEAMS_IO_DIR, 'outbox'), { recursive: true });
-        mkdirSync(join(TEAMS_IO_DIR, 'signals'), { recursive: true });
-    });
-    describe('readNewInboxMessages with malformed JSONL mixed with valid', () => {
-        it('returns valid messages before first malformed line and stops', () => {
-            // Use a unique worker name to avoid any cursor conflicts
-            const workerName = 'w-malformed-test';
-            const inbox = join(TEAMS_IO_DIR, 'inbox', `${workerName}.jsonl`);
-            const cursorFile = join(TEAMS_IO_DIR, 'inbox', `${workerName}.offset`);
-            const validMsg1 = { type: 'message', content: 'first', timestamp: '2026-01-01T00:00:00Z' };
-            const validMsg2 = { type: 'message', content: 'second', timestamp: '2026-01-01T00:01:00Z' };
-            const unreachableMsg = { type: 'message', content: 'unreachable', timestamp: '2026-01-01T00:02:00Z' };
-            const content = [
-                JSON.stringify(validMsg1),
-                JSON.stringify(validMsg2),
-                'this is not json',
-                JSON.stringify(unreachableMsg),
-            ].join('\n') + '\n';
-            writeFileSync(inbox, content);
-            // Verify file was written correctly
-            const rawContent = readFileSync(inbox, 'utf-8');
-            expect(rawContent.length).toBeGreaterThan(0);
-            // Verify no stale cursor
-            expect(existsSync(cursorFile)).toBe(false);
-            const msgs = readNewInboxMessages(EDGE_TEAM_IO, workerName);
-            expect(msgs).toHaveLength(2);
-            expect(msgs[0].content).toBe('first');
-            expect(msgs[1].content).toBe('second');
-        });
-    });
-    describe('readNewInboxMessages with corrupt cursor file', () => {
-        it('resets cursor to 0 on malformed cursor JSON', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            const cursorFile = join(TEAMS_IO_DIR, 'inbox', 'w1.offset');
-            const msg = { type: 'message', content: 'hello', timestamp: '2026-01-01T00:00:00Z' };
-            writeFileSync(inbox, JSON.stringify(msg) + '\n');
-            writeFileSync(cursorFile, 'NOT VALID JSON AT ALL');
-            const msgs = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(msgs).toHaveLength(1);
-            expect(msgs[0].content).toBe('hello');
-        });
-    });
-    describe('readNewInboxMessages returns empty when cursor equals file size', () => {
-        it('returns empty array when no new data since last read', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            const msg = { type: 'message', content: 'data', timestamp: '2026-01-01T00:00:00Z' };
-            writeFileSync(inbox, JSON.stringify(msg) + '\n');
-            // First read consumes everything
-            const first = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(first).toHaveLength(1);
-            // Second read with no new data
-            const second = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(second).toEqual([]);
-        });
-    });
-    describe('readAllInboxMessages with malformed lines', () => {
-        it('skips invalid JSON lines and returns valid ones', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            const valid = { type: 'context', content: 'ctx', timestamp: '2026-01-01T00:00:00Z' };
-            writeFileSync(inbox, 'garbage\n' + JSON.stringify(valid) + '\n' + '{{{\n');
-            const msgs = readAllInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(msgs).toHaveLength(1);
-            expect(msgs[0].content).toBe('ctx');
-        });
-    });
-    describe('rotateOutboxIfNeeded at exact boundary', () => {
-        it('does not rotate when line count equals maxLines', () => {
-            const msg = { type: 'heartbeat', timestamp: '2026-01-01T00:00:00Z' };
-            for (let i = 0; i < 10; i++) {
-                appendOutbox(EDGE_TEAM_IO, 'w1', { ...msg, message: `msg-${i}` });
-            }
-            rotateOutboxIfNeeded(EDGE_TEAM_IO, 'w1', 10);
-            const lines = readFileSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'), 'utf-8')
-                .trim().split('\n').filter(l => l.trim());
-            // Should keep all 10 since 10 <= 10
-            expect(lines).toHaveLength(10);
-        });
-        it('rotates when line count is maxLines + 1', () => {
-            const msg = { type: 'heartbeat', timestamp: '2026-01-01T00:00:00Z' };
-            for (let i = 0; i < 11; i++) {
-                appendOutbox(EDGE_TEAM_IO, 'w1', { ...msg, message: `msg-${i}` });
-            }
-            rotateOutboxIfNeeded(EDGE_TEAM_IO, 'w1', 10);
-            const lines = readFileSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'), 'utf-8')
-                .trim().split('\n').filter(l => l.trim());
-            // Should keep floor(10/2) = 5 most recent
-            expect(lines).toHaveLength(5);
-            // Most recent should be msg-10
-            expect(JSON.parse(lines[lines.length - 1]).message).toBe('msg-10');
-        });
-    });
-    describe('rotateOutboxIfNeeded on nonexistent file', () => {
-        it('is a no-op and does not throw', () => {
-            expect(() => rotateOutboxIfNeeded(EDGE_TEAM_IO, 'ghost', 10)).not.toThrow();
-        });
-    });
-    describe('rotateOutboxIfNeeded with maxLines of 0', () => {
-        it('keeps ALL lines due to JS slice(-0) returning full array', () => {
-            // BUG/QUIRK: When maxLines=0, keepCount = floor(0/2) = 0,
-            // but lines.slice(-0) in JS returns the ENTIRE array (not empty).
-            // This means maxLines=0 does NOT empty the file -- it keeps everything.
-            // This is a known JavaScript edge case with Array.prototype.slice.
-            const msg = { type: 'idle', timestamp: '2026-01-01T00:00:00Z' };
-            appendOutbox(EDGE_TEAM_IO, 'w1', msg);
-            rotateOutboxIfNeeded(EDGE_TEAM_IO, 'w1', 0);
-            const lines = readFileSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'), 'utf-8')
-                .trim().split('\n').filter(l => l.trim());
-            // slice(-0) === slice(0) === full array, so 1 line is preserved
-            expect(lines).toHaveLength(1);
-        });
-    });
-    describe('clearInbox when files do not exist', () => {
-        it('does not throw when inbox and cursor are missing', () => {
-            expect(() => clearInbox(EDGE_TEAM_IO, 'nonexistent-worker')).not.toThrow();
-        });
-    });
-    describe('deleteShutdownSignal when file does not exist', () => {
-        it('does not throw', () => {
-            expect(() => deleteShutdownSignal(EDGE_TEAM_IO, 'ghost')).not.toThrow();
-        });
-    });
-    describe('checkShutdownSignal with corrupt signal file', () => {
-        it('returns null for malformed signal JSON', () => {
-            const sigFile = join(TEAMS_IO_DIR, 'signals', 'w1.shutdown');
-            writeFileSync(sigFile, 'this is not json');
-            expect(checkShutdownSignal(EDGE_TEAM_IO, 'w1')).toBeNull();
-        });
-    });
-    describe('cleanupWorkerFiles when some files already missing', () => {
-        it('cleans available files and ignores missing ones', () => {
-            // Only create outbox, skip inbox/cursor/signal
-            appendOutbox(EDGE_TEAM_IO, 'w1', { type: 'idle', timestamp: '2026-01-01T00:00:00Z' });
-            expect(existsSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'))).toBe(true);
-            // Cleanup should not throw even though inbox/signal don't exist
-            expect(() => cleanupWorkerFiles(EDGE_TEAM_IO, 'w1')).not.toThrow();
-            expect(existsSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'))).toBe(false);
-        });
-    });
-    describe('inbox messages with empty content', () => {
-        it('reads messages with empty string content', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            const msg = { type: 'message', content: '', timestamp: '2026-01-01T00:00:00Z' };
-            writeFileSync(inbox, JSON.stringify(msg) + '\n');
-            const msgs = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(msgs).toHaveLength(1);
-            expect(msgs[0].content).toBe('');
-        });
-    });
-    describe('readNewInboxMessages with multi-byte UTF-8 content', () => {
-        it('correctly handles unicode characters in messages', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            const msg = {
-                type: 'message',
-                content: 'Hello \u{1F600} \u{1F4BB} \u00E9\u00E8\u00EA \u4F60\u597D',
-                timestamp: '2026-01-01T00:00:00Z',
-            };
-            writeFileSync(inbox, JSON.stringify(msg) + '\n');
-            const msgs = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(msgs).toHaveLength(1);
-            expect(msgs[0].content).toContain('\u4F60\u597D');
-        });
-    });
-    describe('readNewInboxMessages with multi-byte then append', () => {
-        it('cursor byte offset works correctly across multi-byte boundaries', () => {
-            const inbox = join(TEAMS_IO_DIR, 'inbox', 'w1.jsonl');
-            // First message with multi-byte chars
-            const msg1 = {
-                type: 'message',
-                content: '\u{1F600}\u{1F600}\u{1F600}',
-                timestamp: '2026-01-01T00:00:00Z',
-            };
-            writeFileSync(inbox, JSON.stringify(msg1) + '\n');
-            const batch1 = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(batch1).toHaveLength(1);
-            // Append second message
-            const msg2 = { type: 'message', content: 'after-emoji', timestamp: '2026-01-01T00:01:00Z' };
-            appendFileSync(inbox, JSON.stringify(msg2) + '\n');
-            const batch2 = readNewInboxMessages(EDGE_TEAM_IO, 'w1');
-            expect(batch2).toHaveLength(1);
-            expect(batch2[0].content).toBe('after-emoji');
-        });
-    });
-    describe('writeShutdownSignal overwrites existing signal', () => {
-        it('replaces previous signal content', () => {
-            writeShutdownSignal(EDGE_TEAM_IO, 'w1', 'req-1', 'first reason');
-            writeShutdownSignal(EDGE_TEAM_IO, 'w1', 'req-2', 'second reason');
-            const sig = checkShutdownSignal(EDGE_TEAM_IO, 'w1');
-            expect(sig?.requestId).toBe('req-2');
-            expect(sig?.reason).toBe('second reason');
-        });
-    });
-    describe('appendOutbox creates directories automatically', () => {
-        it('creates outbox dir if it does not exist', () => {
-            // Remove the outbox directory
-            rmSync(join(TEAMS_IO_DIR, 'outbox'), { recursive: true, force: true });
-            expect(existsSync(join(TEAMS_IO_DIR, 'outbox'))).toBe(false);
-            const msg = { type: 'idle', timestamp: '2026-01-01T00:00:00Z' };
-            appendOutbox(EDGE_TEAM_IO, 'w1', msg);
-            expect(existsSync(join(TEAMS_IO_DIR, 'outbox', 'w1.jsonl'))).toBe(true);
-        });
-    });
-});
-// ============================================================
-// 3. heartbeat edge cases
-// ============================================================
-describe('heartbeat edge cases', () => {
-    beforeEach(() => {
-        mkdirSync(HB_DIR, { recursive: true });
-    });
-    describe('isWorkerAlive with maxAgeMs of 0', () => {
-        it('returns false because any age >= 0 fails the < 0 check', () => {
-            writeHeartbeat(HB_DIR, makeHeartbeat());
-            // Even a fresh heartbeat is at least 0ms old, and 0 < 0 is false
-            expect(isWorkerAlive(HB_DIR, 'test-team', 'w1', 0)).toBe(false);
-        });
-    });
-    describe('isWorkerAlive with very large maxAgeMs', () => {
-        it('returns true for stale heartbeat when maxAge exceeds the staleness', () => {
-            const stale = makeHeartbeat({ lastPollAt: '2000-01-01T00:00:00Z' });
-            writeHeartbeat(HB_DIR, stale);
-            // Year 2000 is ~26 years ago from 2026. Use 30 years in ms to be safe.
-            const thirtyYearsMs = 30 * 365.25 * 24 * 60 * 60 * 1000;
-            expect(isWorkerAlive(HB_DIR, 'test-team', 'w1', thirtyYearsMs)).toBe(true);
-        });
-    });
-    describe('isWorkerAlive with future timestamp', () => {
-        it('returns true since future - now is negative, which is < maxAgeMs', () => {
-            const future = makeHeartbeat({
-                lastPollAt: new Date(Date.now() + 3600000).toISOString(),
-            });
-            writeHeartbeat(HB_DIR, future);
-            expect(isWorkerAlive(HB_DIR, 'test-team', 'w1', 1000)).toBe(true);
-        });
-    });
-    describe('isWorkerAlive with empty string timestamp', () => {
-        it('returns false for empty lastPollAt', () => {
-            const bad = makeHeartbeat({ lastPollAt: '' });
-            writeHeartbeat(HB_DIR, bad);
-            // new Date('').getTime() is NaN
-            expect(isWorkerAlive(HB_DIR, 'test-team', 'w1', 60000)).toBe(false);
-        });
-    });
-    describe('isWorkerAlive with epoch zero timestamp', () => {
-        it('returns false for very old epoch timestamp with tight maxAge', () => {
-            const epoch = makeHeartbeat({ lastPollAt: '1970-01-01T00:00:00Z' });
-            writeHeartbeat(HB_DIR, epoch);
-            expect(isWorkerAlive(HB_DIR, 'test-team', 'w1', 60000)).toBe(false);
-        });
-    });
-    describe('readHeartbeat with corrupt JSON file', () => {
-        it('returns null for corrupt heartbeat file', () => {
-            const dir = join(HB_DIR, '.omc', 'state', 'team-bridge', 'test-team');
-            mkdirSync(dir, { recursive: true });
-            writeFileSync(join(dir, 'w1.heartbeat.json'), 'NOT JSON');
-            expect(readHeartbeat(HB_DIR, 'test-team', 'w1')).toBeNull();
-        });
-    });
-    describe('listHeartbeats with mixed valid and corrupt files', () => {
-        it('returns only successfully parsed heartbeats', () => {
-            writeHeartbeat(HB_DIR, makeHeartbeat({ workerName: 'good1' }));
-            writeHeartbeat(HB_DIR, makeHeartbeat({ workerName: 'good2' }));
-            // Write a corrupt heartbeat file
-            const dir = join(HB_DIR, '.omc', 'state', 'team-bridge', 'test-team');
-            writeFileSync(join(dir, 'corrupt.heartbeat.json'), '{bad json{{{');
-            const heartbeats = listHeartbeats(HB_DIR, 'test-team');
-            expect(heartbeats).toHaveLength(2);
-            const names = heartbeats.map(h => h.workerName).sort();
-            expect(names).toEqual(['good1', 'good2']);
-        });
-    });
-    describe('writeHeartbeat overwrites existing data', () => {
-        it('replaces previous heartbeat content', () => {
-            writeHeartbeat(HB_DIR, makeHeartbeat({ status: 'polling', consecutiveErrors: 0 }));
-            writeHeartbeat(HB_DIR, makeHeartbeat({ status: 'executing', consecutiveErrors: 2 }));
-            const hb = readHeartbeat(HB_DIR, 'test-team', 'w1');
-            expect(hb?.status).toBe('executing');
-            expect(hb?.consecutiveErrors).toBe(2);
-        });
-    });
-    describe('cleanupTeamHeartbeats with non-heartbeat files', () => {
-        it('removes all files in the team directory including non-heartbeat ones', () => {
-            writeHeartbeat(HB_DIR, makeHeartbeat({ workerName: 'w1' }));
-            const dir = join(HB_DIR, '.omc', 'state', 'team-bridge', 'test-team');
-            // Write an extra non-heartbeat file
-            writeFileSync(join(dir, 'other-file.txt'), 'not a heartbeat');
-            cleanupTeamHeartbeats(HB_DIR, 'test-team');
-            // Heartbeat should be gone
-            expect(readHeartbeat(HB_DIR, 'test-team', 'w1')).toBeNull();
-            // The non-heartbeat file is also deleted (cleanupTeamHeartbeats deletes all files)
-            expect(existsSync(join(dir, 'other-file.txt'))).toBe(false);
-        });
-    });
-    describe('deleteHeartbeat is idempotent', () => {
-        it('can be called twice without error', () => {
-            writeHeartbeat(HB_DIR, makeHeartbeat());
-            deleteHeartbeat(HB_DIR, 'test-team', 'w1');
-            expect(() => deleteHeartbeat(HB_DIR, 'test-team', 'w1')).not.toThrow();
-        });
-    });
-});
-// ============================================================
-// 4. tmux-session edge cases
-// ============================================================
-describe('tmux-session edge cases', () => {
-    describe('sanitizeName with empty string', () => {
-        it('throws for empty string', () => {
-            expect(() => sanitizeName('')).toThrow('no valid characters');
-        });
-    });
-    describe('sanitizeName with unicode characters', () => {
-        it('strips all unicode and keeps only ASCII alphanumeric/hyphen', () => {
-            expect(() => sanitizeName('\u4F60\u597D\u{1F600}')).toThrow('no valid characters');
-        });
-        it('keeps ASCII portion of mixed unicode/ASCII', () => {
-            expect(sanitizeName('\u4F60hello\u597D')).toBe('hello');
-        });
-    });
-    describe('sanitizeName with only hyphens', () => {
-        it('accepts hyphens-only name', () => {
-            expect(sanitizeName('---')).toBe('---');
-        });
-    });
-    describe('sanitizeName with whitespace', () => {
-        it('strips spaces and tabs', () => {
-            expect(sanitizeName('  hello  world  ')).toBe('helloworld');
-        });
-    });
-    describe('sanitizeName with path traversal characters', () => {
-        it('strips dots, slashes, and backslashes', () => {
-            expect(sanitizeName('../../../etc/passwd')).toBe('etcpasswd');
-        });
-    });
-    describe('sanitizeName with newlines and control characters', () => {
-        it('strips all control characters', () => {
-            expect(sanitizeName('hello\nworld\t!')).toBe('helloworld');
-        });
-    });
-    describe('sessionName total length', () => {
-        it('each part is truncated to 50 chars independently', () => {
-            const longName = 'a'.repeat(100);
-            const result = sessionName(longName, longName);
-            // 'omc-team-' + 50 chars + '-' + 50 chars = 110 total
-            expect(result.length).toBe(110);
-            expect(result).toBe(`omc-team-${'a'.repeat(50)}-${'a'.repeat(50)}`);
-        });
-    });
-    describe('sanitizeName preserves case', () => {
-        it('does not lowercase the name', () => {
-            expect(sanitizeName('MyWorker-ABC')).toBe('MyWorker-ABC');
-        });
-    });
-});
-// ============================================================
-// 5. team-registration edge cases
-// ============================================================
-describe('team-registration edge cases', () => {
-    beforeEach(() => {
-        mkdirSync(REG_DIR, { recursive: true });
-        mkdirSync(join(REG_DIR, '.omc', 'state'), { recursive: true });
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    });
-    describe('readProbeResult with corrupt JSON', () => {
-        it('returns null for malformed probe result file', () => {
-            const probePath = join(REG_DIR, '.omc', 'state', 'config-probe-result.json');
-            writeFileSync(probePath, 'NOT JSON');
-            expect(readProbeResult(REG_DIR)).toBeNull();
-        });
-    });
-    describe('listMcpWorkers with malformed shadow registry', () => {
-        it('returns empty when shadow registry is corrupt JSON', () => {
-            const shadowPath = join(REG_DIR, '.omc', 'state', 'team-mcp-workers.json');
-            writeFileSync(shadowPath, '{bad');
-            // Should not throw and return whatever was parsed from config (empty since config not set up for this team)
-            const workers = listMcpWorkers(REG_TEAM, REG_DIR);
-            expect(Array.isArray(workers)).toBe(true);
-        });
-    });
-    describe('listMcpWorkers with malformed config.json', () => {
-        it('ignores corrupt config.json and falls back to shadow', () => {
-            const configPath = join(CONFIG_DIR, 'config.json');
-            writeFileSync(configPath, '{bad json{{{');
-            // Register in shadow only
-            registerMcpWorker(REG_TEAM, 'w1', 'codex', 'gpt-5', 'sess1', '/cwd', REG_DIR);
-            const workers = listMcpWorkers(REG_TEAM, REG_DIR);
-            expect(workers).toHaveLength(1);
-            expect(workers[0].name).toBe('w1');
-        });
-    });
-    describe('registerMcpWorker builds correct agentId', () => {
-        it('agentId format is {workerName}@{teamName}', () => {
-            registerMcpWorker(REG_TEAM, 'myworker', 'gemini', 'gemini-pro', 'sess1', '/cwd', REG_DIR);
-            const workers = listMcpWorkers(REG_TEAM, REG_DIR);
-            expect(workers[0].agentId).toBe(`myworker@${REG_TEAM}`);
-        });
-    });
-    describe('registerInConfig with config.json missing members array', () => {
-        it('creates members array when config.json has no members field', () => {
-            // Write config.json without members
-            const configPath = join(CONFIG_DIR, 'config.json');
-            writeFileSync(configPath, JSON.stringify({ teamName: REG_TEAM }));
-            // Set probe to pass so registerInConfig is called
-            writeProbeResult(REG_DIR, { probeResult: 'pass', probedAt: '', version: '' });
-            registerMcpWorker(REG_TEAM, 'w1', 'codex', 'gpt-5', 'sess1', '/cwd', REG_DIR);
-            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-            expect(config.members).toHaveLength(1);
-            expect(config.members[0].name).toBe('w1');
-        });
-    });
-    describe('registerInConfig deduplicates by worker name', () => {
-        it('replaces existing entry with same name', () => {
-            const configPath = join(CONFIG_DIR, 'config.json');
-            writeFileSync(configPath, JSON.stringify({
-                teamName: REG_TEAM,
-                members: [{ name: 'w1', backendType: 'tmux', agentType: 'mcp-codex' }],
-            }));
-            writeProbeResult(REG_DIR, { probeResult: 'pass', probedAt: '', version: '' });
-            registerMcpWorker(REG_TEAM, 'w1', 'gemini', 'gemini-pro', 'sess2', '/cwd2', REG_DIR);
-            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-            expect(config.members).toHaveLength(1);
-            expect(config.members[0].agentType).toBe('mcp-gemini');
-        });
-    });
-    describe('unregisterMcpWorker with corrupt config.json', () => {
-        it('does not throw when config.json is malformed', () => {
-            const configPath = join(CONFIG_DIR, 'config.json');
-            writeFileSync(configPath, 'NOT JSON');
-            expect(() => unregisterMcpWorker(REG_TEAM, 'w1', REG_DIR)).not.toThrow();
-        });
-    });
-    describe('unregisterMcpWorker with corrupt shadow registry', () => {
-        it('does not throw when shadow registry is malformed', () => {
-            const shadowPath = join(REG_DIR, '.omc', 'state', 'team-mcp-workers.json');
-            writeFileSync(shadowPath, 'NOT JSON');
-            expect(() => unregisterMcpWorker(REG_TEAM, 'w1', REG_DIR)).not.toThrow();
-        });
-    });
-    describe('isMcpWorker with various inputs', () => {
-        it('returns false for null/undefined backendType', () => {
-            expect(isMcpWorker({ backendType: null })).toBe(false);
-            expect(isMcpWorker({ backendType: undefined })).toBe(false);
-        });
-        it('returns false for numeric backendType', () => {
-            expect(isMcpWorker({ backendType: 123 })).toBe(false);
-        });
-        it('returns true only for exact string tmux', () => {
-            expect(isMcpWorker({ backendType: 'TMUX' })).toBe(false);
-            expect(isMcpWorker({ backendType: 'tmux ' })).toBe(false);
-            expect(isMcpWorker({ backendType: 'tmux' })).toBe(true);
-        });
-    });
-    describe('listMcpWorkers with no files at all', () => {
-        it('returns empty array when neither config nor shadow exist', () => {
-            // Use a team name that has no config dir
-            const workers = listMcpWorkers('totally_nonexistent_team_abc', REG_DIR);
-            expect(workers).toEqual([]);
-        });
-    });
-    describe('shadow registry handles missing workers array gracefully', () => {
-        it('registers successfully when shadow registry has no workers field', () => {
-            // Shadow file exists but has no "workers" key — (registry.workers || []) guard handles it
-            const shadowPath = join(REG_DIR, '.omc', 'state', 'team-mcp-workers.json');
-            writeFileSync(shadowPath, JSON.stringify({ teamName: REG_TEAM }));
-            // Should not throw
-            expect(() => registerMcpWorker(REG_TEAM, 'w1', 'codex', 'gpt-5', 'sess1', '/cwd', REG_DIR)).not.toThrow();
-            // Verify the worker was registered
-            const workers = listMcpWorkers(REG_TEAM, REG_DIR);
-            expect(workers.length).toBeGreaterThanOrEqual(1);
-            expect(workers.some(w => w.name === 'w1')).toBe(true);
-        });
-    });
-    describe('config.json members with non-tmux workers', () => {
-        it('listMcpWorkers filters out non-tmux members from config', () => {
-            const configPath = join(CONFIG_DIR, 'config.json');
-            writeFileSync(configPath, JSON.stringify({
-                teamName: REG_TEAM,
-                members: [
-                    { name: 'claude-agent', backendType: 'subprocess', agentType: 'claude' },
-                    { name: 'mcp-w1', backendType: 'tmux', agentType: 'mcp-codex' },
-                ],
-            }));
-            const workers = listMcpWorkers(REG_TEAM, REG_DIR);
-            expect(workers).toHaveLength(1);
-            expect(workers[0].name).toBe('mcp-w1');
-        });
-    });
-});
-//# sourceMappingURL=edge-cases.test.js.map