@phnx-labs/agents-cli 1.20.78 → 1.20.82

package/dist/commands/teams.js

@@ -12,7 +12,7 @@ import { shareRuntimeEnv } from '../lib/share/config.js';
 import { runSupervisor } from '../lib/teams/supervisor.js';
 import { debug } from '../lib/teams/debug.js';
 import { runPrWatch, DEFAULT_MAX_WAVES, } from '../lib/teams/pr-watch.js';
-import { handleSpawn, handleStatus, handleStop, handleTasks, toTaskStatusSummary, } from '../lib/teams/api.js';
+import { handleSpawn, handleStatus, handleStop, toTaskStatusSummary, } from '../lib/teams/api.js';
 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';
@@ -46,7 +46,7 @@ const AGENT_NAMES = {
     kimi: 'Kimi',
     droid: 'Droid',
 };
-const VALID_AGENTS = Object.keys(AGENT_NAMES);
+const VALID_AGENTS = ['claude', 'codex', 'cursor', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
 // 'full' kept as historical alias for 'skip'; normalized to 'skip' downstream.
 const VALID_MODES = ['plan', 'edit', 'auto', 'skip', 'full'];
 const VALID_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'auto'];
@@ -77,6 +77,75 @@ function formatTimestamp(iso) {
         minute: '2-digit',
     });
 }
+function normalizeTeamListStatus(status) {
+    if (Object.values(AgentStatus).includes(status)) {
+        return status;
+    }
+    return AgentStatus.RUNNING;
+}
+function parseTimestamp(value) {
+    if (!value)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function durationFromSnapshot(agent) {
+    const startedAt = parseTimestamp(agent.started_at);
+    if (!startedAt)
+        return null;
+    const completedAt = parseTimestamp(agent.completed_at);
+    let seconds;
+    if (completedAt) {
+        seconds = (completedAt.getTime() - startedAt.getTime()) / 1000;
+    }
+    else if (normalizeTeamListStatus(agent.status) === AgentStatus.RUNNING) {
+        seconds = (Date.now() - startedAt.getTime()) / 1000;
+    }
+    else {
+        return null;
+    }
+    if (seconds < 60)
+        return `${Math.max(0, Math.floor(seconds))} seconds`;
+    return `${Math.max(0, seconds / 60).toFixed(1)} minutes`;
+}
+function snapshotActivityTime(agent) {
+    const status = normalizeTeamListStatus(agent.status);
+    if (status === AgentStatus.RUNNING)
+        return new Date();
+    return parseTimestamp(agent.completed_at) || parseTimestamp(agent.started_at) || new Date(0);
+}
+function snapshotToStatusDetail(agent) {
+    return {
+        agent_id: agent.agent_id,
+        agent_type: agent.agent_type,
+        status: normalizeTeamListStatus(agent.status),
+        prompt: agent.prompt,
+        started_at: parseTimestamp(agent.started_at)?.toISOString() || new Date(0).toISOString(),
+        completed_at: parseTimestamp(agent.completed_at)?.toISOString() || null,
+        duration: durationFromSnapshot(agent),
+        files_created: [],
+        files_modified: [],
+        files_read: [],
+        files_deleted: [],
+        bash_commands: [],
+        recent_tool_calls: [],
+        last_messages: [],
+        tool_count: 0,
+        has_errors: false,
+        cursor: snapshotActivityTime(agent).toISOString(),
+        mode: agent.mode ?? undefined,
+        cloud_session_id: agent.cloud_session_id,
+        cloud_provider: agent.cloud_provider,
+        pr_url: agent.pr_url,
+        version: agent.version,
+        remote_session_id: agent.remote_session_id,
+        session_label: null,
+        name: agent.name,
+        after: agent.after,
+        task_type: agent.task_type,
+        host: agent.host,
+    };
+}
 function fullName(type, version) {
     const name = AGENT_NAMES[type];
     return version ? `${name} ${version}` : name;
@@ -714,23 +783,132 @@ function mergeTeams(registry, tasks) {
     }
     return Array.from(byName.values()).sort((a, b) => new Date(b.modified_at).getTime() - new Date(a.modified_at).getTime());
 }
-// Build the same enriched rows the `list` picker uses. Shared between `list`
-// (interactive default) and the picker fallback for `status` / `start`.
-async function loadTeamRows(mgr) {
-    const [tasks, registry] = await Promise.all([handleTasks(mgr, 1000), loadTeams()]);
-    const merged = mergeTeams(registry, tasks.tasks);
-    const rows = await Promise.all(merged.map(async (team) => {
-        let agents = [];
+function buildTasksFromSnapshots(agents) {
+    const byTeam = new Map();
+    for (const agent of agents) {
+        const teamAgents = byTeam.get(agent.task_name) || [];
+        teamAgents.push(agent);
+        byTeam.set(agent.task_name, teamAgents);
+    }
+    const tasks = [];
+    for (const [taskName, teamAgents] of byTeam) {
+        let pending = 0;
+        let running = 0;
+        let completed = 0;
+        let failed = 0;
+        let stopped = 0;
+        let earliestStart = null;
+        let latestActivity = null;
+        let workspaceDir = null;
+        for (const agent of teamAgents) {
+            const status = normalizeTeamListStatus(agent.status);
+            if (status === AgentStatus.PENDING)
+                pending++;
+            else if (status === AgentStatus.RUNNING)
+                running++;
+            else if (status === AgentStatus.COMPLETED)
+                completed++;
+            else if (status === AgentStatus.FAILED)
+                failed++;
+            else if (status === AgentStatus.STOPPED)
+                stopped++;
+            const startedAt = parseTimestamp(agent.started_at);
+            if (startedAt && (!earliestStart || startedAt < earliestStart)) {
+                earliestStart = startedAt;
+            }
+            const activity = snapshotActivityTime(agent);
+            if (!latestActivity || activity > latestActivity) {
+                latestActivity = activity;
+            }
+            if (!workspaceDir && agent.workspace_dir) {
+                workspaceDir = agent.workspace_dir;
+            }
+        }
+        const fallback = new Date(0);
+        tasks.push({
+            task_name: taskName,
+            agent_count: teamAgents.length,
+            pending,
+            running,
+            completed,
+            failed,
+            stopped,
+            workspace_dir: workspaceDir,
+            created_at: (earliestStart || fallback).toISOString(),
+            modified_at: (latestActivity || earliestStart || fallback).toISOString(),
+        });
+    }
+    return tasks.sort((a, b) => new Date(b.modified_at).getTime() - new Date(a.modified_at).getTime());
+}
+export function buildTeamRowsFromSnapshots(registry, agents) {
+    const byTeam = new Map();
+    for (const agent of agents) {
+        const details = byTeam.get(agent.task_name) || [];
+        details.push(snapshotToStatusDetail(agent));
+        byTeam.set(agent.task_name, details);
+    }
+    const teams = mergeTeams(registry, buildTasksFromSnapshots(agents));
+    return {
+        teams,
+        rows: teams.map((team) => ({
+            team,
+            agents: byTeam.get(team.task_name) || [],
+            description: registry[team.task_name]?.description,
+        })),
+        names: teams.map((team) => team.task_name),
+    };
+}
+function snapshotFromMeta(meta) {
+    if (!meta || typeof meta !== 'object')
+        return null;
+    const agentId = typeof meta.agent_id === 'string' ? meta.agent_id : '';
+    const taskName = typeof meta.task_name === 'string' ? meta.task_name : '';
+    const agentType = typeof meta.agent_type === 'string' ? meta.agent_type : '';
+    if (!agentId || !taskName || !agentType)
+        return null;
+    return {
+        agent_id: agentId,
+        task_name: taskName,
+        agent_type: agentType,
+        status: normalizeTeamListStatus(meta.status),
+        prompt: typeof meta.prompt === 'string' ? meta.prompt : '',
+        started_at: parseTimestamp(meta.started_at)?.toISOString() || new Date(0).toISOString(),
+        completed_at: parseTimestamp(meta.completed_at)?.toISOString() || null,
+        workspace_dir: typeof meta.workspace_dir === 'string' ? meta.workspace_dir : null,
+        version: typeof meta.version === 'string' ? meta.version : null,
+        remote_session_id: typeof meta.remote_session_id === 'string' ? meta.remote_session_id : null,
+        name: typeof meta.name === 'string' ? meta.name : null,
+        after: Array.isArray(meta.after) ? meta.after.filter((name) => typeof name === 'string') : [],
+        task_type: typeof meta.task_type === 'string' && VALID_TASK_TYPES.includes(meta.task_type)
+            ? meta.task_type
+            : null,
+        host: typeof meta.host_name === 'string' ? meta.host_name : null,
+        mode: typeof meta.mode === 'string' ? meta.mode : null,
+        cloud_session_id: typeof meta.cloud_session_id === 'string' ? meta.cloud_session_id : null,
+        cloud_provider: typeof meta.cloud_provider === 'string' ? meta.cloud_provider : null,
+        pr_url: typeof meta.pr_url === 'string' ? meta.pr_url : null,
+    };
+}
+async function loadTeamAgentSnapshots() {
+    const agentsDir = await getAgentsDir();
+    const entries = await fs.readdir(agentsDir).catch(() => []);
+    const snapshots = await Promise.all(entries.map(async (entry) => {
+        const metaPath = path.join(agentsDir, entry, 'meta.json');
         try {
-            const res = await handleStatus(mgr, team.task_name, 'all');
-            agents = res.agents;
+            const raw = await fs.readFile(metaPath, 'utf-8');
+            return snapshotFromMeta(JSON.parse(raw));
         }
         catch {
-            // Empty teams (no live agents) throw in some code paths.
+            return null;
         }
-        return { team, agents, description: registry[team.task_name]?.description };
     }));
-    return { rows, names: merged.map((t) => t.task_name) };
+    return snapshots.filter((snapshot) => snapshot !== null);
+}
+// Build cached rows for the `list` picker. Shared between `list` and picker
+// fallbacks for `status` / `start`; full status stays lazy until a team is picked.
+async function loadTeamRows(_mgr) {
+    const [registry, agents] = await Promise.all([loadTeams(), loadTeamAgentSnapshots()]);
+    return buildTeamRowsFromSnapshots(registry, agents);
 }
 // Picker fallback for `teams logs` when the teammate ref is omitted. Shows a
 // flat list of every teammate with their team context; Enter picks one.
@@ -900,25 +1078,23 @@ export function registerTeamsCommands(program) {
         .option('-n, --limit <n>', 'Show at most this many teams (default: 20)', '20')
         .option('--json', 'Output machine-readable JSON instead of formatted table')
         .action(async (query, opts) => {
-        const mgr = mkManager();
         const limit = Math.max(1, parseInt(opts.limit, 10) || 20);
-        const [tasks, registry, everyAgent] = await Promise.all([
-            handleTasks(mgr, 1000),
+        const [registry, everyAgent] = await Promise.all([
             loadTeams(),
-            mgr.listAll(),
+            loadTeamAgentSnapshots(),
         ]);
         // Group agents by team so we can filter on agent-type / version.
         const byTeam = new Map();
         for (const a of everyAgent) {
-            const arr = byTeam.get(a.taskName) || [];
-            arr.push({ agent_type: a.agentType, version: a.version });
-            byTeam.set(a.taskName, arr);
+            const arr = byTeam.get(a.task_name) || [];
+            arr.push(a);
+            byTeam.set(a.task_name, arr);
         }
-        let merged = mergeTeams(registry, tasks.tasks);
+        let rows = buildTeamRowsFromSnapshots(registry, everyAgent).rows;
         // --- query: substring match on team name ---
         if (query) {
             const q = query.toLowerCase();
-            merged = merged.filter((t) => t.task_name.toLowerCase().includes(q));
+            rows = rows.filter((row) => row.team.task_name.toLowerCase().includes(q));
         }
         // --- --agent: filter teams containing a matching teammate ---
         if (opts.agent) {
@@ -926,8 +1102,8 @@ export function registerTeamsCommands(program) {
             const wantVersion = VALID_AGENTS.includes(wantType)
                 ? resolveVersionAliasLoose(wantType, rawVersion)
                 : rawVersion;
-            merged = merged.filter((t) => {
-                const teammates = byTeam.get(t.task_name) || [];
+            rows = rows.filter((row) => {
+                const teammates = byTeam.get(row.team.task_name) || [];
                 return teammates.some((m) => m.agent_type === wantType && (!wantVersion || m.version === wantVersion));
             });
         }
@@ -938,27 +1114,27 @@ export function registerTeamsCommands(program) {
             if (!validStatuses.includes(want)) {
                 die(`Invalid --status '${opts.status}'. Use one of: ${validStatuses.join(', ')}`);
             }
-            merged = merged.filter((t) => classifyTeamStatus(t) === want);
+            rows = rows.filter((row) => classifyTeamStatus(row.team) === want);
         }
         // --- --since / --until: filter by activity window ---
         if (opts.since) {
             const cutoff = parseTimeFilter(opts.since);
             if (!cutoff)
                 die(`Could not parse --since '${opts.since}'`);
-            merged = merged.filter((t) => new Date(t.modified_at).getTime() >= cutoff);
+            rows = rows.filter((row) => new Date(row.team.modified_at).getTime() >= cutoff);
         }
         if (opts.until) {
             const cutoff = parseTimeFilter(opts.until);
             if (!cutoff)
                 die(`Could not parse --until '${opts.until}'`);
-            merged = merged.filter((t) => new Date(t.modified_at).getTime() <= cutoff);
+            rows = rows.filter((row) => new Date(row.team.modified_at).getTime() <= cutoff);
         }
-        merged = merged.slice(0, limit);
+        rows = rows.slice(0, limit);
         if (isJsonMode(opts)) {
-            console.log(JSON.stringify({ teams: merged }, null, 2));
+            console.log(JSON.stringify({ teams: rows.map((row) => row.team) }, null, 2));
             return;
         }
-        if (merged.length === 0) {
+        if (rows.length === 0) {
             if (query || opts.agent || opts.status || opts.since || opts.until) {
                 console.log(chalk.gray('No teams match those filters.'));
             }
@@ -968,24 +1144,12 @@ export function registerTeamsCommands(program) {
             }
             return;
         }
-        // Enrich teams with teammate details for the picker's preview pane.
-        const rows = await Promise.all(merged.map(async (team) => {
-            let agents = [];
-            try {
-                const res = await handleStatus(mgr, team.task_name, 'all');
-                agents = res.agents;
-            }
-            catch {
-                // Empty teams (no live agents) throw in some code paths — preview
-                // will just show "no teammates yet".
-            }
-            return { team, agents, description: registry[team.task_name]?.description };
-        }));
         if (isInteractiveTerminal()) {
             try {
                 const picked = await teamPicker(rows, query);
                 if (picked) {
                     // Fall through to the status subcommand's action for the picked team.
+                    const mgr = mkManager();
                     const result = await handleStatus(mgr, picked.team, 'all');
                     await printTeamStatus(picked.team, result);
                 }

package/dist/commands/versions.js

@@ -4,7 +4,7 @@ import ora from 'ora';
 import * as fs from 'fs';
 import * as path from 'path';
 import { select, confirm, checkbox } from '@inquirer/prompts';
-import { AGENTS, ALL_AGENT_IDS, accountOrgBadge, getAccountEmail, getAccountInfo, agentLabel, warnAgentDeprecated, isSelfUpdatingAgent, } from '../lib/agents.js';
+import { AGENTS, MANAGED_AGENT_IDS, accountOrgBadge, getAccountEmail, getAccountInfo, agentLabel, warnAgentDeprecated, isAgentHardDeprecated, hardDeprecationError, isSelfUpdatingAgent, } from '../lib/agents.js';
 import { formatUsageSummary, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { viewAction } from './view.js';
 import { resolveConfiguredModel, formatAgentIdentity } from '../lib/models.js';
@@ -128,7 +128,7 @@ async function versionPruneAction(specs, options, commandName) {
         const parsed = parseAgentSpec(spec);
         if (!parsed) {
             console.log(chalk.red(`Invalid agent: ${spec}`));
-            console.log(chalk.gray(`Format: <agent>[@version]. Available: ${ALL_AGENT_IDS.join(', ')}`));
+            console.log(chalk.gray(`Format: <agent>[@version]. Available: ${MANAGED_AGENT_IDS.join(', ')}`));
             continue;
         }
         const { agent, version } = parsed;
@@ -333,11 +333,16 @@ export function registerVersionsCommands(program) {
             const parsed = parseAgentSpec(spec);
             if (!parsed) {
                 console.log(chalk.red(`Invalid agent: ${spec}`));
-                console.log(chalk.gray(`Format: <agent>[@version]. Available: ${ALL_AGENT_IDS.join(', ')}`));
+                console.log(chalk.gray(`Format: <agent>[@version]. Available: ${MANAGED_AGENT_IDS.join(', ')}`));
                 continue;
             }
             const { agent, version } = parsed;
             const agentConfig = AGENTS[agent];
+            if (isAgentHardDeprecated(agent)) {
+                console.error(chalk.red(hardDeprecationError(agent)));
+                process.exitCode = 1;
+                continue;
+            }
             warnAgentDeprecated(agent);
             // Isolation relies on a config-dir env var to redirect the copy away
             // from the user's real ~/.<agent>. Agents without one isolate only by
@@ -631,7 +636,7 @@ export function registerVersionsCommands(program) {
                 const parsed = parseAgentSpec(agentArg);
                 if (!parsed) {
                     console.log(chalk.red(`Invalid agent: ${agentArg}`));
-                    console.log(chalk.gray(`Format: <agent>[@version]. Available: ${ALL_AGENT_IDS.join(', ')}`));
+                    console.log(chalk.gray(`Format: <agent>[@version]. Available: ${MANAGED_AGENT_IDS.join(', ')}`));
                     return;
                 }
                 agent = parsed.agent;
@@ -641,7 +646,7 @@ export function registerVersionsCommands(program) {
                 const agentLower = agentArg.toLowerCase();
                 if (!AGENTS[agentLower]) {
                     console.log(chalk.red(`Invalid agent: ${agentArg}`));
-                    console.log(chalk.gray(`Available: ${ALL_AGENT_IDS.join(', ')}`));
+                    console.log(chalk.gray(`Available: ${MANAGED_AGENT_IDS.join(', ')}`));
                     return;
                 }
                 agent = agentLower;

package/dist/commands/view.d.ts

@@ -129,6 +129,7 @@ export declare function viewAction(agentArg?: string, options?: {
     detailed?: boolean;
     refresh?: boolean;
     live?: boolean;
+    merged?: boolean;
 } & ViewSectionFilter): Promise<void>;
 /** Register the `agents view` command. */
 export declare function registerViewCommand(program: Command): void;

package/dist/commands/view.js

@@ -13,6 +13,7 @@ import { readManifest } from '../lib/manifest.js';
 import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, syncResourcesToVersion, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, isVersionIsolated, getIsolatedDefault, } from '../lib/versions.js';
 import { ensureVersionedAliasCurrent, removeShim, } from '../lib/shims.js';
 import { getAgentResources } from '../lib/resources.js';
+import { renderMergedResources } from '../lib/merged-resources.js';
 import { resolveVersionFilter, AgentSpecError } from '../lib/agent-spec/index.js';
 import { listCliStatus } from '../lib/cli-resources.js';
 import { isCapable } from '../lib/capabilities.js';
@@ -1468,6 +1469,12 @@ export async function pruneDuplicates(filterAgentId, yes, dryRun) {
  * Exported for use by deprecated aliases.
  */
 export async function viewAction(agentArg, options) {
+    // --merged renders the cross-layer, first-wins resource surface (the former
+    // `agents resources`), independent of the per-version detail view below.
+    if (options?.merged) {
+        renderMergedResources();
+        return;
+    }
     // --live is a shorter-to-type alias of --refresh; both force a live probe.
     const forceRefresh = options?.refresh === true || options?.live === true;
     // --resources / --detailed imply --json (they only shape structured output).
@@ -1595,6 +1602,7 @@ export function registerViewCommand(program) {
         .option('--hooks', 'Show only hooks in the detail view.')
         .option('--promptcuts', 'Show only promptcuts in the detail view.')
         .option('--cli', 'Show only host CLIs (declared in cli/, installed to PATH).')
+        .option('--merged', 'Show the merged, first-wins resource surface across all layers (project, user, extras, system) in one table with the winning layer per row.')
         .addHelpText('after', `
 Examples:
   # Show all installed agents with versions, accounts, and usage
@@ -1625,6 +1633,9 @@ Examples:
   agents view claude@default --plugins --workflows
   agents view claude --commands    # implicitly the default version
 
+  # Merged, first-wins resource surface across all layers, with the winning layer
+  agents view --merged
+
 When to use:
   - Checking which agents are installed and what their default versions are
   - Seeing which account each version is logged into (useful for multi-account setups)

package/dist/index.js

@@ -94,7 +94,7 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadResources, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadCheck, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
@@ -215,7 +215,7 @@ program.helpInformation = function () {
         return brandRootHelp(`Usage: agents [command] [options]
 
 Install, configure, run, and dispatch AI coding agents from one place.
-Works with Claude, Codex, Gemini, Cursor, OpenCode, OpenClaw, and Droid.
+Works with Claude, Codex, Antigravity, Cursor, OpenCode, OpenClaw, and Droid.
 
 Quick start:
   agents setup                    First-time setup (interactive)
@@ -231,9 +231,8 @@ Agent versions:
   use <agent>@<version>           Set the default version
   prune cleanup [target]          Remove orphan resources and older duplicate version installs
   trash                           Inspect and restore soft-deleted version directories
-  view [agent[@version]]          List versions, or inspect one in detail
+  view [agent[@version]]          List versions, inspect one in detail, or --merged for the cross-layer resource surface
   inspect <target>                Deep details for one agent+version, or a DotAgents repo (user|system|project|alias|path)
-  resources                       Show merged DotAgents resources with their winning layer
 
 Agent configuration (synced across versions):
   rules                           Instructions given to agents (CLAUDE.md, etc.)
@@ -268,8 +267,7 @@ Credentials and profiles:
   secrets                         Keychain-backed env bundles; use 'secrets exec <bundle> -- <cmd>' to inject into a subprocess
 
 Diagnostics:
-  doctor [agent[@version]]        Diagnose CLI availability, sync status, and resource divergence
-  check                           CI drift gate: exit non-zero when resources are out of sync
+  doctor [agent[@version]]        Diagnose CLI availability, sync status, and resource divergence; --check for the CI drift gate
   usage [agent]                   Show rate-limit and quota usage per agent
 
 Config sync:
@@ -764,7 +762,6 @@ async function registerAllEagerCommands() {
     await reg(loadShare);
     await reg(loadSend);
     await reg(loadInspect);
-    await reg(loadResources);
     await reg(loadFeedback);
     await reg(loadCommands);
     await reg(loadHooks);
@@ -788,13 +785,13 @@ async function registerAllEagerCommands() {
     await reg(loadRun);
     await reg(loadFork);
     await reg(loadDefaults);
+    await reg(loadSet);
     await reg(loadModels);
     await reg(loadPrune);
     await reg(loadTrash);
     await reg(loadRestore);
     await reg(loadDoctor);
     await reg(loadApply);
-    await reg(loadCheck);
     await reg(loadStatus);
     registerExecAliasCommand(program);
     await reg(loadProfiles);

package/dist/lib/acp/harnesses.js

@@ -8,13 +8,6 @@
  * Sources: https://agentclientprotocol.com/get-started/agents + vendor docs.
  */
 export const ACP_HARNESSES = {
-    gemini: {
-        command: 'gemini',
-        args: ['--experimental-acp'],
-        installHint: 'npm i -g @google/gemini-cli',
-        confidence: 'documented',
-        source: 'https://agentclientprotocol.com/get-started/agents',
-    },
     claude: {
         command: 'npx',
         args: ['-y', '@zed-industries/claude-agent-acp'],