@phnx-labs/agents-cli 1.18.1 → 1.18.3

package/dist/lib/state.js

@@ -282,6 +282,8 @@ export function getSessionsDbPath() { return SESSIONS_DB_PATH; }
 export function getTeamsDir() { return TEAMS_DIR; }
 /** Path to teams execution history (~/.agents/.history/teams/agents/). */
 export function getTeamsAgentsDir() { return TEAMS_AGENTS_DIR; }
+/** Path to the team registry — list of named teams with timestamps. Durable runtime, per-machine. */
+export function getTeamsRegistryPath() { return path.join(HISTORY_DIR, 'teams', 'registry.json'); }
 /** Path to cloud dispatch cache (~/.agents/.cache/cloud/). */
 export function getCloudDir() { return CLOUD_DIR; }
 /** Path to terminal session metadata (~/.agents/.cache/terminals/). */

package/dist/lib/teams/agents.d.ts

@@ -1,4 +1,3 @@
-import { type AgentConfig } from './persistence.js';
 import { AgentType } from './parsers.js';
 /**
  * Compute the Lowest Common Ancestor (LCA) of multiple file paths.
@@ -31,20 +30,10 @@ export type { AgentType } from './parsers.js';
  * Returns null on any error so callers can skip the guard rather than crash.
  */
 export declare function captureProcessStartTime(pid: number): string | null;
-export declare const AGENT_COMMANDS: Record<AgentType, string[]>;
 /**
- * Rewrite a plan-mode command into edit mode (writes inside cwd allowed,
- * approval prompts may still appear). Pure function — exported for tests.
- */
-export declare function applyEditMode(agentType: AgentType, cmd: string[]): string[];
-/**
- * Rewrite a plan-mode command into full mode (writes + approval gates
- * bypassed). Pure function — exported for tests.
- */
-export declare function applyFullMode(agentType: AgentType, cmd: string[]): string[];
-/**
- * Reasoning-intensity knob wired into buildReasoningFlags.
- * Does not select a model; use --model separately to pin a specific model per teammate.
+ * Reasoning-intensity knob. Passed through to `agents run --effort`, which
+ * translates it into per-agent reasoning flags (claude --effort, codex
+ * model_reasoning_effort override). Mode (plan/edit/full) is a separate knob.
  */
 export type EffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
 declare const VALID_MODES: readonly ["plan", "edit", "full"];
@@ -165,16 +154,13 @@ export declare class AgentManager {
     private filterByCwd;
     private cleanupAgeDays;
     private defaultMode;
-    private agentConfigs;
-    private constructorAgentConfigs;
     private initPromise;
     private cloudDispatcher;
     private constructorAgentsDir;
-    constructor(maxAgents?: number, agentsDir?: string | null, defaultMode?: Mode | null, filterByCwd?: string | null, cleanupAgeDays?: number, agentConfigs?: Record<AgentType, AgentConfig> | null);
+    constructor(maxAgents?: number, agentsDir?: string | null, defaultMode?: Mode | null, filterByCwd?: string | null, cleanupAgeDays?: number);
     private initialize;
     private doInitialize;
     getDefaultMode(): Mode;
-    setModelOverrides(agentConfigs: Record<AgentType, AgentConfig>): void;
     /**
      * Register the callback used to dispatch cloud-backed teammates when their
      * --after deps resolve. Called once at CLI startup by `agents teams`.
@@ -206,9 +192,14 @@ export declare class AgentManager {
      * (returns empty list).
      */
     startReady(taskName: string): Promise<AgentProcess[]>;
+    /**
+     * Build the argv to spawn for a teammate. Delegates to `agents run` so the
+     * agent's CLI flags, version routing, mode handling (plan/edit/full), model
+     * injection, and reasoning-intensity flags are owned by a single canonical
+     * exec path (src/lib/exec.ts). The team runner just supplies prompt + mode
+     * and reads stream-json events off stdout.
+     */
     private buildCommand;
-    private applyEditMode;
-    private applyFullMode;
     get(agentId: string): Promise<AgentProcess | null>;
     /**
      * Resolve a teammate reference to a single agent_id within a team.

package/dist/lib/teams/agents.js

@@ -16,9 +16,9 @@ import { randomUUID } from 'crypto';
 import { resolveAgentsDir } from './persistence.js';
 import { normalizeEvents } from './parsers.js';
 import { debug } from './debug.js';
-import { buildReasoningFlags } from '../models.js';
 import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from '../gemini-settings.js';
 import { getAgentsDir as getSystemAgentsDir } from '../state.js';
+import { AGENTS } from '../agents.js';
 let lastMemoryWarnAt = 0;
 // On macOS, os.freemem() returns only the truly-free pool and ignores the
 // large inactive+purgeable cache the kernel will reclaim under pressure, so
@@ -170,103 +170,8 @@ export function captureProcessStartTime(pid) {
         return null;
     }
 }
-// Base commands for plan mode (read-only). applyEditMode / applyFullMode
-// rewrite these for write-capable modes. Each agent's read-only flag MUST be
-// here so a plan-mode teammate truly cannot write — even if the teammate
-// prompt tries to ignore the instruction. See agents.test.ts for the contract.
-export const AGENT_COMMANDS = {
-    codex: ['codex', 'exec', '--sandbox', 'read-only', '{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}'],
-};
-/**
- * Rewrite a plan-mode command into edit mode (writes inside cwd allowed,
- * approval prompts may still appear). Pure function — exported for tests.
- */
-export function applyEditMode(agentType, cmd) {
-    const editCmd = [...cmd];
-    switch (agentType) {
-        case 'codex': {
-            // Swap --sandbox read-only -> --sandbox workspace-write so the codex
-            // sandbox actually permits writes. --full-auto then disables approvals.
-            const sandboxIndex = editCmd.indexOf('--sandbox');
-            if (sandboxIndex !== -1 && sandboxIndex + 1 < editCmd.length) {
-                editCmd[sandboxIndex + 1] = 'workspace-write';
-            }
-            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;
-}
-/**
- * Rewrite a plan-mode command into full mode (writes + approval gates
- * bypassed). Pure function — exported for tests.
- */
-export function applyFullMode(agentType, cmd) {
-    const fullCmd = [...cmd];
-    switch (agentType) {
-        case 'codex': {
-            const sandboxIndex = fullCmd.indexOf('--sandbox');
-            if (sandboxIndex !== -1 && sandboxIndex + 1 < fullCmd.length) {
-                fullCmd[sandboxIndex + 1] = 'workspace-write';
-            }
-            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': {
-            const permModeIndex = fullCmd.indexOf('--permission-mode');
-            if (permModeIndex !== -1) {
-                fullCmd.splice(permModeIndex, 2);
-            }
-            fullCmd.push('--dangerously-skip-permissions');
-            break;
-        }
-    }
-    return fullCmd;
-}
-// 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' },
-    };
-}
+/** Agent types the team runner supports. */
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 
@@ -385,11 +290,10 @@ export async function ensureGeminiPlanMode() {
 }
 /** 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) {
+    const executable = AGENTS[agentType]?.cliCommand;
+    if (!executable) {
         return [false, `Unknown agent type: ${agentType}`];
     }
-    const executable = cmdTemplate[0];
     try {
         const whichPath = execSync(`which ${executable}`, { encoding: 'utf-8' }).trim();
         return [true, whichPath];
@@ -401,7 +305,7 @@ export function checkCliAvailable(agentType) {
 /** 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)) {
+    for (const agentType of TEAM_AGENT_TYPES) {
         const [available, pathOrError] = checkCliAvailable(agentType);
         if (available) {
             results[agentType] = { installed: true, path: pathOrError, error: null };
@@ -845,12 +749,10 @@ export class AgentManager {
     filterByCwd;
     cleanupAgeDays;
     defaultMode;
-    agentConfigs;
-    constructorAgentConfigs = null;
     initPromise = null;
     cloudDispatcher = null;
     constructorAgentsDir = null;
-    constructor(maxAgents = 50, agentsDir = null, defaultMode = null, filterByCwd = null, cleanupAgeDays = 7, agentConfigs = null) {
+    constructor(maxAgents = 50, agentsDir = null, defaultMode = null, filterByCwd = null, cleanupAgeDays = 7) {
         this.maxAgents = maxAgents;
         this.constructorAgentsDir = agentsDir;
         this.filterByCwd = filterByCwd;
@@ -860,7 +762,6 @@ export class AgentManager {
             throw new Error(`Invalid default_mode '${defaultMode}'. Use 'plan' or 'edit'.`);
         }
         this.defaultMode = resolvedDefaultMode;
-        this.constructorAgentConfigs = agentConfigs;
         this.initPromise = this.doInitialize();
     }
     async initialize() {
@@ -872,15 +773,11 @@ export class AgentManager {
     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`.
@@ -1070,14 +967,11 @@ export class AgentManager {
         const running = await this.listRunning();
         warnIfMemoryLow(running.length);
         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}`;
-        }
+        // null model 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 ?? null;
+        const cmd = this.buildCommand(agent.agentType, agent.prompt, agent.mode, resolvedModel, agent.cwd, agent.agentId, effort, agent.version);
         debug(`Launching ${agent.agentType} agent ${agent.agentId} [${agent.mode}]: ${cmd.slice(0, 3).join(' ')}...`);
         try {
             const stdoutPath = await agent.getStdoutPath();
@@ -1154,98 +1048,57 @@ export class AgentManager {
         }
         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
+    /**
+     * Build the argv to spawn for a teammate. Delegates to `agents run` so the
+     * agent's CLI flags, version routing, mode handling (plan/edit/full), model
+     * injection, and reasoning-intensity flags are owned by a single canonical
+     * exec path (src/lib/exec.ts). The team runner just supplies prompt + mode
+     * and reads stream-json events off stdout.
+     */
+    buildCommand(agentType, prompt, mode, model, cwd = null, sessionId = null, effort = 'medium', version = null) {
+        // Compose the prompt: a plan-mode prefix for Claude (clarifying headless
+        // plan-mode restrictions) and a universal summary suffix. These are
+        // team-specific prompt scaffolding — `agents run` does not apply them.
         let fullPrompt = prompt + PROMPT_SUFFIX;
-        // For Claude in plan mode, add prefix explaining headless plan mode restrictions
-        if (agentType === 'claude' && !isEditMode) {
+        if (agentType === 'claude' && mode !== 'edit') {
             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.
-        }
+        const target = version ? `${agentType}@${version}` : agentType;
+        const agentsCli = process.argv[1];
+        const cmd = [
+            process.execPath,
+            agentsCli,
+            'run',
+            target,
+            fullPrompt,
+            '--mode', mode,
+            '--effort', effort,
+            '--json',
+            '--headless',
+            '--quiet',
+        ];
+        if (model)
+            cmd.push('--model', model);
+        if (cwd)
+            cmd.push('--cwd', cwd);
+        // Pin Claude's session UUID to our agent_id so its session file lands at
+        // ~/.claude/projects/.../<agent_id>.jsonl — unified identity for status polling.
+        if (agentType === 'claude' && sessionId) {
+            cmd.push('--session-id', sessionId);
+        }
+        // Claude: grant access to the teammate's working directory.
+        if (agentType === 'claude' && cwd) {
+            cmd.push('--add-dir', cwd);
+        }
+        // Codex's workspace-write sandbox blocks writes outside cwd. Factory
+        // teammates need to run further `agents teams add` commands, which
+        // write to ~/.agents/. Grant that root so subprocess-issued
+        // `agents teams add` calls hit the real store.
         if (agentType === 'codex') {
-            // Codex's workspace-write sandbox blocks writes outside cwd. Factory
-            // teammates need to run further `agents teams add` commands,
-            // which write to ~/.agents/. Grant that root so subprocess-issued
-            // `agents teams add` calls hit the real store instead of the tmp
-            // fallback (which the supervisor does not watch).
             cmd.push('--add-dir', getSystemAgentsDir());
         }
-        // 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) {
-        return applyEditMode(agentType, cmd);
-    }
-    applyFullMode(agentType, cmd) {
-        return applyFullMode(agentType, cmd);
-    }
     async get(agentId) {
         await this.initialize();
         let agent = this.agents.get(agentId) || null;

package/dist/lib/teams/index.d.ts

@@ -5,11 +5,12 @@
  * to reuse the same agent lifecycle, parsing, summarization, and persistence
  * layer that powers the `agents teams` CLI.
  */
-export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, AGENT_COMMANDS, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, type TaskType, type CloudDispatchFn, } from './agents.js';
+export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, type TaskType, type CloudDispatchFn, } from './agents.js';
 export { type AgentType } from './parsers.js';
 export { normalizeEvents, normalizeEvent, parseEvent } from './parsers.js';
 export { handleSpawn, handleStatus, handleStop, handleTasks, type SpawnResult, type AgentStatusDetail, type TaskStatusResult, type StopResult, type TaskInfo, type TasksResult, } from './api.js';
-export { readConfig, resolveAgentsDir, resolveBaseDir, type EffortLevel, type ModelOverrides, type ProviderConfig, type AgentConfig, type SwarmConfig, type ReadConfigResult, } from './persistence.js';
+export { resolveAgentsDir, resolveBaseDir, } from './persistence.js';
+export { type EffortLevel } from './agents.js';
 export { collapseEvents, getToolBreakdown, groupAndFlattenEvents, summarizeEvents, getDelta, filterEventsByPriority, getLastTool, getToolUses, getLastMessages, getQuickStatus, getStatusSummary, AgentSummary, PRIORITY, type QuickStatus, } from './summarizer.js';
 export { extractFileOpsFromBash } from './file_ops.js';
 export { debug } from './debug.js';

package/dist/lib/teams/index.js

@@ -5,10 +5,10 @@
  * to reuse the same agent lifecycle, parsing, summarization, and persistence
  * layer that powers the `agents teams` CLI.
  */
-export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, AGENT_COMMANDS, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, } from './agents.js';
+export { AgentManager, AgentProcess, AgentStatus, VALID_TASK_TYPES, computePathLCA, checkAllClis, checkCliAvailable, ensureGeminiPlanMode, getAgentsDir, resolveMode, } from './agents.js';
 export { normalizeEvents, normalizeEvent, parseEvent } from './parsers.js';
 export { handleSpawn, handleStatus, handleStop, handleTasks, } from './api.js';
-export { readConfig, resolveAgentsDir, resolveBaseDir, } from './persistence.js';
+export { resolveAgentsDir, resolveBaseDir, } from './persistence.js';
 export { collapseEvents, getToolBreakdown, groupAndFlattenEvents, summarizeEvents, getDelta, filterEventsByPriority, getLastTool, getToolUses, getLastMessages, getQuickStatus, getStatusSummary, AgentSummary, PRIORITY, } from './summarizer.js';
 export { extractFileOpsFromBash } from './file_ops.js';
 export { debug } from './debug.js';

package/dist/lib/teams/persistence.d.ts

@@ -1,42 +1,4 @@
-import { AgentType } from './parsers.js';
 /** Resolve the base data directory for teams, preferring ~/.agents/teams/ with a temp fallback. */
 export declare function resolveBaseDir(): Promise<string>;
-/** Reasoning-intensity levels supported by the teams system. */
-export type EffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
-/**
- * Legacy type retained for config-file back-compat. Older configs pinned a
- * model per effort tier; we no longer act on these entries but accept them
- * without error when loading from disk.
- */
-export type ModelOverrides = Partial<Record<AgentType, Partial<Record<EffortLevel, string>>>>;
-/** API endpoint configuration for a model provider. */
-export interface ProviderConfig {
-    apiEndpoint: string | null;
-}
-/** Per-agent-type configuration: CLI command template, enabled state, optional pinned model, and provider. */
-export interface AgentConfig {
-    command: string;
-    enabled: boolean;
-    model: string | null;
-    provider: string;
-}
-/** Top-level teams configuration structure persisted to config.json. */
-export interface SwarmConfig {
-    agents: Record<AgentType, AgentConfig>;
-    providers: Record<string, ProviderConfig>;
-}
-/** Result of reading the teams config, including resolved agent and provider configurations. */
-export interface ReadConfigResult {
-    hasConfig: boolean;
-    enabledAgents: AgentType[];
-    agentConfigs: Record<AgentType, AgentConfig>;
-    providerConfigs: Record<string, ProviderConfig>;
-}
 /** Resolve and ensure the agents subdirectory exists under the teams base dir. */
 export declare function resolveAgentsDir(): Promise<string>;
-/** Read teams config from disk, migrating legacy formats if needed. Returns defaults when no config exists. */
-export declare function readConfig(): Promise<ReadConfigResult>;
-/** Write teams config to disk. */
-export declare function writeConfig(config: SwarmConfig): Promise<void>;
-/** Update the enabled/disabled status of a specific agent type in the config file. */
-export declare function setAgentEnabled(agentType: AgentType, enabled: boolean): Promise<void>;