claudecode-omc 4.9.4 → 5.0.0

package/dist/cli/commands/team.js

@@ -1,739 +0,0 @@
-/**
- * omc team CLI subcommand
- *
- * Full team lifecycle for `omc team`:
- *   omc team [N:agent-type] "task"          Start team (spawns tmux worker panes)
- *   omc team status <team-name>             Monitor team status
- *   omc team shutdown <team-name> [--force] Shutdown team
- *   omc team api <operation> --input '...'  Worker CLI API
- */
-import { TEAM_API_OPERATIONS, resolveTeamApiOperation, executeTeamApiOperation, } from '../../team/api-interop.js';
-const HELP_TOKENS = new Set(['--help', '-h', 'help']);
-const MIN_WORKER_COUNT = 1;
-const MAX_WORKER_COUNT = 20;
-const TEAM_HELP = `
-Usage: omc team [N:agent-type[:role]] [--new-window] "<task description>"
-       omc team status <team-name>
-       omc team shutdown <team-name> [--force]
-       omc team api <operation> [--input <json>] [--json]
-       omc team api --help
-
-Examples:
-  omc team 3:claude "fix failing tests"
-  omc team 2:codex:architect "design auth system"
-  omc team 1:gemini:executor "implement feature"
-  omc team 1:codex,1:gemini "compare approaches"
-  omc team 2:codex "review auth flow" --new-window
-  omc team status fix-failing-tests
-  omc team shutdown fix-failing-tests
-  omc team api send-message --input '{"team_name":"my-team","from_worker":"worker-1","to_worker":"leader-fixed","body":"ACK"}' --json
-
-Roles (optional): architect, executor, planner, analyst, critic, debugger, verifier,
-  code-reviewer, security-reviewer, test-engineer, debugger, designer, writer, scientist
-`;
-const TEAM_API_HELP = `
-Usage: omc team api <operation> [--input <json>] [--json]
-       omc team api <operation> --help
-
-Supported operations:
-  ${TEAM_API_OPERATIONS.join('\n  ')}
-
-Examples:
-  omc team api list-tasks --input '{"team_name":"my-team"}' --json
-  omc team api claim-task --input '{"team_name":"my-team","task_id":"1","worker":"worker-1","expected_version":1}' --json
-`;
-const TEAM_API_OPERATION_REQUIRED_FIELDS = {
-    'send-message': ['team_name', 'from_worker', 'to_worker', 'body'],
-    'broadcast': ['team_name', 'from_worker', 'body'],
-    'mailbox-list': ['team_name', 'worker'],
-    'mailbox-mark-delivered': ['team_name', 'worker', 'message_id'],
-    'mailbox-mark-notified': ['team_name', 'worker', 'message_id'],
-    'create-task': ['team_name', 'subject', 'description'],
-    'read-task': ['team_name', 'task_id'],
-    'list-tasks': ['team_name'],
-    'update-task': ['team_name', 'task_id'],
-    'claim-task': ['team_name', 'task_id', 'worker'],
-    'transition-task-status': ['team_name', 'task_id', 'from', 'to', 'claim_token'],
-    'release-task-claim': ['team_name', 'task_id', 'claim_token', 'worker'],
-    'read-config': ['team_name'],
-    'read-manifest': ['team_name'],
-    'read-worker-status': ['team_name', 'worker'],
-    'read-worker-heartbeat': ['team_name', 'worker'],
-    'update-worker-heartbeat': ['team_name', 'worker', 'pid', 'turn_count', 'alive'],
-    'write-worker-inbox': ['team_name', 'worker', 'content'],
-    'write-worker-identity': ['team_name', 'worker', 'index', 'role'],
-    'append-event': ['team_name', 'type', 'worker'],
-    'get-summary': ['team_name'],
-    'cleanup': ['team_name'],
-    'orphan-cleanup': ['team_name'],
-    'write-shutdown-request': ['team_name', 'worker', 'requested_by'],
-    'read-shutdown-ack': ['team_name', 'worker'],
-    'read-monitor-snapshot': ['team_name'],
-    'write-monitor-snapshot': ['team_name', 'snapshot'],
-    'read-task-approval': ['team_name', 'task_id'],
-    'write-task-approval': ['team_name', 'task_id', 'status', 'reviewer', 'decision_reason'],
-};
-const TEAM_API_OPERATION_OPTIONAL_FIELDS = {
-    'create-task': ['owner', 'blocked_by', 'requires_code_change'],
-    'update-task': ['subject', 'description', 'blocked_by', 'requires_code_change'],
-    'claim-task': ['expected_version'],
-    'read-shutdown-ack': ['min_updated_at'],
-    'write-worker-identity': [
-        'assigned_tasks', 'pid', 'pane_id', 'working_dir',
-        'worktree_path', 'worktree_branch', 'worktree_detached', 'team_state_root',
-    ],
-    'append-event': ['task_id', 'message_id', 'reason'],
-    'write-task-approval': ['required'],
-};
-const TEAM_API_OPERATION_NOTES = {
-    'update-task': 'Only non-lifecycle task metadata can be updated.',
-    'release-task-claim': 'Use this only for rollback/requeue to pending (not for completion).',
-    'transition-task-status': 'Lifecycle flow is claim-safe and typically transitions in_progress -> completed|failed.',
-};
-const NUMBERED_LINE_RE = /^\s*\d+[.)]\s+(.+)$/;
-const BULLETED_LINE_RE = /^\s*[-*•]\s+(.+)$/;
-// Conjunction split: "fix auth AND fix login AND fix logout" or "fix auth, fix login, and fix logout"
-const CONJUNCTION_SPLIT_RE = /\s+(?:and|,\s*and|,)\s+/i;
-/** Signals that a task is atomic (contains file refs, code symbols, or parallel keywords) */
-const PARALLELIZATION_KEYWORDS_RE = /\b(?:parallel|concurrently|simultaneously|at the same time|independently)\b/i;
-const FILE_REF_RE = /\b\S+\.\w{1,6}\b/g;
-const CODE_SYMBOL_RE = /`[^`]+`/g;
-/**
- * Count atomic parallelization signals in a task string.
- * Returns true when the task should NOT be decomposed (it's already atomic or tightly coupled).
- */
-export function hasAtomicParallelizationSignals(task, _size) {
-    const fileRefs = (task.match(FILE_REF_RE) || []).length;
-    const codeSymbols = (task.match(CODE_SYMBOL_RE) || []).length;
-    const parallelKw = PARALLELIZATION_KEYWORDS_RE.test(task);
-    // Treat as atomic when many specific file/symbol refs present (tightly coupled)
-    return fileRefs >= 3 || codeSymbols >= 3 || parallelKw;
-}
-/**
- * Resolve the effective worker count fanout limit for decomposed tasks.
- * Caps worker count to the number of discovered subtasks when decomposition produces fewer items.
- */
-export function resolveTeamFanoutLimit(requestedWorkerCount, _explicitAgentType, _explicitWorkerCount, plan) {
-    if (plan.strategy === 'atomic')
-        return requestedWorkerCount;
-    const subtaskCount = plan.subtasks.length;
-    if (subtaskCount > 0 && subtaskCount < requestedWorkerCount) {
-        return subtaskCount;
-    }
-    return requestedWorkerCount;
-}
-/**
- * Decompose a task string into a structured plan.
- *
- * Detects:
- * - Numbered list: "1. fix auth\n2. fix login"
- * - Bulleted list: "- fix auth\n- fix login"
- * - Conjunction: "fix auth and fix login and fix logout"
- * - Atomic: single task, no decomposition
- */
-export function splitTaskString(task) {
-    const lines = task.split('\n').map(l => l.trim()).filter(Boolean);
-    // Check numbered list
-    if (lines.length >= 2 && lines.every(l => NUMBERED_LINE_RE.test(l))) {
-        return {
-            strategy: 'numbered',
-            subtasks: lines.map(l => {
-                const m = l.match(NUMBERED_LINE_RE);
-                const subject = m[1].trim();
-                return { subject: subject.slice(0, 80), description: subject };
-            }),
-        };
-    }
-    // Check bulleted list
-    if (lines.length >= 2 && lines.every(l => BULLETED_LINE_RE.test(l))) {
-        return {
-            strategy: 'bulleted',
-            subtasks: lines.map(l => {
-                const m = l.match(BULLETED_LINE_RE);
-                const subject = m[1].trim();
-                return { subject: subject.slice(0, 80), description: subject };
-            }),
-        };
-    }
-    // Check conjunction split (single line with "and" or commas)
-    if (lines.length === 1) {
-        const parts = lines[0].split(CONJUNCTION_SPLIT_RE).map(s => s.trim()).filter(Boolean);
-        if (parts.length >= 2) {
-            return {
-                strategy: 'conjunction',
-                subtasks: parts.map(p => ({ subject: p.slice(0, 80), description: p })),
-            };
-        }
-    }
-    // Atomic: no decomposition
-    return {
-        strategy: 'atomic',
-        subtasks: [{ subject: task.slice(0, 80), description: task }],
-    };
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function slugifyTask(task) {
-    return task
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 30) || 'team-task';
-}
-function getTeamWorkerIdentityFromEnv(env = process.env) {
-    const omc = typeof env.OMC_TEAM_WORKER === 'string' ? env.OMC_TEAM_WORKER.trim() : '';
-    if (omc)
-        return omc;
-    const omx = typeof env.OMX_TEAM_WORKER === 'string' ? env.OMX_TEAM_WORKER.trim() : '';
-    return omx || null;
-}
-export async function assertTeamSpawnAllowed(cwd, env = process.env) {
-    const workerIdentity = getTeamWorkerIdentityFromEnv(env);
-    const { teamReadManifest } = await import('../../team/team-ops.js');
-    const { findActiveTeamsV2 } = await import('../../team/runtime-v2.js');
-    const { DEFAULT_TEAM_GOVERNANCE, normalizeTeamGovernance } = await import('../../team/governance.js');
-    if (workerIdentity) {
-        const [parentTeamName] = workerIdentity.split('/');
-        const parentManifest = parentTeamName ? await teamReadManifest(parentTeamName, cwd) : null;
-        const governance = normalizeTeamGovernance(parentManifest?.governance, parentManifest?.policy);
-        if (!governance.nested_teams_allowed) {
-            throw new Error(`Worker context (${workerIdentity}) cannot start nested teams because nested_teams_allowed is false.`);
-        }
-        if (!governance.delegation_only) {
-            throw new Error(`Worker context (${workerIdentity}) cannot start nested teams because delegation_only is false.`);
-        }
-        return;
-    }
-    const activeTeams = await findActiveTeamsV2(cwd);
-    for (const activeTeam of activeTeams) {
-        const manifest = await teamReadManifest(activeTeam, cwd);
-        const governance = normalizeTeamGovernance(manifest?.governance, manifest?.policy);
-        if (governance.one_team_per_leader_session ?? DEFAULT_TEAM_GOVERNANCE.one_team_per_leader_session) {
-            throw new Error(`Leader session already owns active team "${activeTeam}" and one_team_per_leader_session is enabled.`);
-        }
-    }
-}
-/** Regex for a single worker spec segment: N[:type[:role]] */
-const SINGLE_SPEC_RE = /^(\d+)(?::([a-z][a-z0-9-]*)(?::([a-z][a-z0-9-]*))?)?$/i;
-/** @internal Exported for testing */
-export function parseTeamArgs(tokens) {
-    const args = [...tokens];
-    let workerCount = 3;
-    let agentTypes = [];
-    let workerSpecs = [];
-    let json = false;
-    let newWindow = false;
-    // Extract supported flags before parsing positional args
-    const filteredArgs = [];
-    for (const arg of args) {
-        if (arg === '--json') {
-            json = true;
-        }
-        else if (arg === '--new-window') {
-            newWindow = true;
-        }
-        else {
-            filteredArgs.push(arg);
-        }
-    }
-    const first = filteredArgs[0] || '';
-    // Try comma-separated multi-type spec first (e.g. "1:codex,1:gemini" or "2:claude,1:codex:architect")
-    let role;
-    let specMatched = false;
-    if (first.includes(',')) {
-        const segments = first.split(',');
-        const parsedSegments = [];
-        let allValid = true;
-        for (const seg of segments) {
-            const m = seg.match(SINGLE_SPEC_RE);
-            if (!m) {
-                allValid = false;
-                break;
-            }
-            const count = Number.parseInt(m[1], 10);
-            if (!Number.isFinite(count) || count < MIN_WORKER_COUNT || count > MAX_WORKER_COUNT) {
-                throw new Error(`Invalid worker count "${m[1]}". Expected ${MIN_WORKER_COUNT}-${MAX_WORKER_COUNT}.`);
-            }
-            parsedSegments.push({ count, type: m[2] || 'claude', role: m[3] });
-        }
-        if (allValid && parsedSegments.length > 0) {
-            workerCount = 0;
-            for (const seg of parsedSegments) {
-                workerCount += seg.count;
-                for (let i = 0; i < seg.count; i++) {
-                    agentTypes.push(seg.type);
-                    workerSpecs.push({ agentType: seg.type, ...(seg.role ? { role: seg.role } : {}) });
-                }
-            }
-            if (workerCount > MAX_WORKER_COUNT) {
-                throw new Error(`Total worker count ${workerCount} exceeds maximum ${MAX_WORKER_COUNT}.`);
-            }
-            // If every segment specifies the same role, use it; otherwise leave undefined
-            const roles = parsedSegments.map(s => s.role);
-            const uniqueRoles = [...new Set(roles)];
-            if (uniqueRoles.length === 1 && uniqueRoles[0])
-                role = uniqueRoles[0];
-            specMatched = true;
-            filteredArgs.shift();
-        }
-    }
-    // Fall back to single spec (e.g. "3:codex" or "2:codex:architect")
-    if (!specMatched) {
-        const match = first.match(SINGLE_SPEC_RE);
-        if (match) {
-            const count = Number.parseInt(match[1], 10);
-            if (!Number.isFinite(count) || count < MIN_WORKER_COUNT || count > MAX_WORKER_COUNT) {
-                throw new Error(`Invalid worker count "${match[1]}". Expected ${MIN_WORKER_COUNT}-${MAX_WORKER_COUNT}.`);
-            }
-            workerCount = count;
-            const type = match[2] || 'claude';
-            if (match[3])
-                role = match[3];
-            agentTypes = Array.from({ length: workerCount }, () => type);
-            workerSpecs = Array.from({ length: workerCount }, () => ({ agentType: type, ...(role ? { role } : {}) }));
-            filteredArgs.shift();
-        }
-    }
-    // Default: 3 claude workers if no spec matched
-    if (agentTypes.length === 0) {
-        agentTypes = Array.from({ length: workerCount }, () => 'claude');
-        workerSpecs = Array.from({ length: workerCount }, () => ({ agentType: 'claude' }));
-    }
-    const task = filteredArgs.join(' ').trim();
-    if (!task) {
-        throw new Error('Usage: omc team [N:agent-type] "<task description>"');
-    }
-    const teamName = slugifyTask(task);
-    return { workerCount, agentTypes, workerSpecs, role, task, teamName, json, newWindow };
-}
-export function buildStartupTasks(parsed) {
-    return Array.from({ length: parsed.workerCount }, (_, index) => {
-        const workerSpec = parsed.workerSpecs[index];
-        const roleLabel = workerSpec?.role ? ` (${workerSpec.role})` : '';
-        return {
-            subject: parsed.workerCount === 1
-                ? parsed.task.slice(0, 80)
-                : `Worker ${index + 1}${roleLabel}: ${parsed.task}`.slice(0, 80),
-            description: parsed.task,
-            ...(workerSpec?.role ? { owner: `worker-${index + 1}` } : {}),
-        };
-    });
-}
-function sampleValueForField(field) {
-    switch (field) {
-        case 'team_name': return 'my-team';
-        case 'from_worker': return 'worker-1';
-        case 'to_worker': return 'leader-fixed';
-        case 'worker': return 'worker-1';
-        case 'body': return 'ACK';
-        case 'subject': return 'Demo task';
-        case 'description': return 'Created through CLI interop';
-        case 'task_id': return '1';
-        case 'message_id': return 'msg-123';
-        case 'from': return 'in_progress';
-        case 'to': return 'completed';
-        case 'claim_token': return 'claim-token';
-        case 'expected_version': return 1;
-        case 'pid': return 12345;
-        case 'turn_count': return 12;
-        case 'alive': return true;
-        case 'content': return '# Inbox update\nProceed with task 2.';
-        case 'index': return 1;
-        case 'role': return 'executor';
-        case 'assigned_tasks': return ['1', '2'];
-        case 'type': return 'task_completed';
-        case 'requested_by': return 'leader-fixed';
-        case 'min_updated_at': return '2026-03-04T00:00:00.000Z';
-        case 'snapshot':
-            return {
-                taskStatusById: { '1': 'completed' },
-                workerAliveByName: { 'worker-1': true },
-                workerStateByName: { 'worker-1': 'idle' },
-                workerTurnCountByName: { 'worker-1': 12 },
-                workerTaskIdByName: { 'worker-1': '1' },
-                mailboxNotifiedByMessageId: {},
-                completedEventTaskIds: { '1': true },
-            };
-        case 'status': return 'approved';
-        case 'reviewer': return 'leader-fixed';
-        case 'decision_reason': return 'approved in demo';
-        case 'required': return true;
-        default: return `<${field}>`;
-    }
-}
-function buildOperationHelp(operation) {
-    const requiredFields = TEAM_API_OPERATION_REQUIRED_FIELDS[operation] ?? [];
-    const optionalFields = TEAM_API_OPERATION_OPTIONAL_FIELDS[operation] ?? [];
-    const sampleInput = {};
-    for (const field of requiredFields) {
-        sampleInput[field] = sampleValueForField(field);
-    }
-    const sampleInputJson = JSON.stringify(sampleInput);
-    const required = requiredFields.length > 0
-        ? requiredFields.map((field) => `  - ${field}`).join('\n')
-        : '  (none)';
-    const optional = optionalFields.length > 0
-        ? `\nOptional input fields:\n${optionalFields.map((field) => `  - ${field}`).join('\n')}\n`
-        : '\n';
-    const note = TEAM_API_OPERATION_NOTES[operation]
-        ? `\nNote:\n  ${TEAM_API_OPERATION_NOTES[operation]}\n`
-        : '';
-    return `
-Usage: omc team api ${operation} --input <json> [--json]
-
-Required input fields:
-${required}${optional}${note}Example:
-  omc team api ${operation} --input '${sampleInputJson}' --json
-`.trim();
-}
-function parseTeamApiArgs(args) {
-    const operation = resolveTeamApiOperation(args[0] || '');
-    if (!operation) {
-        throw new Error(`Usage: omc team api <operation> [--input <json>] [--json]\nSupported operations: ${TEAM_API_OPERATIONS.join(', ')}`);
-    }
-    let input = {};
-    let json = false;
-    for (let i = 1; i < args.length; i += 1) {
-        const token = args[i];
-        if (token === '--json') {
-            json = true;
-            continue;
-        }
-        if (token === '--input') {
-            const next = args[i + 1];
-            if (!next)
-                throw new Error('Missing value after --input');
-            try {
-                const parsed = JSON.parse(next);
-                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                    throw new Error('input must be a JSON object');
-                }
-                input = parsed;
-            }
-            catch (error) {
-                throw new Error(`Invalid --input JSON: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            i += 1;
-            continue;
-        }
-        if (token.startsWith('--input=')) {
-            const raw = token.slice('--input='.length);
-            try {
-                const parsed = JSON.parse(raw);
-                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                    throw new Error('input must be a JSON object');
-                }
-                input = parsed;
-            }
-            catch (error) {
-                throw new Error(`Invalid --input JSON: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            continue;
-        }
-        throw new Error(`Unknown argument for "omc team api": ${token}`);
-    }
-    return { operation, input, json };
-}
-// ---------------------------------------------------------------------------
-// Team start (spawns tmux workers)
-// ---------------------------------------------------------------------------
-async function handleTeamStart(parsed, cwd) {
-    await assertTeamSpawnAllowed(cwd);
-    // Decompose the task string into subtasks when possible
-    const decomposition = splitTaskString(parsed.task);
-    const effectiveWorkerCount = resolveTeamFanoutLimit(parsed.workerCount, parsed.agentTypes[0], parsed.workerCount, decomposition);
-    // Build the task list from decomposition subtasks or fall back to atomic replication
-    const tasks = [];
-    if (decomposition.strategy !== 'atomic' && decomposition.subtasks.length > 1) {
-        // Use decomposed subtasks — one per subtask (up to effectiveWorkerCount)
-        const subtasks = decomposition.subtasks.slice(0, effectiveWorkerCount);
-        for (let i = 0; i < subtasks.length; i++) {
-            tasks.push({
-                subject: subtasks[i].subject,
-                description: subtasks[i].description,
-                owner: `worker-${i + 1}`,
-            });
-        }
-    }
-    else {
-        // Atomic task: replicate across all workers (backward compatible)
-        for (let i = 0; i < effectiveWorkerCount; i++) {
-            tasks.push({
-                subject: effectiveWorkerCount === 1
-                    ? parsed.task.slice(0, 80)
-                    : `Worker ${i + 1}: ${parsed.task}`.slice(0, 80),
-                description: parsed.task,
-                owner: `worker-${i + 1}`,
-            });
-        }
-    }
-    // Load role prompt if a role was specified (e.g., 3:codex:architect)
-    let rolePrompt;
-    if (parsed.role) {
-        const { loadAgentPrompt } = await import('../../agents/utils.js');
-        rolePrompt = loadAgentPrompt(parsed.role);
-    }
-    // Use v2 runtime by default (OMC_RUNTIME_V2 opt-out), otherwise fall back to v1
-    const { isRuntimeV2Enabled } = await import('../../team/runtime-v2.js');
-    if (isRuntimeV2Enabled()) {
-        const { startTeamV2, monitorTeamV2 } = await import('../../team/runtime-v2.js');
-        const runtime = await startTeamV2({
-            teamName: parsed.teamName,
-            workerCount: effectiveWorkerCount,
-            agentTypes: parsed.agentTypes.slice(0, effectiveWorkerCount),
-            tasks,
-            cwd,
-            newWindow: parsed.newWindow,
-            workerRoles: parsed.workerSpecs.map((spec) => spec.role ?? spec.agentType),
-            ...(rolePrompt ? { roleName: parsed.role, rolePrompt } : {}),
-        });
-        const uniqueTypes = [...new Set(parsed.agentTypes)].join(',');
-        if (parsed.json) {
-            const snapshot = await monitorTeamV2(runtime.teamName, cwd);
-            console.log(JSON.stringify({
-                teamName: runtime.teamName,
-                sessionName: runtime.sessionName,
-                workerCount: runtime.config.worker_count,
-                agentType: uniqueTypes,
-                tasks: snapshot ? snapshot.tasks : null,
-            }));
-            return;
-        }
-        console.log(`Team started: ${runtime.teamName}`);
-        console.log(`tmux session: ${runtime.sessionName}`);
-        console.log(`workers: ${runtime.config.worker_count}`);
-        console.log(`agent_type: ${uniqueTypes}`);
-        const snapshot = await monitorTeamV2(runtime.teamName, cwd);
-        if (snapshot) {
-            console.log(`tasks: total=${snapshot.tasks.total} pending=${snapshot.tasks.pending} in_progress=${snapshot.tasks.in_progress} completed=${snapshot.tasks.completed} failed=${snapshot.tasks.failed}`);
-        }
-        return;
-    }
-    // v1 fallback
-    const { startTeam, monitorTeam } = await import('../../team/runtime.js');
-    const runtime = await startTeam({
-        teamName: parsed.teamName,
-        workerCount: effectiveWorkerCount,
-        agentTypes: parsed.agentTypes.slice(0, effectiveWorkerCount),
-        tasks,
-        cwd,
-        newWindow: parsed.newWindow,
-    });
-    const uniqueTypesV1 = [...new Set(parsed.agentTypes)].join(',');
-    if (parsed.json) {
-        const snapshot = await monitorTeam(runtime.teamName, cwd, runtime.workerPaneIds);
-        console.log(JSON.stringify({
-            teamName: runtime.teamName,
-            sessionName: runtime.sessionName,
-            workerCount: runtime.workerNames.length,
-            agentType: uniqueTypesV1,
-            tasks: snapshot ? {
-                total: snapshot.taskCounts.pending + snapshot.taskCounts.inProgress + snapshot.taskCounts.completed + snapshot.taskCounts.failed,
-                pending: snapshot.taskCounts.pending,
-                in_progress: snapshot.taskCounts.inProgress,
-                completed: snapshot.taskCounts.completed,
-                failed: snapshot.taskCounts.failed,
-            } : null,
-        }));
-        return;
-    }
-    console.log(`Team started: ${runtime.teamName}`);
-    console.log(`tmux session: ${runtime.sessionName}`);
-    console.log(`workers: ${runtime.workerNames.length}`);
-    console.log(`agent_type: ${uniqueTypesV1}`);
-    const snapshot = await monitorTeam(runtime.teamName, cwd, runtime.workerPaneIds);
-    if (snapshot) {
-        console.log(`tasks: total=${snapshot.taskCounts.pending + snapshot.taskCounts.inProgress + snapshot.taskCounts.completed + snapshot.taskCounts.failed} pending=${snapshot.taskCounts.pending} in_progress=${snapshot.taskCounts.inProgress} completed=${snapshot.taskCounts.completed} failed=${snapshot.taskCounts.failed}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// Team status
-// ---------------------------------------------------------------------------
-async function handleTeamStatus(teamName, cwd) {
-    const { isRuntimeV2Enabled } = await import('../../team/runtime-v2.js');
-    if (isRuntimeV2Enabled()) {
-        const { monitorTeamV2 } = await import('../../team/runtime-v2.js');
-        const { deriveTeamLeaderGuidance } = await import('../../team/leader-nudge-guidance.js');
-        const { readTeamEventsByType } = await import('../../team/events.js');
-        const snapshot = await monitorTeamV2(teamName, cwd);
-        if (!snapshot) {
-            console.log(`No team state found for ${teamName}`);
-            return;
-        }
-        const leaderGuidance = deriveTeamLeaderGuidance({
-            tasks: {
-                pending: snapshot.tasks.pending,
-                blocked: snapshot.tasks.blocked,
-                inProgress: snapshot.tasks.in_progress,
-                completed: snapshot.tasks.completed,
-                failed: snapshot.tasks.failed,
-            },
-            workers: {
-                total: snapshot.workers.length,
-                alive: snapshot.workers.filter((worker) => worker.alive).length,
-                idle: snapshot.workers.filter((worker) => worker.alive && (worker.status.state === 'idle' || worker.status.state === 'done')).length,
-                nonReporting: snapshot.nonReportingWorkers.length,
-            },
-        });
-        const latestLeaderNudge = (await readTeamEventsByType(teamName, 'team_leader_nudge', cwd)).at(-1);
-        console.log(`team=${snapshot.teamName} phase=${snapshot.phase}`);
-        console.log(`workers: total=${snapshot.workers.length}`);
-        console.log(`tasks: total=${snapshot.tasks.total} pending=${snapshot.tasks.pending} blocked=${snapshot.tasks.blocked} in_progress=${snapshot.tasks.in_progress} completed=${snapshot.tasks.completed} failed=${snapshot.tasks.failed}`);
-        console.log(`leader_next_action=${leaderGuidance.nextAction}`);
-        console.log(`leader_guidance=${leaderGuidance.message}`);
-        if (latestLeaderNudge) {
-            console.log(`latest_leader_nudge action=${latestLeaderNudge.next_action ?? 'unknown'} at=${latestLeaderNudge.created_at} reason=${latestLeaderNudge.reason ?? 'n/a'}`);
-        }
-        return;
-    }
-    // v1 fallback
-    const { monitorTeam } = await import('../../team/runtime.js');
-    const snapshot = await monitorTeam(teamName, cwd, []);
-    if (!snapshot) {
-        console.log(`No team state found for ${teamName}`);
-        return;
-    }
-    console.log(`team=${snapshot.teamName} phase=${snapshot.phase}`);
-    console.log(`tasks: pending=${snapshot.taskCounts.pending} in_progress=${snapshot.taskCounts.inProgress} completed=${snapshot.taskCounts.completed} failed=${snapshot.taskCounts.failed}`);
-}
-// ---------------------------------------------------------------------------
-// Team shutdown
-// ---------------------------------------------------------------------------
-async function handleTeamShutdown(teamName, cwd, force) {
-    const { isRuntimeV2Enabled } = await import('../../team/runtime-v2.js');
-    if (isRuntimeV2Enabled()) {
-        const { shutdownTeamV2 } = await import('../../team/runtime-v2.js');
-        await shutdownTeamV2(teamName, cwd, { force });
-        console.log(`Team shutdown complete: ${teamName}`);
-        return;
-    }
-    // v1 fallback
-    const { shutdownTeam } = await import('../../team/runtime.js');
-    await shutdownTeam(teamName, `omc-team-${teamName}`, cwd);
-    console.log(`Team shutdown complete: ${teamName}`);
-}
-// ---------------------------------------------------------------------------
-// API subcommand handler
-// ---------------------------------------------------------------------------
-async function handleTeamApi(args, cwd) {
-    const apiSubcommand = (args[0] || '').toLowerCase();
-    // omc team api --help
-    if (HELP_TOKENS.has(apiSubcommand)) {
-        const operationFromHelpAlias = resolveTeamApiOperation((args[1] || '').toLowerCase());
-        if (operationFromHelpAlias) {
-            console.log(buildOperationHelp(operationFromHelpAlias));
-            return;
-        }
-        console.log(TEAM_API_HELP.trim());
-        return;
-    }
-    // omc team api <operation> --help
-    const operation = resolveTeamApiOperation(apiSubcommand);
-    if (operation) {
-        const trailing = args.slice(1).map((token) => token.toLowerCase());
-        if (trailing.some((token) => HELP_TOKENS.has(token))) {
-            console.log(buildOperationHelp(operation));
-            return;
-        }
-    }
-    const wantsJson = args.includes('--json');
-    const jsonBase = {
-        schema_version: '1.0',
-        timestamp: new Date().toISOString(),
-    };
-    let parsedApi;
-    try {
-        parsedApi = parseTeamApiArgs(args);
-    }
-    catch (error) {
-        if (wantsJson) {
-            console.log(JSON.stringify({
-                ...jsonBase,
-                ok: false,
-                command: 'omc team api',
-                operation: 'unknown',
-                error: {
-                    code: 'invalid_input',
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            }));
-            process.exitCode = 1;
-            return;
-        }
-        throw error;
-    }
-    const envelope = await executeTeamApiOperation(parsedApi.operation, parsedApi.input, cwd);
-    if (parsedApi.json) {
-        console.log(JSON.stringify({
-            ...jsonBase,
-            command: `omc team api ${parsedApi.operation}`,
-            ...envelope,
-        }));
-        if (!envelope.ok)
-            process.exitCode = 1;
-        return;
-    }
-    if (envelope.ok) {
-        console.log(`ok operation=${envelope.operation}`);
-        console.log(JSON.stringify(envelope.data, null, 2));
-        return;
-    }
-    console.error(`error operation=${envelope.operation} code=${envelope.error.code}: ${envelope.error.message}`);
-    process.exitCode = 1;
-}
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-/**
- * Main team subcommand handler.
- * Routes:
- *   omc team [N:agent-type] "task"          -> Start team
- *   omc team status <team-name>             -> Monitor
- *   omc team shutdown <team-name> [--force] -> Shutdown
- *   omc team api <operation> [--input] ...  -> Worker CLI API
- */
-export async function teamCommand(args) {
-    const cwd = process.cwd();
-    const [subcommandRaw] = args;
-    const subcommand = (subcommandRaw || '').toLowerCase();
-    if (HELP_TOKENS.has(subcommand) || !subcommand) {
-        console.log(TEAM_HELP.trim());
-        return;
-    }
-    // omc team api <operation> ...
-    if (subcommand === 'api') {
-        await handleTeamApi(args.slice(1), cwd);
-        return;
-    }
-    // omc team status <team-name>
-    if (subcommand === 'status') {
-        const name = args[1];
-        if (!name)
-            throw new Error('Usage: omc team status <team-name>');
-        await handleTeamStatus(name, cwd);
-        return;
-    }
-    // omc team shutdown <team-name> [--force]
-    if (subcommand === 'shutdown') {
-        const nameOrFlag = args.filter(a => !a.startsWith('--'));
-        const name = nameOrFlag[1]; // skip 'shutdown' itself
-        if (!name)
-            throw new Error('Usage: omc team shutdown <team-name> [--force]');
-        const force = args.includes('--force');
-        await handleTeamShutdown(name, cwd, force);
-        return;
-    }
-    // Default: omc team [N:agent-type] "task" -> Start team
-    try {
-        const parsed = parseTeamArgs(args);
-        await handleTeamStart(parsed, cwd);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        console.log(TEAM_HELP.trim());
-        process.exitCode = 1;
-    }
-}
-//# sourceMappingURL=team.js.map