@phnx-labs/agents-cli 1.20.49 → 1.20.51

package/dist/commands/teams.js

@@ -1,8 +1,9 @@
 import chalk from 'chalk';
+import { die, relTime, truncate, isJsonMode, padRight } from '../lib/format.js';
 import * as fs from 'fs/promises';
 import { addHostOption } from '../lib/hosts/option.js';
 import * as path from 'path';
-import { AgentManager, checkAllClis, checkCliSignedIn, getAgentsDir, resolveSignInAdvisory, VALID_TASK_TYPES, } from '../lib/teams/agents.js';
+import { AgentManager, checkCliSignedIn, collectTeamsDoctorData, getAgentsDir, VALID_TASK_TYPES, } from '../lib/teams/agents.js';
 import { resolveProvider } from '../lib/cloud/registry.js';
 import { runSupervisor } from '../lib/teams/supervisor.js';
 import { debug } from '../lib/teams/debug.js';
@@ -11,7 +12,15 @@ import { handleSpawn, handleStatus, handleStop, handleTasks, toTaskStatusSummary
 import { createTeam, ensureTeam, getTeam, loadTeams, removeTeam, teamExists, } from '../lib/teams/registry.js';
 import { setHelpSections } from '../lib/help.js';
 import { createWorktree, isGitRepo, hasUncommittedChanges, removeWorktree, } from '../lib/teams/worktree.js';
-import { isVersionInstalled, resolveVersion, resolveVersionAlias, resolveVersionAliasLoose, verifyInstalledBinaryLaunches } from '../lib/versions.js';
+import { resolveHost } from '../lib/hosts/registry.js';
+import { sshTargetFor } from '../lib/hosts/types.js';
+import { ensureHostReady } from '../lib/hosts/ready.js';
+import { remoteShellFor } from '../lib/hosts/remote-cmd.js';
+import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
+import { remoteWorktreeDirty, removeRemoteWorktree, ensureRemoteRepo } from '../lib/teams/remoteWorktree.js';
+import { getRemoteUrl } from '../lib/git.js';
+import { machineId } from '../lib/session/sync/config.js';
+import { isVersionInstalled, resolveVersionAlias, resolveVersionAliasLoose } from '../lib/versions.js';
 import { AGENTS, warnAgentDeprecated } from '../lib/agents.js';
 import { discoverSessions, parseTimeFilter, resolveSessionById } from '../lib/session/discover.js';
 import { renderSessionLog } from './sessions.js';
@@ -40,13 +49,6 @@ const VALID_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
 const VALID_CLOUD_PROVIDERS = ['rush', 'codex', 'factory'];
 // Auto-enable JSON mode when piped / not a TTY so AI agent consumers get
 // parseable output by default.
-function isJsonMode(opts) {
-    return Boolean(opts.json) || !process.stdout.isTTY;
-}
-function die(msg, code = 1) {
-    console.error(chalk.red(msg));
-    process.exit(code);
-}
 function statusColor(status) {
     switch (status) {
         case 'pending': return chalk.blue;
@@ -57,23 +59,6 @@ function statusColor(status) {
         default: return chalk.white;
     }
 }
-function relTime(iso) {
-    const secs = Math.floor((Date.now() - new Date(iso).getTime()) / 1000);
-    if (secs < 10)
-        return 'just now';
-    if (secs < 60)
-        return `${secs}s ago`;
-    if (secs < 3600)
-        return `${Math.floor(secs / 60)}m ago`;
-    if (secs < 86400)
-        return `${Math.floor(secs / 3600)}h ago`;
-    return `${Math.floor(secs / 86400)}d ago`;
-}
-function truncate(s, n) {
-    if (s.length <= n)
-        return s;
-    return s.slice(0, n - 1) + '…';
-}
 function compactPrompt(s, n = 160) {
     return truncate(s.replace(/\s+/g, ' ').trim(), n);
 }
@@ -90,9 +75,6 @@ function formatTimestamp(iso) {
         minute: '2-digit',
     });
 }
-function padRight(s, width) {
-    return s.length >= width ? s : s + ' '.repeat(width - s.length);
-}
 function fullName(type, version) {
     const name = AGENT_NAMES[type];
     return version ? `${name} ${version}` : name;
@@ -486,6 +468,9 @@ function printAgentDetail(a, session) {
     if (a.after && a.after.length) {
         console.log(`    ${chalk.gray('after   ')} ${a.after.join(', ')}`);
     }
+    if (a.host) {
+        console.log(`    ${chalk.gray('host    ')} ${chalk.cyan(a.host)}`);
+    }
     // If the agent's internal session id differs from ours (non-Claude), show
     // it as a hint for `agents sessions <id>`.
     if (a.remote_session_id && a.remote_session_id !== a.agent_id) {
@@ -569,7 +554,8 @@ function printAgentSummary(s) {
     const duration = s.duration ? `${chalk.gray(' · ')}${chalk.white(s.duration)}` : '';
     const errBadge = s.has_errors ? chalk.red(' !') : '';
     const tools = chalk.gray(` · ${s.tool_count} tools`);
-    console.log(`  ${chalk.cyan(handle.padEnd(14))} ${ident.padEnd(11)} ${label}${duration}${tools}${errBadge}`);
+    const hostBadge = s.host ? chalk.gray(' · on ') + chalk.cyan(s.host) : '';
+    console.log(`  ${chalk.cyan(handle.padEnd(14))} ${ident.padEnd(11)} ${label}${duration}${tools}${hostBadge}${errBadge}`);
     // Files: counts + basenames. Read is count only.
     const fileLines = [];
     const renderCat = (label, cat) => {
@@ -965,13 +951,55 @@ export function registerTeamsCommands(program) {
         .option('-d, --description <text>', 'One-line summary of what this team is working on')
         .option('--enable-worktrees', 'Each teammate works in its own git worktree (requires --worktree on add)')
         .option('--use-worktree <path>', 'All teammates share this existing worktree path (mutually exclusive with --enable-worktrees)')
+        .option('--devices <list>', 'Pool of machines this team may run teammates on (comma-separated). Enables distributed auto-scheduling.')
+        .option('--hosts <list>', 'Alias for --devices.')
+        .option('--repo <urlOrPath>', 'How each device gets the code (git URL to clone, or a path). Defaults to the local checkout origin.')
         .option('--json', 'Output machine-readable JSON')
         .action(async (team, opts) => {
         try {
+            // --devices / --hosts are aliases; commander can't express a two-name
+            // option that isn't a short flag, so merge them here. Split on comma,
+            // trim, drop blanks, dedupe (preserving first-seen order).
+            const rawPool = [opts.devices, opts.hosts].filter(Boolean).join(',');
+            const devices = [];
+            for (const d of rawPool.split(',').map((s) => s.trim()).filter(Boolean)) {
+                if (!devices.includes(d))
+                    devices.push(d);
+            }
+            // Validate every pooled device resolves + is POSIX (v1 remote monitor is
+            // POSIX-only). A device equal to the local machine is fine (runs local),
+            // so skip the resolve/POSIX check for it.
+            for (const name of devices) {
+                if (name.toLowerCase() === machineId())
+                    continue;
+                const host = await resolveHost(name);
+                if (!host) {
+                    die(`Couldn't resolve pool device "${name}". Register it with \`agents devices\`, ` +
+                        `enroll it with \`agents hosts add ${name}\`, or pass user@host.`);
+                }
+                if (remoteShellFor(host.os ?? resolveRemoteOsSync(host.name)) === 'powershell') {
+                    die(`Distributed teams on Windows device "${host.name}" are not supported yet — ` +
+                        `the teams remote monitor is POSIX-only. Use a Linux/macOS device.`);
+                }
+            }
+            // --repo: how each device gets the code. Default to the local checkout's
+            // origin when a pool is declared and we're inside a git repo, so the user
+            // never hand-manages a path per box. A poolless team leaves repo unset.
+            let repo = opts.repo;
+            if (!repo && devices.length > 0) {
+                const cwd = process.cwd();
+                if (await isGitRepo(cwd)) {
+                    const origin = await getRemoteUrl(cwd);
+                    if (origin)
+                        repo = origin;
+                }
+            }
             const meta = await createTeam(team, {
                 description: opts.description,
                 enableWorktrees: opts.enableWorktrees,
                 useWorktree: opts.useWorktree,
+                devices,
+                repo,
             });
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify({ team, ...meta }, null, 2));
@@ -984,6 +1012,10 @@ export function registerTeamsCommands(program) {
                 console.log(chalk.gray(`  worktrees: per-teammate`));
             if (meta.use_worktree)
                 console.log(chalk.gray(`  worktree: ${meta.use_worktree}`));
+            if (meta.devices && meta.devices.length)
+                console.log(chalk.gray(`  devices: ${meta.devices.join(', ')}`));
+            if (meta.repo)
+                console.log(chalk.gray(`  repo: ${meta.repo}`));
             console.log();
             console.log(chalk.gray('Add your first teammate:'));
             if (meta.enable_worktrees) {
@@ -1039,9 +1071,88 @@ export function registerTeamsCommands(program) {
                 die(`--cloud rush requires --repo <owner/repo>`);
             }
         }
+        // Auto-create the team if it doesn't exist yet (friendlier UX than erroring),
+        // then load its metadata — needed here for the distributed --repo (how each
+        // device gets the code) before we resolve a per-teammate --device pin.
+        await ensureTeam(team);
+        const teamMeta = await getTeam(team);
+        // `--device`/`--host` are aliases (addHostOption registers both). For `teams
+        // add` the passthrough special-cases them as PLACEMENT, not routing, so the
+        // local action reads them here. Reject a conflicting pair.
+        const explicitDevice = (() => {
+            const h = opts.host;
+            const d = opts.device;
+            if (h && d && h !== d) {
+                die('Conflicting --host/--device values — pass just one.');
+            }
+            return h ?? d ?? null;
+        })();
+        // Distributed teams: --device <name> PINS this teammate to a machine over
+        // SSH. Resolve + validate the placement here so a bad target fails at `add`
+        // time, not silently at launch. Persisted (hostName/hostTarget/repoPath) so
+        // startReady()/launchRemoteProcess dispatch over SSH. Unpinned teammates
+        // leave these null — the launch-time scheduler resolves the pool cascade.
+        let hostName = null;
+        let hostTarget = null;
+        let hostRepoPath = null;
+        if (explicitDevice && explicitDevice.toLowerCase() !== machineId()) {
+            if (cloudProviderId) {
+                die(`--device and --cloud are mutually exclusive (two different remote backends). Pick one.`);
+            }
+            const host = await resolveHost(explicitDevice);
+            if (!host) {
+                die(`Couldn't resolve --device "${explicitDevice}". Register it with \`agents devices\`, ` +
+                    `enroll it with \`agents hosts add ${explicitDevice}\`, or pass user@host.`);
+            }
+            // POSIX-only in v1: the remote follow/monitor layer offset-tails the log
+            // with tail/cat/kill, which don't exist under PowerShell. Refuse Windows
+            // up front, mirroring dispatch.ts launchDetached.
+            if (remoteShellFor(host.os ?? resolveRemoteOsSync(host.name)) === 'powershell') {
+                die(`Distributed teammates on Windows host "${host.name}" are not supported yet — ` +
+                    `the teams remote monitor is POSIX-only (offset-tails the remote log with tail/cat/kill). ` +
+                    `Use a Linux/macOS host, or run this teammate locally.`);
+            }
+            try {
+                hostTarget = sshTargetFor(host);
+            }
+            catch (err) {
+                die(`Can't resolve an ssh target for "${host.name}": ${err.message}`);
+            }
+            // Ensure agents-cli is present + version-matched on the host; surface
+            // (not fail on) an agent-not-installed warning, like the run --host path.
+            try {
+                const { warnings } = ensureHostReady(host, { agent: parseTeammate(teammate).agent });
+                for (const w of warnings)
+                    process.stderr.write(chalk.yellow(`[teams] warning: ${w}\n`));
+            }
+            catch (err) {
+                die(`Host "${host.name}" is not ready: ${err.message}`);
+            }
+            // Provision the repo on the host from the team's --repo (clone into
+            // ~/.agents/repos/<team> or reuse an existing checkout), resolving to the
+            // ABSOLUTE git root so every later remote command works from an absolute
+            // path (dispatch `cd`, worktree create, polling). When the team has no
+            // --repo (the common "just send one teammate elsewhere" case, created
+            // without a pool), fall back to THIS checkout's origin so the headline case
+            // works with zero extra flags whenever you run `add` inside a git repo.
+            let effectiveRepo = teamMeta?.repo ?? '';
+            if (!effectiveRepo && (await isGitRepo(process.cwd()))) {
+                effectiveRepo = (await getRemoteUrl(process.cwd())) ?? '';
+            }
+            try {
+                hostRepoPath = ensureRemoteRepo(hostTarget, effectiveRepo, team);
+            }
+            catch (err) {
+                die(`Couldn't provision the repo on "${host.name}": ${err.message}\n` +
+                    `  Set how each device gets the code with: agents teams create ${team} --repo <url|path>`);
+            }
+            hostName = host.name;
+        }
         const { agent, version, profileName } = parseTeammate(teammate);
         warnAgentDeprecated(agent);
-        if (version && !isVersionInstalled(agent, version)) {
+        // Version-installed check is about the LOCAL machine — a distributed (--on)
+        // teammate's agent/version lives on the host, verified by ensureHostReady.
+        if (version && !hostName && !isVersionInstalled(agent, version)) {
             die(`${AGENT_NAMES[agent]} ${version} isn't installed.\n` +
                 `  Install it:  agents add ${agent}@${version}\n` +
                 `  Or see what's installed (incl. @latest):  agents view ${agent}`);
@@ -1049,7 +1160,8 @@ export function registerTeamsCommands(program) {
         // Advisory sign-in check: warn but NEVER block. Detection is unreliable
         // for opaque-cred agents, so a false negative must not stop a team. Cloud
         // dispatch authenticates through the provider, not the local CLI — skip it.
-        if (!opts.force && !cloudProviderId && !(await checkCliSignedIn(agent))) {
+        // Distributed (--on) teammates authenticate on the host, not locally — skip.
+        if (!opts.force && !cloudProviderId && !hostName && !(await checkCliSignedIn(agent))) {
             console.error(chalk.yellow(`⚠ ${AGENT_NAMES[agent]} may not be signed in (detection is unreliable). Adding anyway.`) +
                 chalk.gray(`\n  If it fails to start, run \`${AGENTS[agent].cliCommand}\` to log in, or pass --force to silence this.`));
         }
@@ -1058,7 +1170,7 @@ export function registerTeamsCommands(program) {
         // out-of-credits / signed-out account (see throttleWarningLine). Skip bare
         // targets (rotation handles them), profiles (auth-injected account isn't
         // the version-home one we can read), and cloud dispatch. Warn, never block.
-        if (!opts.force && !cloudProviderId && !profileName && version) {
+        if (!opts.force && !cloudProviderId && !hostName && !profileName && version) {
             const readiness = await checkRunAccountReadiness(agent, version);
             if (!readiness.ready)
                 console.error(throttleWarningLine(agent, version, readiness));
@@ -1086,15 +1198,34 @@ export function registerTeamsCommands(program) {
         catch (err) {
             die(err.message);
         }
-        // Auto-create the team if it doesn't exist yet (friendlier UX than erroring).
-        await ensureTeam(team);
-        // Check if team has worktrees enabled or a shared worktree
-        const teamMeta = await getTeam(team);
+        // Team already ensured + loaded above (teamMeta) for the --repo provisioning.
         const worktreesEnabled = teamMeta?.enable_worktrees ?? false;
         const sharedWorktree = teamMeta?.use_worktree ?? null;
         let worktreeName = null;
         let worktreePath = null;
-        if (sharedWorktree) {
+        if (hostName) {
+            // Distributed teammate: the checkout lives on the host, so we NEVER touch
+            // the local filesystem here. A shared local worktree makes no sense for a
+            // remote teammate; a per-teammate worktree is created ON THE HOST at launch
+            // (createRemoteWorktree in launchRemoteProcess) — we just capture its name.
+            if (sharedWorktree) {
+                die(`Team '${team}' uses a shared local --use-worktree, which can't apply to a --device (remote) teammate.`);
+            }
+            if (worktreesEnabled) {
+                if (!opts.worktree) {
+                    die(`Team '${team}' has worktrees enabled. Use --worktree <name> for the remote teammate (created on ${hostName}).`);
+                }
+                if (!opts.name) {
+                    die(`Team '${team}' has worktrees enabled. Use --name <name> to identify this teammate.`);
+                }
+                worktreeName = opts.worktree;
+            }
+            else if (opts.worktree) {
+                die(`--worktree requires --enable-worktrees on the team. Recreate the team with: agents teams create ${team} --enable-worktrees`);
+            }
+            // Local cwd stays null — the remote cwd is repoPath / the remote worktree.
+        }
+        else if (sharedWorktree) {
             // Team uses a shared worktree for all teammates
             const fsp = await import('fs/promises');
             try {
@@ -1133,7 +1264,10 @@ export function registerTeamsCommands(program) {
         else if (opts.worktree) {
             die(`--worktree requires --enable-worktrees on the team. Recreate the team with: agents teams create ${team} --enable-worktrees`);
         }
-        const cwd = worktreePath ?? opts.cwd ?? process.cwd();
+        // Distributed teammates have no LOCAL cwd — their working dir lives on the
+        // host (repoPath / the remote worktree). Local teammates default to the
+        // worktree path, then --cwd, then the current directory.
+        const cwd = hostName ? null : (worktreePath ?? opts.cwd ?? process.cwd());
         const mgr = mkManager();
         // Factory teammates: prepend the worker-skill preamble to every task
         // prompt so implementers/testers/reviewers know about the Ledger, the
@@ -1182,7 +1316,7 @@ export function registerTeamsCommands(program) {
             }
         }
         try {
-            const result = await handleSpawn(mgr, team, agent, effectiveTask, cwd, opts.mode, opts.effort, null, cwd, version, opts.name ?? null, after, opts.model ?? null, envOverrides ?? null, taskType, cloudProviderId, cloudSessionId, opts.repo ?? null, opts.branch ?? null, worktreeName, worktreePath, profileName);
+            const result = await handleSpawn(mgr, team, agent, effectiveTask, cwd, opts.mode, opts.effort, null, cwd, version, opts.name ?? null, after, opts.model ?? null, envOverrides ?? null, taskType, cloudProviderId, cloudSessionId, opts.repo ?? null, opts.branch ?? null, worktreeName, worktreePath, profileName, hostName, hostTarget, hostRepoPath);
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify(result, null, 2));
                 return;
@@ -1200,7 +1334,10 @@ export function registerTeamsCommands(program) {
             console.log(`  ${chalk.gray('agent_id')}  ${chalk.cyan(shortId(result.agent_id))} ${chalk.gray(`(${result.agent_id})`)}`);
             console.log(`  ${chalk.gray('status  ')}  ${statusColor(result.status)(result.status)}`);
             console.log(`  ${chalk.gray('mode    ')}  ${opts.mode}`);
-            console.log(`  ${chalk.gray('working ')}  ${cwd}`);
+            console.log(`  ${chalk.gray('working ')}  ${hostName ? hostRepoPath : cwd}`);
+            if (hostName) {
+                console.log(`  ${chalk.gray('host    ')}  ${chalk.cyan(hostName)}${chalk.gray(` (${hostTarget})`)}`);
+            }
             if (worktreeName) {
                 console.log(`  ${chalk.gray('worktree')}  ${chalk.cyan(worktreeName)}`);
             }
@@ -1300,6 +1437,7 @@ export function registerTeamsCommands(program) {
                     started_at: a.startedAt.toISOString(),
                     cwd: a.cwd,
                     version: a.version,
+                    host: a.hostName,
                 })) }, null, 2));
             return;
         }
@@ -1317,7 +1455,10 @@ export function registerTeamsCommands(program) {
             console.log(chalk.bold(`Team ${chalk.cyan(team)}  ${chalk.gray(`(${agents.length} working)`)}`));
             for (const a of agents) {
                 const ident = a.name || shortId(a.agentId);
-                const pidStr = a.pid ? chalk.yellow(`pid ${a.pid}`) : chalk.gray('pid ?');
+                // A distributed teammate has no local pid; show its host + remote pid.
+                const pidStr = a.hostName
+                    ? chalk.cyan(`on ${a.hostName}`) + (a.remotePid ? chalk.gray(` (pid ${a.remotePid})`) : '')
+                    : a.pid ? chalk.yellow(`pid ${a.pid}`) : chalk.gray('pid ?');
                 const started = chalk.gray(relTime(a.startedAt.toISOString()));
                 console.log(`  ${chalk.magenta(padRight(fullName(a.agentType, a.version), 18))}  ${chalk.white(padRight(ident, 20))}  ${pidStr}  ${started}`);
             }
@@ -1544,13 +1685,24 @@ export function registerTeamsCommands(program) {
         let worktreeKept = false;
         if (agent?.worktreeName && agent?.worktreePath) {
             try {
-                const dirty = await hasUncommittedChanges(agent.worktreePath);
-                if (dirty) {
-                    worktreeKept = true;
+                if (agent.hostName && agent.hostTarget && agent.repoPath) {
+                    // Distributed teammate: guard + remove the worktree ON THE HOST.
+                    if (remoteWorktreeDirty(agent.hostTarget, agent.worktreePath)) {
+                        worktreeKept = true;
+                    }
+                    else {
+                        removeRemoteWorktree(agent.hostTarget, agent.repoPath, agent.worktreeName);
+                    }
                 }
                 else {
-                    const baseCwd = process.cwd();
-                    await removeWorktree(baseCwd, agent.worktreeName);
+                    const dirty = await hasUncommittedChanges(agent.worktreePath);
+                    if (dirty) {
+                        worktreeKept = true;
+                    }
+                    else {
+                        const baseCwd = process.cwd();
+                        await removeWorktree(baseCwd, agent.worktreeName);
+                    }
                 }
             }
             catch {
@@ -1667,12 +1819,23 @@ export function registerTeamsCommands(program) {
             const agent = await mgr.get(a.agent_id);
             if (agent?.worktreeName && agent?.worktreePath) {
                 try {
-                    const dirty = await hasUncommittedChanges(agent.worktreePath);
-                    if (dirty) {
-                        keptWorktrees.push(agent.worktreeName);
+                    if (agent.hostName && agent.hostTarget && agent.repoPath) {
+                        // Distributed teammate: guard + remove the worktree ON THE HOST.
+                        if (remoteWorktreeDirty(agent.hostTarget, agent.worktreePath)) {
+                            keptWorktrees.push(agent.worktreeName);
+                        }
+                        else {
+                            removeRemoteWorktree(agent.hostTarget, agent.repoPath, agent.worktreeName);
+                        }
                     }
                     else {
-                        await removeWorktree(baseCwd, agent.worktreeName);
+                        const dirty = await hasUncommittedChanges(agent.worktreePath);
+                        if (dirty) {
+                            keptWorktrees.push(agent.worktreeName);
+                        }
+                        else {
+                            await removeWorktree(baseCwd, agent.worktreeName);
+                        }
                     }
                 }
                 catch { /* best-effort */ }
@@ -1778,58 +1941,16 @@ export function registerTeamsCommands(program) {
         .description('Check which agents are installed and available to join a team. Verifies CLI paths and shows an advisory sign-in hint.')
         .option('--json', 'Output machine-readable JSON')
         .action(async (opts) => {
-        const info = checkAllClis();
-        // Deep integrity probe. `checkAllClis` reports presence (shim + stub guard),
-        // but a GUTTED native binary (JS wrapper present, platform binary missing —
-        // the codex/kimi optional-dep partial-extract failure) still passes that. So
-        // actually launch the resolved default version and, if it won't run, flip the
-        // agent to not-installed with a repair hint — otherwise doctor says "ready"
-        // and the teammate ENOENTs at spawn. Parallel; win32 is treated as healthy by
-        // verifyInstalledBinaryLaunches.
-        await Promise.all(Object.entries(info).map(async ([name, entry]) => {
-            if (!entry.installed)
-                return;
-            const agent = name;
-            const version = resolveVersion(agent);
-            if (!version)
-                return;
-            const health = await verifyInstalledBinaryLaunches(agent, version);
-            if (!health.ok) {
-                entry.installed = false;
-                entry.path = null;
-                entry.error = `${AGENTS[agent]?.cliCommand ?? name}@${version} is installed but its binary won't launch`
-                    + `${health.detail ? ` (${health.detail})` : ''}. Repair: agents add ${agent}@${version}`;
-            }
-        }));
-        // Advisory enrichment only. Sign-in detection is UNRELIABLE, so it never
-        // changes the authoritative installed/ready column — it annotates. And an
-        // agent that is actually running in a team is treated as signed in
-        // regardless of the probe, so doctor never reports a working agent as
-        // logged out ("don't show wrong stuff").
-        const running = new Set();
-        try {
-            for (const a of await mkManager().listRunning())
-                running.add(a.agentType);
-        }
-        catch { /* no teams yet — leave running empty */ }
-        const auth = {};
-        await Promise.all(Object.entries(info).map(async ([name, entry]) => {
-            const isRunning = running.has(name);
-            const probe = entry.installed && !isRunning ? await checkCliSignedIn(name) : false;
-            auth[name] = resolveSignInAdvisory(entry.installed, isRunning, probe);
-        }));
+        const data = await collectTeamsDoctorData();
         if (isJsonMode(opts)) {
-            const merged = {};
-            for (const [name, entry] of Object.entries(info))
-                merged[name] = { ...entry, ...auth[name] };
-            console.log(JSON.stringify(merged, null, 2));
+            console.log(JSON.stringify(data, null, 2));
             return;
         }
         console.log(chalk.bold('Who can join a team:'));
-        for (const [name, entry] of Object.entries(info)) {
+        for (const [name, entry] of Object.entries(data)) {
             const pretty = AGENT_NAMES[name] || name;
             if (entry.installed) {
-                const { signedIn, running: isRunning } = auth[name];
+                const { signedIn, running: isRunning } = entry;
                 const hint = isRunning
                     ? chalk.gray('in use')
                     : signedIn

package/dist/commands/tmux.js

@@ -21,6 +21,7 @@
  *   agents tmux kill-all       [--yes]
  */
 import chalk from 'chalk';
+import { truncate } from '../lib/format.js';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
 import { assertTmuxAvailable, attachTmux, capturePane, createSession, getDefaultSocketPath, getTmuxVersion, hasSession, isTmuxInstalled, killAll, killSession, listSessions, readSessionMeta, sendKeys, splitPane, TmuxCommandError, TmuxSessionError, TmuxUnavailableError, } from '../lib/tmux/index.js';
@@ -395,9 +396,6 @@ function formatAge(secs) {
     const h = Math.floor(m / 60);
     return `${h}h ${m % 60}m`;
 }
-function truncate(s, n) {
-    return s.length > n ? `${s.slice(0, n - 1)}…` : s;
-}
 function printMeta(m) {
     console.log(`  ${chalk.bold('name')}       ${m.name}`);
     console.log(`  ${chalk.bold('socket')}     ${m.socket}`);

package/dist/commands/view.js

@@ -1,5 +1,6 @@
 import { addHostOption } from '../lib/hosts/option.js';
 import chalk from 'chalk';
+import { visibleWidth, termLink } from '../lib/format.js';
 import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -67,12 +68,6 @@ function profileKindAndModel(model, planWidth) {
     const kind = 'profile'.padEnd(Math.max(planWidth, 'profile'.length));
     return `${kind}  ${model}`;
 }
-function termLink(text, filePath) {
-    if (!process.stdout.isTTY)
-        return text;
-    const url = `file://${filePath}`;
-    return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
-}
 /**
  * Resolve a resource path to something the IDE can open inline. When `p` is a
  * directory, OSC 8 file:// links cause IDEs (Cursor/VS Code) to open it as a
@@ -112,9 +107,6 @@ function formatLastActive(date) {
         return chalk.gray(`${days}d ago`);
     return chalk.gray(`${days}d ago`);
 }
-function visibleWidth(s) {
-    return s.replace(/\u001b\[[0-9;]*m/g, '').length;
-}
 function compareVersions(a, b) {
     const partsA = a.split('.').map(Number);
     const partsB = b.split('.').map(Number);

package/dist/commands/worktree.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { die } from '../lib/format.js';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as fs from 'fs/promises';
@@ -8,10 +9,6 @@ import { setHelpSections } from '../lib/help.js';
 const execFileAsync = promisify(execFile);
 const WORKTREE_SUBDIR = path.join('.agents', 'worktrees');
 const BRANCH_PREFIX = 'agents/';
-function die(msg, code = 1) {
-    console.error(chalk.red(msg));
-    process.exit(code);
-}
 function isValidTerminalId(id) {
     // Allow letters, digits, dot, dash, underscore. Reject anything else so a
     // hostile or buggy caller can't inject path traversal or shell metachars.

package/dist/lib/agents.d.ts

@@ -52,8 +52,6 @@ export declare function getCliPath(agentId: AgentId): Promise<string | null>;
 export declare function getCliState(agentId: AgentId): Promise<CliState>;
 /** Resolve CLI state for all registered agents in parallel. */
 export declare function getAllCliStates(): Promise<Partial<Record<AgentId, CliState>>>;
-/** Check whether the agent's config directory exists on disk. */
-export declare function isConfigured(agentId: AgentId): boolean;
 /** Info about an existing unmanaged agent installation. */
 export interface UnmanagedInstall {
     agentId: AgentId;
@@ -128,8 +126,6 @@ export declare function resolveLastActive(agentId: AgentId, base: string, config
  * Used during init to show approximate session count to user.
  */
 export declare function countSessionFiles(agentId: AgentId): number;
-/** Check whether a named MCP server is registered with the agent's CLI. */
-export declare function isMcpRegistered(agentId: AgentId, mcpName: string): Promise<boolean>;
 /** Register an MCP server with an agent's CLI via `mcp add`. */
 export declare function registerMcp(agentId: AgentId, name: string, command: string, scope?: 'user' | 'project', transport?: string, options?: {
     home?: string;