@swarmify/agents-cli 1.13.4 → 1.14.0

package/dist/lib/teams/agents.js

@@ -1,1244 +0,0 @@
-/**
- * Teams agent lifecycle management.
- *
- * Defines the AgentProcess and AgentManager classes that handle spawning,
- * monitoring, stopping, and persisting teammate processes across all supported
- * agent CLIs (Claude, Codex, Gemini, Cursor, OpenCode). Supports DAG-based
- * dependency scheduling via --after, per-teammate model/effort overrides, and
- * multiple permission modes (plan, edit, full).
- */
-import { spawn, execSync } from 'child_process';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { randomUUID } from 'crypto';
-import { resolveAgentsDir } from './persistence.js';
-import { normalizeEvents } from './parsers.js';
-import { debug } from './debug.js';
-import { buildReasoningFlags } from '../models.js';
-/**
- * Compute the Lowest Common Ancestor (LCA) of multiple file paths.
- * Returns the deepest common directory shared by all paths.
- * Returns null if paths is empty or paths have no common ancestor (different roots).
- */
-export function computePathLCA(paths) {
-    const validPaths = paths.filter(p => p && p.trim());
-    if (validPaths.length === 0)
-        return null;
-    if (validPaths.length === 1)
-        return validPaths[0];
-    // Normalize and split all paths into segments
-    const splitPaths = validPaths.map(p => {
-        const normalized = path.resolve(p);
-        // Split by path separator, filter empty segments
-        return normalized.split(path.sep).filter(seg => seg);
-    });
-    // Find minimum length
-    const minLen = Math.min(...splitPaths.map(p => p.length));
-    // Find common prefix
-    const commonSegments = [];
-    for (let i = 0; i < minLen; i++) {
-        const segment = splitPaths[0][i];
-        const allMatch = splitPaths.every(p => p[i] === segment);
-        if (allMatch) {
-            commonSegments.push(segment);
-        }
-        else {
-            break;
-        }
-    }
-    if (commonSegments.length === 0)
-        return null;
-    // Reconstruct path (add leading separator for absolute paths)
-    const lca = path.sep + commonSegments.join(path.sep);
-    return lca;
-}
-/** Lifecycle status of a teammate process. */
-export var AgentStatus;
-(function (AgentStatus) {
-    AgentStatus["PENDING"] = "pending";
-    AgentStatus["RUNNING"] = "running";
-    AgentStatus["COMPLETED"] = "completed";
-    AgentStatus["FAILED"] = "failed";
-    AgentStatus["STOPPED"] = "stopped";
-})(AgentStatus || (AgentStatus = {}));
-export const VALID_TASK_TYPES = [
-    'plan', 'implement', 'test', 'review', 'bugfix', 'docs',
-];
-/**
- * Walk the `after` chain from `startName` within the given map; returns true
- * if `targetName` appears anywhere in the transitive dependency closure.
- * Used to detect cycles before adding a new --after edge.
- */
-function hasTransitiveDep(byName, startName, targetName, seen = new Set()) {
-    if (seen.has(startName))
-        return false;
-    seen.add(startName);
-    const node = byName.get(startName);
-    if (!node)
-        return false;
-    for (const dep of node.after) {
-        if (dep === targetName)
-            return true;
-        if (hasTransitiveDep(byName, dep, targetName, seen))
-            return true;
-    }
-    return false;
-}
-// Base commands for plan mode (read-only, may prompt for confirmation)
-export const AGENT_COMMANDS = {
-    codex: ['codex', 'exec', '--sandbox', 'workspace-write', '{prompt}', '--json'],
-    cursor: ['cursor-agent', '-p', '--output-format', 'stream-json', '{prompt}'],
-    gemini: ['gemini', '{prompt}', '--output-format', 'stream-json', '--approval-mode', 'plan'],
-    claude: ['claude', '-p', '--verbose', '{prompt}', '--output-format', 'stream-json', '--permission-mode', 'plan'],
-    opencode: ['opencode', 'run', '--format', 'json', '{prompt}'],
-};
-// Minimal defaults — no per-effort model map. Configs on disk may still have
-// a model pinned; launchProcess picks it up from agent.model when set.
-function loadDefaultAgentConfigs() {
-    return {
-        claude: { command: 'claude -p \'{prompt}\' --output-format stream-json --json', enabled: true, model: null, provider: 'anthropic' },
-        codex: { command: 'codex exec --sandbox workspace-write \'{prompt}\' --json', enabled: true, model: null, provider: 'openai' },
-        gemini: { command: 'gemini \'{prompt}\' --output-format stream-json', enabled: true, model: null, provider: 'google' },
-        cursor: { command: 'cursor-agent -p --output-format stream-json \'{prompt}\'', enabled: true, model: null, provider: 'custom' },
-        opencode: { command: 'opencode run --format json \'{prompt}\'', enabled: true, model: null, provider: 'custom' },
-    };
-}
-// Suffix appended to all prompts to ensure agents provide a summary
-const PROMPT_SUFFIX = `
-
-When you're done, provide a brief summary of:
-1. What you did (1-2 sentences)
-2. Key files modified and why
-3. Any important classes, functions, or components you added/changed`;
-// Prefix for Claude agents in plan mode - explains the headless plan mode restrictions
-const CLAUDE_PLAN_MODE_PREFIX = `You are running in HEADLESS PLAN MODE. This mode works like normal plan mode with one exception: you cannot write to ~/.claude/plans/ directory. Instead of writing a plan file, output your complete plan/response as your final message.
-
-`;
-const VALID_MODES = ['plan', 'edit', 'full'];
-function normalizeModeValue(modeValue) {
-    if (!modeValue)
-        return null;
-    const normalized = modeValue.trim().toLowerCase();
-    if (VALID_MODES.includes(normalized)) {
-        return normalized;
-    }
-    return null;
-}
-function defaultModeFromEnv() {
-    for (const envVar of ['AGENTS_MCP_MODE', 'AGENTS_MCP_DEFAULT_MODE']) {
-        const rawValue = process.env[envVar];
-        const parsed = normalizeModeValue(rawValue);
-        if (parsed) {
-            return parsed;
-        }
-        if (rawValue) {
-            console.warn(`Invalid ${envVar}='${rawValue}'. Use 'plan' or 'edit'. Falling back to plan mode.`);
-        }
-    }
-    return 'plan';
-}
-function coerceDate(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        const ms = value < 1e12 ? value * 1000 : value;
-        const date = new Date(ms);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed)
-            return null;
-        const numeric = Number(trimmed);
-        if (!Number.isNaN(numeric)) {
-            const ms = numeric < 1e12 ? numeric * 1000 : numeric;
-            const date = new Date(ms);
-            if (!Number.isNaN(date.getTime()))
-                return date;
-        }
-        const date = new Date(trimmed);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    return null;
-}
-function extractTimestamp(raw) {
-    if (!raw || typeof raw !== 'object')
-        return null;
-    const candidates = [
-        raw.timestamp,
-        raw.time,
-        raw.created_at,
-        raw.createdAt,
-        raw.ts,
-        raw.started_at,
-        raw.startedAt,
-    ];
-    for (const candidate of candidates) {
-        const date = coerceDate(candidate);
-        if (date)
-            return date;
-    }
-    return null;
-}
-/** Resolve a mode string to a validated Mode, falling back to the given default. */
-export function resolveMode(requestedMode, defaultMode = 'plan') {
-    const normalizedDefault = normalizeModeValue(defaultMode);
-    if (!normalizedDefault) {
-        throw new Error(`Invalid default mode '${defaultMode}'. Use 'plan' or 'edit'.`);
-    }
-    if (requestedMode !== null && requestedMode !== undefined) {
-        const normalizedMode = normalizeModeValue(requestedMode);
-        if (!normalizedMode) {
-            throw new Error(`Invalid mode '${requestedMode}'. Valid modes: 'plan' (read-only) or 'edit' (can write).`);
-        }
-        return normalizedMode;
-    }
-    return normalizedDefault;
-}
-/** Ensure Gemini's settings.json has experimental.plan enabled for headless plan mode. */
-export async function ensureGeminiPlanMode() {
-    const settingsPath = path.join(os.homedir(), '.gemini', 'settings.json');
-    try {
-        let settings = {};
-        try {
-            const raw = await fs.readFile(settingsPath, 'utf-8');
-            settings = JSON.parse(raw);
-        }
-        catch {
-            // No settings file or invalid JSON
-        }
-        if (settings.experimental?.plan === true)
-            return;
-        settings.experimental = { ...settings.experimental, plan: true };
-        await fs.mkdir(path.dirname(settingsPath), { recursive: true });
-        await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-        console.error('[Swarm] Enabled Gemini experimental.plan in', settingsPath);
-    }
-    catch (err) {
-        console.warn('[Swarm] Could not enable Gemini plan mode:', err);
-    }
-}
-/** Check whether the CLI binary for a given agent type exists in PATH. Returns [available, pathOrError]. */
-export function checkCliAvailable(agentType) {
-    const cmdTemplate = AGENT_COMMANDS[agentType];
-    if (!cmdTemplate) {
-        return [false, `Unknown agent type: ${agentType}`];
-    }
-    const executable = cmdTemplate[0];
-    try {
-        const whichPath = execSync(`which ${executable}`, { encoding: 'utf-8' }).trim();
-        return [true, whichPath];
-    }
-    catch {
-        return [false, `CLI tool '${executable}' not found in PATH. Install it first.`];
-    }
-}
-/** Check availability of all known agent CLIs. Returns a map of agent type to install status. */
-export function checkAllClis() {
-    const results = {};
-    for (const agentType of Object.keys(AGENT_COMMANDS)) {
-        const [available, pathOrError] = checkCliAvailable(agentType);
-        if (available) {
-            results[agentType] = { installed: true, path: pathOrError, error: null };
-        }
-        else {
-            results[agentType] = { installed: false, path: null, error: pathOrError };
-        }
-    }
-    return results;
-}
-let AGENTS_DIR = null;
-/** Resolve and cache the base directory where teammate process data is stored. */
-export async function getAgentsDir() {
-    if (!AGENTS_DIR) {
-        AGENTS_DIR = await resolveAgentsDir();
-    }
-    return AGENTS_DIR;
-}
-/**
- * Represents a single teammate process within a team.
- *
- * Tracks process metadata (PID, status, timestamps), reads incremental
- * stdout events, persists state to disk as meta.json, and can be
- * reconstituted from disk via loadFromDisk().
- */
-export class AgentProcess {
-    agentId;
-    taskName;
-    agentType;
-    prompt;
-    cwd;
-    workspaceDir;
-    mode = 'plan';
-    pid = null;
-    status = AgentStatus.RUNNING;
-    startedAt = new Date();
-    completedAt = null;
-    parentSessionId = null;
-    cloudSessionId = null;
-    cloudProvider = null;
-    prUrl = null;
-    version = null;
-    remoteSessionId = null;
-    name = null;
-    // Names of teammates in the same team that this teammate is waiting on.
-    // Empty array = no deps = can run immediately. Populated by `teams add --after`.
-    after = [];
-    // Reasoning-intensity knob wired into buildReasoningFlags at launch time.
-    // Resolved late so config/effort-default changes between spawn and launch
-    // are honored for teammates staged via `teams add --after`.
-    effort = null;
-    // Pinned model for this teammate. When null, the agent's CLI picks its
-    // own default (no --model forwarded).
-    model = null;
-    // Extra env vars passed through to the child process (from --env KEY=VALUE).
-    envOverrides = null;
-    // Factory task-type label. When set, drives planner fan-out and the
-    // test-oracle loop. Null for plain teammates — no behavioral change.
-    taskType = null;
-    // Repo/branch for cloud dispatches that stage behind --after. Captured
-    // at spawn time so startReady() can invoke the dispatcher with the same
-    // options the user originally supplied.
-    cloudRepo = null;
-    cloudBranch = null;
-    eventsCache = [];
-    lastReadPos = 0;
-    baseDir = null;
-    constructor(agentId, taskName, agentType, prompt, cwd = null, mode = 'plan', pid = null, status = AgentStatus.RUNNING, startedAt = new Date(), completedAt = null, baseDir = null, parentSessionId = null, workspaceDir = null, cloudSessionId = null, cloudProvider = null, prUrl = null, version = null, remoteSessionId = null, name = null, after = [], effort = null, model = null, envOverrides = null, taskType = null, cloudRepo = null, cloudBranch = null) {
-        this.agentId = agentId;
-        this.remoteSessionId = remoteSessionId;
-        this.name = name;
-        this.after = after;
-        this.effort = effort;
-        this.model = model;
-        this.envOverrides = envOverrides;
-        this.taskType = taskType;
-        this.cloudRepo = cloudRepo;
-        this.cloudBranch = cloudBranch;
-        this.taskName = taskName;
-        this.agentType = agentType;
-        this.prompt = prompt;
-        this.cwd = cwd;
-        this.workspaceDir = workspaceDir;
-        this.mode = mode;
-        this.pid = pid;
-        this.status = status;
-        this.startedAt = startedAt;
-        this.completedAt = completedAt;
-        this.baseDir = baseDir;
-        this.parentSessionId = parentSessionId;
-        this.cloudSessionId = cloudSessionId;
-        this.cloudProvider = cloudProvider;
-        this.prUrl = prUrl;
-        this.version = version;
-    }
-    get isEditMode() {
-        return this.mode === 'edit' || this.mode === 'full';
-    }
-    async getAgentDir() {
-        const base = this.baseDir || await getAgentsDir();
-        return path.join(base, this.agentId);
-    }
-    /**
-     * Dump the subset of state the Ledger sync hook needs. Keeps sync.ts
-     * free of any teams-internal imports.
-     */
-    async toSnapshot() {
-        return {
-            agent_id: this.agentId,
-            team_id: this.taskName,
-            teammate_name: this.name,
-            agent_type: this.agentType,
-            task_type: this.taskType,
-            status: this.status,
-            started_at: this.startedAt.toISOString(),
-            completed_at: this.completedAt?.toISOString() ?? null,
-            after: this.after,
-            cloud_provider: this.cloudProvider,
-            cloud_session_id: this.cloudSessionId,
-            cloud_repo: this.cloudRepo,
-            cloud_branch: this.cloudBranch,
-            agent_dir: await this.getAgentDir(),
-            cwd: this.cwd,
-        };
-    }
-    async getStdoutPath() {
-        return path.join(await this.getAgentDir(), 'stdout.log');
-    }
-    async getMetaPath() {
-        return path.join(await this.getAgentDir(), 'meta.json');
-    }
-    toDict() {
-        return {
-            agent_id: this.agentId,
-            task_name: this.taskName,
-            agent_type: this.agentType,
-            status: this.status,
-            started_at: this.startedAt.toISOString(),
-            completed_at: this.completedAt?.toISOString() || null,
-            event_count: this.events.length,
-            duration: this.duration(),
-            mode: this.mode,
-            parent_session_id: this.parentSessionId,
-            workspace_dir: this.workspaceDir,
-            cloud_session_id: this.cloudSessionId,
-            cloud_provider: this.cloudProvider,
-            pr_url: this.prUrl,
-            version: this.version,
-            remote_session_id: this.remoteSessionId,
-            name: this.name,
-            after: this.after,
-            effort: this.effort,
-            model: this.model,
-            env_overrides: this.envOverrides,
-            task_type: this.taskType,
-            cloud_repo: this.cloudRepo,
-            cloud_branch: this.cloudBranch,
-        };
-    }
-    duration() {
-        let seconds;
-        if (this.completedAt) {
-            seconds = (this.completedAt.getTime() - this.startedAt.getTime()) / 1000;
-        }
-        else if (this.status === AgentStatus.RUNNING) {
-            seconds = (Date.now() - this.startedAt.getTime()) / 1000;
-        }
-        else {
-            return null;
-        }
-        if (seconds < 60) {
-            return `${Math.floor(seconds)} seconds`;
-        }
-        else {
-            const minutes = seconds / 60;
-            return `${minutes.toFixed(1)} minutes`;
-        }
-    }
-    get events() {
-        return this.eventsCache;
-    }
-    /**
-     * Return the latest timestamp we have seen in the agent's events.
-     * Falls back to null when none are available.
-     */
-    getLatestEventTime() {
-        let latest = null;
-        for (const event of this.eventsCache) {
-            const ts = event?.timestamp;
-            if (!ts)
-                continue;
-            const parsed = new Date(ts);
-            if (!Number.isNaN(parsed.getTime())) {
-                if (!latest || parsed > latest) {
-                    latest = parsed;
-                }
-            }
-        }
-        return latest;
-    }
-    async readNewEvents() {
-        const stdoutPath = await this.getStdoutPath();
-        try {
-            const stats = await fs.stat(stdoutPath).catch(() => null);
-            if (!stats)
-                return;
-            const fallbackTimestamp = (stats.mtime || new Date()).toISOString();
-            const fd = await fs.open(stdoutPath, 'r');
-            const buffer = Buffer.alloc(1024 * 1024);
-            const { bytesRead } = await fd.read(buffer, 0, buffer.length, this.lastReadPos);
-            await fd.close();
-            if (bytesRead === 0)
-                return;
-            const newContent = buffer.toString('utf-8', 0, bytesRead);
-            this.lastReadPos += bytesRead;
-            const lines = newContent.split('\n').map(l => l.trim()).filter(l => l);
-            for (const line of lines) {
-                try {
-                    const rawEvent = JSON.parse(line);
-                    const events = normalizeEvents(this.agentType, rawEvent);
-                    const resolvedTimestamp = extractTimestamp(rawEvent)?.toISOString() || fallbackTimestamp;
-                    for (const event of events) {
-                        event.timestamp = resolvedTimestamp;
-                        this.eventsCache.push(event);
-                        // Capture the agent's own session/thread id the first time we see
-                        // it. For Claude it's the same uuid we passed via --session-id;
-                        // for others (Codex thread_id, Gemini/Cursor/OpenCode sessionID)
-                        // it's their internal id, which lets us cross-reference with
-                        // `agents sessions <id>`.
-                        if (!this.remoteSessionId && event.session_id) {
-                            this.remoteSessionId = event.session_id;
-                        }
-                        if (event.type === 'result' || event.type === 'turn.completed' || event.type === 'thread.completed') {
-                            if (event.status === 'success' || event.type === 'turn.completed') {
-                                this.status = AgentStatus.COMPLETED;
-                                this.completedAt = event.timestamp ? new Date(event.timestamp) : new Date();
-                            }
-                            else if (event.status === 'error') {
-                                this.status = AgentStatus.FAILED;
-                                this.completedAt = event.timestamp ? new Date(event.timestamp) : new Date();
-                            }
-                        }
-                    }
-                }
-                catch {
-                    this.eventsCache.push({
-                        type: 'raw',
-                        content: line,
-                        timestamp: fallbackTimestamp,
-                    });
-                }
-            }
-        }
-        catch (err) {
-            console.error(`Error reading events for agent ${this.agentId}:`, err);
-        }
-    }
-    async saveMeta() {
-        const agentDir = await this.getAgentDir();
-        await fs.mkdir(agentDir, { recursive: true });
-        const meta = {
-            agent_id: this.agentId,
-            task_name: this.taskName,
-            agent_type: this.agentType,
-            prompt: this.prompt,
-            cwd: this.cwd,
-            workspace_dir: this.workspaceDir,
-            mode: this.mode,
-            pid: this.pid,
-            status: this.status,
-            started_at: this.startedAt.toISOString(),
-            completed_at: this.completedAt?.toISOString() || null,
-            parent_session_id: this.parentSessionId,
-            cloud_session_id: this.cloudSessionId,
-            cloud_provider: this.cloudProvider,
-            pr_url: this.prUrl,
-            version: this.version,
-            remote_session_id: this.remoteSessionId,
-            name: this.name,
-            after: this.after,
-            effort: this.effort,
-            model: this.model,
-            env_overrides: this.envOverrides,
-            task_type: this.taskType,
-            cloud_repo: this.cloudRepo,
-            cloud_branch: this.cloudBranch,
-        };
-        const metaPath = await this.getMetaPath();
-        await fs.writeFile(metaPath, JSON.stringify(meta, null, 2));
-    }
-    static async loadFromDisk(agentId, baseDir = null) {
-        const base = baseDir || await getAgentsDir();
-        const agentDir = path.join(base, agentId);
-        const metaPath = path.join(agentDir, 'meta.json');
-        try {
-            await fs.access(metaPath);
-        }
-        catch {
-            return null;
-        }
-        try {
-            const metaContent = await fs.readFile(metaPath, 'utf-8');
-            const meta = JSON.parse(metaContent);
-            // Legacy teammates may have mode='ralph' or 'cloud' from before modes
-            // were narrowed. Coerce to the closest current mode so they still load.
-            const modeMap = {
-                edit: 'edit',
-                full: 'full',
-                ralph: 'full', // ralph used the same "no-permission" flags as full
-                cloud: 'edit', // cloud teammates had edit-level write access
-            };
-            const resolvedMode = modeMap[meta.mode] || 'plan';
-            // AgentStatus is a string enum. Validate meta.status against its VALUES
-            // (not its keys) — `AgentStatus["pending"]` is undefined but
-            // `AgentStatus.PENDING === "pending"` works.
-            const validStatuses = Object.values(AgentStatus);
-            const resolvedStatus = validStatuses.includes(meta.status)
-                ? meta.status
-                : AgentStatus.RUNNING;
-            const agent = new AgentProcess(meta.agent_id, meta.task_name || 'default', meta.agent_type, meta.prompt, meta.cwd || null, resolvedMode, meta.pid || null, resolvedStatus, new Date(meta.started_at), meta.completed_at ? new Date(meta.completed_at) : null, baseDir, meta.parent_session_id || null, meta.workspace_dir || null, meta.cloud_session_id || null, meta.cloud_provider || null, meta.pr_url || null, meta.version || null, meta.remote_session_id || null, meta.name || null, Array.isArray(meta.after) ? meta.after : [], meta.effort || null, meta.model || null, meta.env_overrides || null, meta.task_type && VALID_TASK_TYPES.includes(meta.task_type)
-                ? meta.task_type
-                : null, meta.cloud_repo || null, meta.cloud_branch || null);
-            return agent;
-        }
-        catch {
-            return null;
-        }
-    }
-    isProcessAlive() {
-        if (!this.pid)
-            return false;
-        try {
-            process.kill(this.pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async updateStatusFromProcess() {
-        if (!this.pid)
-            return;
-        if (this.isProcessAlive()) {
-            await this.readNewEvents();
-            return;
-        }
-        if (this.status === AgentStatus.RUNNING) {
-            const exitCode = await this.reapProcess();
-            await this.readNewEvents();
-            if (this.status === AgentStatus.RUNNING) {
-                const fallbackCompletion = this.getLatestEventTime() || this.startedAt || new Date();
-                if (exitCode !== null && exitCode !== 0) {
-                    this.status = AgentStatus.FAILED;
-                }
-                else {
-                    this.status = AgentStatus.COMPLETED;
-                }
-                this.completedAt = fallbackCompletion;
-            }
-        }
-        else if (!this.completedAt) {
-            await this.readNewEvents();
-            const fallbackCompletion = this.getLatestEventTime() || this.startedAt || new Date();
-            this.completedAt = fallbackCompletion;
-        }
-        await this.saveMeta();
-    }
-    async reapProcess() {
-        if (!this.pid)
-            return null;
-        try {
-            process.kill(this.pid, 0);
-            return null;
-        }
-        catch {
-            return 1;
-        }
-    }
-}
-export class AgentManager {
-    agents = new Map();
-    maxAgents;
-    maxConcurrent;
-    agentsDir = '';
-    filterByCwd;
-    cleanupAgeDays;
-    defaultMode;
-    agentConfigs;
-    constructorAgentConfigs = null;
-    initPromise = null;
-    cloudDispatcher = null;
-    completionHook = null;
-    syncedAgents = new Set();
-    constructorAgentsDir = null;
-    constructor(maxAgents = 50, maxConcurrent = 10, agentsDir = null, defaultMode = null, filterByCwd = null, cleanupAgeDays = 7, agentConfigs = null) {
-        this.maxAgents = maxAgents;
-        this.maxConcurrent = maxConcurrent;
-        this.constructorAgentsDir = agentsDir;
-        this.filterByCwd = filterByCwd;
-        this.cleanupAgeDays = cleanupAgeDays;
-        const resolvedDefaultMode = defaultMode ? normalizeModeValue(defaultMode) : defaultModeFromEnv();
-        if (!resolvedDefaultMode) {
-            throw new Error(`Invalid default_mode '${defaultMode}'. Use 'plan' or 'edit'.`);
-        }
-        this.defaultMode = resolvedDefaultMode;
-        this.constructorAgentConfigs = agentConfigs;
-        this.initPromise = this.doInitialize();
-    }
-    async initialize() {
-        if (!this.initPromise) {
-            this.initPromise = this.doInitialize();
-        }
-        return this.initPromise;
-    }
-    async doInitialize() {
-        this.agentsDir = this.constructorAgentsDir || await getAgentsDir();
-        await fs.mkdir(this.agentsDir, { recursive: true });
-        this.agentConfigs = this.constructorAgentConfigs ?? loadDefaultAgentConfigs();
-        await this.loadExistingAgents();
-    }
-    getDefaultMode() {
-        return this.defaultMode;
-    }
-    setModelOverrides(agentConfigs) {
-        this.agentConfigs = agentConfigs;
-    }
-    /**
-     * Register the callback used to dispatch cloud-backed teammates when their
-     * --after deps resolve. Called once at CLI startup by `agents teams`.
-     */
-    setCloudDispatcher(fn) {
-        this.cloudDispatcher = fn;
-    }
-    /**
-     * Register a hook to run once per teammate the first time it lands in a
-     * terminal status (completed / failed / stopped). The hook fires during
-     * listAll() / listByTask() status polling, so any CLI or MCP command that
-     * touches status triggers sync automatically.
-     */
-    setCompletionHook(fn) {
-        this.completionHook = fn;
-    }
-    registerAgent(agent) {
-        this.agents.set(agent.agentId, agent);
-    }
-    /**
-     * Scan the agents dir for meta.json files not already in the in-memory
-     * cache and load them. Needed when another process (e.g. a Planner
-     * teammate running `agents teams add`) creates new teammates while this
-     * manager is alive — the supervisor loop calls this each wave so
-     * dynamically-added teammates get picked up.
-     *
-     * Does not modify or re-load agents already in the cache; that path is
-     * covered by updateStatusFromProcess() which re-reads stdout.log.
-     */
-    async rescanFromDisk() {
-        await this.initialize();
-        try {
-            await fs.access(this.agentsDir);
-        }
-        catch {
-            return 0;
-        }
-        const entries = await fs.readdir(this.agentsDir);
-        let added = 0;
-        for (const entry of entries) {
-            if (this.agents.has(entry))
-                continue;
-            const agentDir = path.join(this.agentsDir, entry);
-            const stat = await fs.stat(agentDir).catch(() => null);
-            if (!stat || !stat.isDirectory())
-                continue;
-            const agent = await AgentProcess.loadFromDisk(entry, this.agentsDir);
-            if (!agent)
-                continue;
-            if (this.filterByCwd !== null && agent.cwd !== this.filterByCwd)
-                continue;
-            this.agents.set(entry, agent);
-            added++;
-        }
-        return added;
-    }
-    async loadExistingAgents() {
-        try {
-            await fs.access(this.agentsDir);
-        }
-        catch {
-            return;
-        }
-        const cutoffDate = new Date(Date.now() - this.cleanupAgeDays * 24 * 60 * 60 * 1000);
-        let loadedCount = 0;
-        let skippedCwd = 0;
-        let cleanedOld = 0;
-        const entries = await fs.readdir(this.agentsDir);
-        for (const entry of entries) {
-            const agentDir = path.join(this.agentsDir, entry);
-            const stat = await fs.stat(agentDir).catch(() => null);
-            if (!stat || !stat.isDirectory())
-                continue;
-            const agentId = entry;
-            const agent = await AgentProcess.loadFromDisk(agentId, this.agentsDir);
-            if (!agent)
-                continue;
-            if (agent.completedAt && agent.completedAt < cutoffDate) {
-                try {
-                    await fs.rm(agentDir, { recursive: true });
-                    cleanedOld++;
-                }
-                catch (err) {
-                    console.warn(`Failed to cleanup old agent ${agentId}:`, err);
-                }
-                continue;
-            }
-            if (this.filterByCwd !== null) {
-                const agentCwd = agent.cwd;
-                if (agentCwd !== this.filterByCwd) {
-                    skippedCwd++;
-                    continue;
-                }
-            }
-            await agent.updateStatusFromProcess();
-            this.agents.set(agentId, agent);
-            loadedCount++;
-        }
-        if (cleanedOld > 0) {
-            debug(`Cleaned up ${cleanedOld} old agents (older than ${this.cleanupAgeDays} days)`);
-        }
-        if (skippedCwd > 0) {
-            debug(`Skipped ${skippedCwd} agents (different CWD)`);
-        }
-        debug(`Loaded ${loadedCount} agents from disk`);
-    }
-    async spawn(taskName, agentType, prompt, cwd = null, mode = null, effort = 'medium', parentSessionId = null, workspaceDir = null, version = null, name = null, after = [], model = null, envOverrides = null, taskType = null, cloudProvider = null, cloudSessionId = null, cloudRepo = null, cloudBranch = null) {
-        await this.initialize();
-        const resolvedMode = resolveMode(mode, this.defaultMode);
-        // Enforce: teammate names are unique within a team.
-        const siblings = await this.listByTask(taskName);
-        if (name && siblings.some((a) => a.name === name)) {
-            throw new Error(`Team '${taskName}' already has a teammate named '${name}'. Pick another name or leave --name off.`);
-        }
-        // --- dependency validation ---
-        const cleanAfter = after.filter((s) => s && s.trim());
-        if (cleanAfter.length > 0) {
-            if (!name) {
-                throw new Error("Can't use --after without --name. Dependencies reference teammates by name.");
-            }
-            // Every --after entry must resolve to an existing teammate name.
-            const siblingNames = new Set(siblings.map((a) => a.name).filter(Boolean));
-            const missing = cleanAfter.filter((dep) => !siblingNames.has(dep));
-            if (missing.length > 0) {
-                throw new Error(`Team '${taskName}' has no teammate named ${missing.map((m) => `'${m}'`).join(', ')} yet.\n` +
-                    `  Add them first, then add this one.`);
-            }
-            // Cycle check: walk the transitive deps of each --after entry; if the
-            // new teammate's own name shows up, we'd create a cycle.
-            const byName = new Map(siblings.filter((a) => a.name).map((a) => [a.name, a]));
-            for (const dep of cleanAfter) {
-                if (hasTransitiveDep(byName, dep, name)) {
-                    throw new Error(`Adding '${name}' after '${dep}' would create a cycle (${dep} already depends on ${name}).`);
-                }
-            }
-        }
-        // Resolve and validate cwd
-        let resolvedCwd = null;
-        if (cwd !== null) {
-            resolvedCwd = path.resolve(cwd);
-            const stat = await fs.stat(resolvedCwd).catch(() => null);
-            if (!stat) {
-                throw new Error(`Working directory does not exist: ${cwd}`);
-            }
-            if (!stat.isDirectory()) {
-                throw new Error(`Working directory is not a directory: ${cwd}`);
-            }
-        }
-        // Cloud-backed teammates run on remote infrastructure; we don't need the
-        // local CLI for them (the pod has its own). The caller has already
-        // dispatched via the cloud provider and passed us the provider + session.
-        const isCloudBacked = Boolean(cloudProvider);
-        if (!isCloudBacked) {
-            const [available, pathOrError] = checkCliAvailable(agentType);
-            if (!available) {
-                throw new Error(pathOrError || 'CLI tool not available');
-            }
-        }
-        // Use a full UUIDv4 as the canonical agent_id. For Claude, we pass it via
-        // --session-id so it's also Claude's session id (unified identity).
-        const agentId = randomUUID();
-        const isStaged = cleanAfter.length > 0;
-        const agent = new AgentProcess(agentId, taskName, agentType, prompt, resolvedCwd, resolvedMode, null, isStaged ? AgentStatus.PENDING : AgentStatus.RUNNING, new Date(), null, this.agentsDir, parentSessionId, workspaceDir, cloudSessionId, cloudProvider, null, version, null, name, cleanAfter, effort, model, envOverrides && Object.keys(envOverrides).length > 0 ? envOverrides : null, taskType, cloudRepo, cloudBranch);
-        const agentDir = await agent.getAgentDir();
-        try {
-            await fs.mkdir(agentDir, { recursive: true });
-        }
-        catch (err) {
-            throw new Error(`Failed to create agent directory: ${err.message}`);
-        }
-        await agent.saveMeta();
-        this.agents.set(agentId, agent);
-        if (isStaged) {
-            debug(`Staged ${agentType} teammate '${name}' in team '${taskName}' (after: ${cleanAfter.join(', ')})`);
-        }
-        else if (isCloudBacked) {
-            // Cloud-backed teammate: the provider already dispatched a remote task.
-            // No local process to launch; status polling walks the provider instead.
-            debug(`Cloud-backed ${agentType} teammate via ${cloudProvider} (session=${cloudSessionId})`);
-        }
-        else {
-            await this.launchProcess(agent);
-        }
-        await this.cleanupOldAgents();
-        return agent;
-    }
-    /**
-     * Actually spawn the OS process for a teammate. Extracted from spawn() so
-     * staged teammates can be launched later by startReady().
-     */
-    async launchProcess(agent) {
-        const running = await this.listRunning();
-        if (running.length >= this.maxConcurrent) {
-            throw new Error(`Maximum concurrent agents (${this.maxConcurrent}) reached. Wait for an agent to complete or stop one first.`);
-        }
-        const effort = agent.effort ?? 'medium';
-        // Falls back to the pinned model in agentConfigs; null means "let the
-        // CLI pick its own default" (no --model flag forwarded). Effort is a
-        // separate knob wired into buildReasoningFlags inside buildCommand.
-        const resolvedModel = agent.model ?? this.agentConfigs[agent.agentType]?.model ?? null;
-        const cmd = this.buildCommand(agent.agentType, agent.prompt, agent.mode, resolvedModel, agent.cwd, agent.agentId, effort);
-        if (agent.version && cmd.length > 0) {
-            cmd[0] = `${cmd[0]}@${agent.version}`;
-        }
-        debug(`Launching ${agent.agentType} agent ${agent.agentId} [${agent.mode}]: ${cmd.slice(0, 3).join(' ')}...`);
-        try {
-            const stdoutPath = await agent.getStdoutPath();
-            const stdoutFile = await fs.open(stdoutPath, 'w');
-            const stdoutFd = stdoutFile.fd;
-            const childProcess = spawn(cmd[0], cmd.slice(1), {
-                stdio: ['ignore', stdoutFd, stdoutFd],
-                cwd: agent.cwd || undefined,
-                detached: true,
-                env: agent.envOverrides
-                    ? { ...process.env, ...agent.envOverrides }
-                    : process.env,
-            });
-            childProcess.unref();
-            stdoutFile.close().catch(() => { });
-            agent.pid = childProcess.pid || null;
-            agent.status = AgentStatus.RUNNING;
-            agent.startedAt = new Date();
-            await agent.saveMeta();
-        }
-        catch (err) {
-            await this.cleanupPartialAgent(agent);
-            console.error(`Failed to spawn agent ${agent.agentId}:`, err);
-            throw new Error(`Failed to spawn agent: ${err.message}`);
-        }
-        debug(`Launched agent ${agent.agentId} with PID ${agent.pid}`);
-    }
-    /**
-     * Fire any pending teammates in the given team whose `after` deps have all
-     * completed. Returns the list of teammates just launched. Repeatable:
-     * call it once per DAG wave. Safe to call on teams with no pending work
-     * (returns empty list).
-     */
-    async startReady(taskName) {
-        await this.initialize();
-        const teammates = await this.listByTask(taskName);
-        const byName = new Map(teammates.filter((a) => a.name).map((a) => [a.name, a]));
-        const launched = [];
-        for (const agent of teammates) {
-            if (agent.status !== AgentStatus.PENDING)
-                continue;
-            const depsReady = agent.after.every((depName) => {
-                const dep = byName.get(depName);
-                return dep && dep.status === AgentStatus.COMPLETED;
-            });
-            if (!depsReady)
-                continue;
-            try {
-                if (agent.cloudProvider) {
-                    if (!this.cloudDispatcher) {
-                        console.error(`Cannot start cloud-backed teammate ${agent.agentId}: no dispatcher registered.`);
-                        continue;
-                    }
-                    const { cloudSessionId } = await this.cloudDispatcher(agent);
-                    agent.cloudSessionId = cloudSessionId;
-                    agent.status = AgentStatus.RUNNING;
-                    agent.startedAt = new Date();
-                    await agent.saveMeta();
-                    launched.push(agent);
-                }
-                else {
-                    await this.launchProcess(agent);
-                    launched.push(agent);
-                }
-            }
-            catch (err) {
-                console.error(`Could not launch ${agent.agentId}:`, err);
-            }
-        }
-        return launched;
-    }
-    buildCommand(agentType, prompt, mode, model, cwd = null, sessionId = null, effort = 'medium') {
-        const cmdTemplate = AGENT_COMMANDS[agentType];
-        if (!cmdTemplate) {
-            throw new Error(`Unknown agent type: ${agentType}`);
-        }
-        const isEditMode = mode === 'edit';
-        // Build the full prompt with prefix (for plan mode) and suffix
-        let fullPrompt = prompt + PROMPT_SUFFIX;
-        // For Claude in plan mode, add prefix explaining headless plan mode restrictions
-        if (agentType === 'claude' && !isEditMode) {
-            fullPrompt = CLAUDE_PLAN_MODE_PREFIX + fullPrompt;
-        }
-        let cmd = cmdTemplate.map(part => part.replace('{prompt}', fullPrompt));
-        if (agentType === 'claude') {
-            // Grant access to the working directory.
-            if (cwd) {
-                cmd.push('--add-dir', cwd);
-            }
-            // Pin Claude's session UUID to our agent_id so the session file lands
-            // at ~/.claude/projects/.../<agent_id>.jsonl — unified identity.
-            if (sessionId) {
-                cmd.push('--session-id', sessionId);
-            }
-            // Note: we deliberately do NOT pass --settings here. The agents-cli
-            // shim exports CLAUDE_CONFIG_DIR scoped to the version being spawned,
-            // which makes Claude read settings.json, commands/, skills/, hooks/,
-            // and MCP config from that version's home. Passing a fixed
-            // ~/.claude/settings.json would override that and bind settings to the
-            // *default* version rather than the one this teammate is running.
-        }
-        // Add model flag for each agent type only when the teammate has a pinned
-        // model. When null, the agent's CLI picks its own default.
-        if (model) {
-            if (agentType === 'codex') {
-                const execIndex = cmd.indexOf('exec');
-                const sandboxIndex = cmd.indexOf('--sandbox');
-                const insertIndex = sandboxIndex !== -1 ? sandboxIndex : execIndex + 1;
-                cmd.splice(insertIndex, 0, '--model', model);
-            }
-            else if (agentType === 'cursor') {
-                cmd.push('--model', model);
-            }
-            else if (agentType === 'gemini' || agentType === 'claude') {
-                cmd.push('--model', model);
-            }
-            else if (agentType === 'opencode') {
-                cmd.push('--model', model);
-            }
-        }
-        if (agentType === 'opencode') {
-            const opencodeAgent = mode === 'edit' || mode === 'full' ? 'build' : 'plan';
-            const promptIndex = cmd.indexOf(fullPrompt);
-            if (promptIndex !== -1) {
-                cmd.splice(promptIndex + 1, 0, '--agent', opencodeAgent);
-            }
-        }
-        // Inject reasoning-intensity flags for agents that support them. Claude
-        // gets --effort appended; Codex gets `-c model_reasoning_effort=...`
-        // inserted before `exec` so it's parsed as a global config override.
-        const reasoningFlags = buildReasoningFlags(agentType, effort);
-        if (reasoningFlags.length > 0) {
-            if (agentType === 'codex') {
-                const execIndex = cmd.indexOf('exec');
-                const insertIndex = execIndex !== -1 ? execIndex : 1;
-                cmd.splice(insertIndex, 0, ...reasoningFlags);
-            }
-            else {
-                cmd.push(...reasoningFlags);
-            }
-        }
-        if (mode === 'full') {
-            cmd = this.applyFullMode(agentType, cmd);
-        }
-        else if (isEditMode) {
-            cmd = this.applyEditMode(agentType, cmd);
-        }
-        return cmd;
-    }
-    applyEditMode(agentType, cmd) {
-        const editCmd = [...cmd];
-        switch (agentType) {
-            case 'codex':
-                editCmd.push('--full-auto');
-                break;
-            case 'cursor':
-                editCmd.push('-f');
-                break;
-            case 'gemini': {
-                const approvalIndex = editCmd.indexOf('--approval-mode');
-                if (approvalIndex !== -1) {
-                    editCmd.splice(approvalIndex, 2);
-                }
-                editCmd.push('--yolo');
-                break;
-            }
-            case 'claude':
-                const permModeIndex = editCmd.indexOf('--permission-mode');
-                if (permModeIndex !== -1 && permModeIndex + 1 < editCmd.length) {
-                    editCmd[permModeIndex + 1] = 'acceptEdits';
-                }
-                break;
-        }
-        return editCmd;
-    }
-    // "full" mode: edit-level write access with permission gates bypassed.
-    // For Claude that's --dangerously-skip-permissions; other agents already
-    // lack gates in edit mode so their commands match applyEditMode.
-    applyFullMode(agentType, cmd) {
-        const fullCmd = [...cmd];
-        switch (agentType) {
-            case 'codex':
-                fullCmd.push('--full-auto');
-                break;
-            case 'cursor':
-                fullCmd.push('-f');
-                break;
-            case 'gemini': {
-                const approvalIndex = fullCmd.indexOf('--approval-mode');
-                if (approvalIndex !== -1) {
-                    fullCmd.splice(approvalIndex, 2);
-                }
-                fullCmd.push('--yolo');
-                break;
-            }
-            case 'claude':
-                // Replace --permission-mode plan with --dangerously-skip-permissions
-                const permModeIndex = fullCmd.indexOf('--permission-mode');
-                if (permModeIndex !== -1) {
-                    fullCmd.splice(permModeIndex, 2); // Remove --permission-mode and its value
-                }
-                fullCmd.push('--dangerously-skip-permissions');
-                break;
-        }
-        return fullCmd;
-    }
-    async get(agentId) {
-        await this.initialize();
-        let agent = this.agents.get(agentId) || null;
-        if (agent) {
-            await agent.readNewEvents();
-            await agent.updateStatusFromProcess();
-            return agent;
-        }
-        agent = await AgentProcess.loadFromDisk(agentId, this.agentsDir);
-        if (agent) {
-            await agent.readNewEvents();
-            await agent.updateStatusFromProcess();
-            this.agents.set(agentId, agent);
-            return agent;
-        }
-        return null;
-    }
-    /**
-     * Resolve a teammate reference to a single agent_id within a team.
-     * Accepts (in priority order):
-     *   1. exact teammate name                ("alice")
-     *   2. exact UUID                         ("b2438499-dc25-4a5e-9e02-9916012580b8")
-     *   3. UUID prefix, if unique             ("b2438499")
-     *
-     * Returns:
-     *  - { kind: 'ok', agentId }       when exactly one teammate matches
-     *  - { kind: 'none' }              when nothing matches
-     *  - { kind: 'ambiguous', matches } when the prefix matches multiple ids
-     */
-    async resolveAgentIdInTask(taskName, ref) {
-        const agents = await this.listByTask(taskName);
-        const byName = agents.find((a) => a.name === ref);
-        if (byName)
-            return { kind: 'ok', agentId: byName.agentId };
-        const exact = agents.find((a) => a.agentId === ref);
-        if (exact)
-            return { kind: 'ok', agentId: exact.agentId };
-        const prefix = agents.filter((a) => a.agentId.startsWith(ref));
-        if (prefix.length === 1)
-            return { kind: 'ok', agentId: prefix[0].agentId };
-        if (prefix.length === 0)
-            return { kind: 'none' };
-        return { kind: 'ambiguous', matches: prefix.map((a) => a.agentId) };
-    }
-    async listAll() {
-        await this.initialize();
-        const agents = Array.from(this.agents.values());
-        for (const agent of agents) {
-            await agent.readNewEvents();
-            await agent.updateStatusFromProcess();
-            await this.maybeFireCompletionHook(agent);
-        }
-        return agents;
-    }
-    /**
-     * Fire the completion hook exactly once per teammate when it transitions
-     * into a terminal state. Errors are logged but never thrown — a ledger
-     * backend outage must not break status polling.
-     */
-    async maybeFireCompletionHook(agent) {
-        if (!this.completionHook)
-            return;
-        const terminal = agent.status === AgentStatus.COMPLETED ||
-            agent.status === AgentStatus.FAILED ||
-            agent.status === AgentStatus.STOPPED;
-        if (!terminal)
-            return;
-        if (this.syncedAgents.has(agent.agentId))
-            return;
-        this.syncedAgents.add(agent.agentId);
-        try {
-            await this.completionHook(agent);
-        }
-        catch (err) {
-            console.warn(`[ledger sync] completion hook failed for ${agent.agentId}:`, err);
-        }
-    }
-    async listRunning() {
-        const all = await this.listAll();
-        return all.filter(a => a.status === AgentStatus.RUNNING);
-    }
-    async listCompleted() {
-        const all = await this.listAll();
-        return all.filter(a => a.status !== AgentStatus.RUNNING);
-    }
-    async listByTask(taskName) {
-        const all = await this.listAll();
-        return all.filter(a => a.taskName === taskName);
-    }
-    async listByParentSession(parentSessionId) {
-        const all = await this.listAll();
-        return all.filter(a => a.parentSessionId === parentSessionId);
-    }
-    async stopByTask(taskName) {
-        const agents = await this.listByTask(taskName);
-        const stopped = [];
-        const alreadyStopped = [];
-        for (const agent of agents) {
-            if (agent.status === AgentStatus.RUNNING) {
-                const success = await this.stop(agent.agentId);
-                if (success) {
-                    stopped.push(agent.agentId);
-                }
-            }
-            else {
-                alreadyStopped.push(agent.agentId);
-            }
-        }
-        return { stopped, alreadyStopped };
-    }
-    async stop(agentId) {
-        await this.initialize();
-        const agent = this.agents.get(agentId);
-        if (!agent) {
-            return false;
-        }
-        if (agent.pid && agent.status === AgentStatus.RUNNING) {
-            try {
-                process.kill(-agent.pid, 'SIGTERM');
-                debug(`Sent SIGTERM to agent ${agentId} (PID ${agent.pid})`);
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                if (agent.isProcessAlive()) {
-                    process.kill(-agent.pid, 'SIGKILL');
-                    debug(`Sent SIGKILL to agent ${agentId}`);
-                }
-            }
-            catch {
-            }
-            agent.status = AgentStatus.STOPPED;
-            agent.completedAt = new Date();
-            await agent.saveMeta();
-            debug(`Stopped agent ${agentId}`);
-            return true;
-        }
-        return false;
-    }
-    async cleanupPartialAgent(agent) {
-        this.agents.delete(agent.agentId);
-        try {
-            const agentDir = await agent.getAgentDir();
-            await fs.rm(agentDir, { recursive: true });
-        }
-        catch (err) {
-            console.warn(`Failed to clean up agent directory:`, err);
-        }
-    }
-    async cleanupOldAgents() {
-        const completed = await this.listCompleted();
-        if (completed.length > this.maxAgents) {
-            completed.sort((a, b) => {
-                const aTime = a.completedAt?.getTime() || 0;
-                const bTime = b.completedAt?.getTime() || 0;
-                return aTime - bTime;
-            });
-            for (const agent of completed.slice(0, completed.length - this.maxAgents)) {
-                this.agents.delete(agent.agentId);
-                try {
-                    const agentDir = await agent.getAgentDir();
-                    await fs.rm(agentDir, { recursive: true });
-                }
-                catch (err) {
-                    console.warn(`Failed to cleanup old agent ${agent.agentId}:`, err);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=agents.js.map