@phnx-labs/agents-cli 1.20.4 → 1.20.6

package/dist/lib/staleness/writers/sources.js

@@ -0,0 +1,72 @@
+/**
+ * Shared layer-source resolution for writers.
+ *
+ * Layer precedence matches getResourceBases() in versions.ts. Project layer
+ * is intentionally EXCLUDED for commands/skills/hooks/subagents/permissions
+ * — those bodies become agent context, and a cloned public repo could ship
+ * one that coerces the agent on the next launch. Trusted layers only:
+ * user → system → extras.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getUserAgentsDir, getAgentsDir, getEnabledExtraRepos, getCommandsDir, getSkillsDir, getHooksDir } from '../../state.js';
+import { safeJoin } from '../../paths.js';
+/** Trusted source bases for content-like kinds. Project layer excluded. */
+export function trustedSourceBases() {
+    return [
+        { dir: getUserAgentsDir() },
+        { dir: getAgentsDir() },
+        ...getEnabledExtraRepos().map((e) => ({ dir: e.dir })),
+    ];
+}
+function isLiveFile(p) {
+    try {
+        return fs.existsSync(p) && !fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function isLiveDir(p) {
+    try {
+        return fs.existsSync(p) && !fs.lstatSync(p).isSymbolicLink() && fs.lstatSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Find the trusted source for a command markdown by name. */
+export function resolveCommandSource(name) {
+    const candidates = [
+        safeJoin(path.join(getUserAgentsDir(), 'commands'), `${name}.md`),
+        safeJoin(getCommandsDir(), `${name}.md`),
+        ...getEnabledExtraRepos().map((e) => safeJoin(path.join(e.dir, 'commands'), `${name}.md`)),
+    ];
+    return candidates.find(isLiveFile) ?? null;
+}
+/** Find the trusted source directory for a skill by name. */
+export function resolveSkillSource(name) {
+    const candidates = [
+        safeJoin(path.join(getUserAgentsDir(), 'skills'), name),
+        safeJoin(getSkillsDir(), name),
+        ...getEnabledExtraRepos().map((e) => safeJoin(path.join(e.dir, 'skills'), name)),
+    ];
+    return candidates.find(isLiveDir) ?? null;
+}
+/** Find the trusted source file for a hook by name. */
+export function resolveHookSource(name) {
+    const candidates = [
+        safeJoin(path.join(getUserAgentsDir(), 'hooks'), name),
+        safeJoin(getHooksDir(), name),
+        ...getEnabledExtraRepos().map((e) => safeJoin(path.join(e.dir, 'hooks'), name)),
+    ];
+    return candidates.find(isLiveFile) ?? null;
+}
+/** All trusted command-skill source roots, used to dedup name collisions for commands-as-skills writes. */
+export function trustedSkillRoots() {
+    return [
+        path.join(getUserAgentsDir(), 'skills'),
+        getSkillsDir(),
+        ...getEnabledExtraRepos().map((e) => path.join(e.dir, 'skills')),
+    ];
+}

package/dist/lib/staleness/writers/subagents.d.ts

@@ -0,0 +1,3 @@
+import type { AgentId } from '../../types.js';
+import type { ResourceWriter } from './types.js';
+export declare const subagentsWriters: Partial<Record<AgentId, ResourceWriter<string[]>>>;

package/dist/lib/staleness/writers/subagents.js

@@ -0,0 +1,53 @@
+/**
+ * Subagents writer. Claude flattens each subagent into a single .md file
+ * under `<agentDir>/agents/`. OpenClaw copies the full subagent directory
+ * (with AGENT.md renamed to AGENTS.md) into `<versionHome>/.openclaw/<name>/`.
+ *
+ * Source-side discovery is `listInstalledSubagents` from lib/subagents.ts —
+ * it reads user + system layers only (project layer excluded for the same
+ * defense as commands/skills/hooks).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { capableAgents } from '../../capabilities.js';
+import { listInstalledSubagents, transformSubagentForClaude, syncSubagentToOpenclaw } from '../../subagents.js';
+import { safeJoin } from '../../paths.js';
+import { lazyAgentMap } from './lazy-map.js';
+function buildSubagentsWriter(agent) {
+    return {
+        kind: 'subagents',
+        agent,
+        write({ versionHome, selection }) {
+            const all = listInstalledSubagents();
+            const map = new Map(all.map(s => [s.name, s]));
+            const synced = [];
+            for (const name of selection) {
+                const sub = map.get(name);
+                if (!sub)
+                    continue;
+                try {
+                    if (agent === 'claude') {
+                        const agentsDir = path.join(versionHome, '.claude', 'agents');
+                        fs.mkdirSync(agentsDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForClaude(sub.path));
+                        synced.push(sub.name);
+                    }
+                    else if (agent === 'openclaw') {
+                        const target = safeJoin(path.join(versionHome, '.openclaw'), sub.name);
+                        const r = syncSubagentToOpenclaw(sub.path, target);
+                        if (r.success)
+                            synced.push(sub.name);
+                    }
+                }
+                catch { /* per-item sync failure: skip */ }
+            }
+            return { synced };
+        },
+    };
+}
+export const subagentsWriters = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('subagents'))
+        m[agent] = buildSubagentsWriter(agent);
+    return m;
+});

package/dist/lib/staleness/writers/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Per-(kind, agent) writer contract.
+ *
+ * The aggregator in `syncResourcesToVersion` (versions.ts) selects names per
+ * kind, then dispatches into a writer from `../registry.ts`. The writer owns
+ * everything kind-specific: the agent's storage format, the layered source
+ * search, the conversion/copy step. Writers MUST be reached only after a
+ * `supports(agent, kind, version).ok === true` precheck — they throw when
+ * called on a (kind, agent) pair that the capability matrix says is false.
+ *
+ * The shape is intentionally narrow. Writers don't accept ambient state; the
+ * caller passes the names already resolved against availability. Selection is
+ * a string[] for most kinds, a PermissionsSelection object for permissions,
+ * and a RulesSelection object for rules — see kind-specific writer modules.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceKind } from './kinds.js';
+export interface WriteArgs<Sel> {
+    /** Agent version (e.g. "1.2.3") — passed for version-gated capability checks and side files. */
+    version: string;
+    /** Absolute path to the version's home dir, i.e. `~/.agents/.history/versions/<agent>/<version>/home`. */
+    versionHome: string;
+    /** Kind-specific selection payload. */
+    selection: Sel;
+    /** Current working directory — used by writers that consult project-layer state. */
+    cwd: string;
+}
+export interface WriteResult {
+    /** Names actually written. Empty array = write produced nothing (not an error). */
+    synced: string[];
+}
+export interface ResourceWriter<Sel = string[]> {
+    readonly kind: ResourceKind;
+    readonly agent: AgentId;
+    write(args: WriteArgs<Sel>): WriteResult;
+}

package/dist/lib/staleness/writers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/staleness/writers/workflows.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Workflows writer — copies each workflow directory into
+ * `<versionHome>/workflows/<name>/` via `syncWorkflowToVersion`.
+ */
+import type { AgentId } from '../../types.js';
+import type { ResourceWriter } from './types.js';
+export declare const workflowsWriters: Partial<Record<AgentId, ResourceWriter<string[]>>>;

package/dist/lib/staleness/writers/workflows.js

@@ -0,0 +1,31 @@
+import { capableAgents } from '../../capabilities.js';
+import { listInstalledWorkflows, syncWorkflowToVersion } from '../../workflows.js';
+import { lazyAgentMap } from './lazy-map.js';
+function buildWorkflowsWriter(agent) {
+    return {
+        kind: 'workflows',
+        agent,
+        write({ versionHome, selection }) {
+            const all = listInstalledWorkflows();
+            const synced = [];
+            for (const name of selection) {
+                const wf = all.get(name);
+                if (!wf)
+                    continue;
+                try {
+                    const r = syncWorkflowToVersion(wf.path, name, agent, versionHome);
+                    if (r.success)
+                        synced.push(name);
+                }
+                catch { /* per-item failure: skip */ }
+            }
+            return { synced };
+        },
+    };
+}
+export const workflowsWriters = lazyAgentMap(() => {
+    const m = {};
+    for (const agent of capableAgents('workflows'))
+        m[agent] = buildWorkflowsWriter(agent);
+    return m;
+});

package/dist/lib/state.d.ts

@@ -1,28 +1,34 @@
 /**
  * Filesystem layout and persistent state for agents-cli.
  *
- * Two roots:
- *  - ~/.agents-system/ — system repo (npm-shipped resources, read-only defaults)
- *  - ~/.agents/        — user repo (resources + agents.yaml + operational state)
+ * Single root at ~/.agents/ with three internal buckets:
  *
- * Inside ~/.agents/, top-level paths hold ONLY resources + agents.yaml.
- * Operational state lives in two sibling buckets:
- *
- *  - ~/.agents/.history/ — durable runtime data (sessions, versions, runs,
+ *   ~/.agents/           — user repo: user-authored resources + agents.yaml
+ *                          (git-tracked via `agents repo push`).
+ *   ~/.agents/.system/   — system repo: npm-shipped resources, regenerable.
+ *                          Don't hand-edit; maintained by npm install /
+ *                          `agents repo pull system`.
+ *   ~/.agents/.history/  — durable runtime data (sessions, versions, runs,
  *                          teams/agents, trash, backups). Backed up by
  *                          `agents repo push`.
- *  - ~/.agents/.cache/   — regenerable runtime data (shims, packages, helpers
+ *   ~/.agents/.cache/    — regenerable runtime data (shims, packages, helpers
  *                          for daemon/pty, terminals, cloud, drive, browser
  *                          chrome-data, logs, companion). Gitignored.
  *
  * Resolution precedence for resources: project > user > system.
  * Every module that needs a path or reads/writes agents.yaml goes through here.
+ *
+ * Legacy layout (pre-fold): system repo lived at ~/.agents-system/ as a peer
+ * of ~/.agents/. runMigration() folds it into ~/.agents/.system/ on first run
+ * and leaves a back-compat symlink at the old path.
  */
 import type { Meta } from './types.js';
-/** Root of the system data directory (~/.agents-system/). */
+/** Root of the system data directory (~/.agents/.system/). */
 export declare function getAgentsDir(): string;
-/** Root of the system data directory (~/.agents-system/). */
+/** Root of the system data directory (~/.agents/.system/). */
 export declare function getSystemAgentsDir(): string;
+/** Legacy system-repo location (~/.agents-system/). Exported for migration only. */
+export declare function getLegacySystemAgentsDir(): string;
 /** Root of the user repo (~/.agents/). Always present after ensureAgentsDir(). */
 export declare function getUserAgentsDir(): string;
 /**
@@ -55,7 +61,7 @@ export declare function getMcpDir(): string;
 export declare function getPermissionsDir(): string;
 /** Path to subagent definition directories — system repo. */
 export declare function getSubagentsDir(): string;
-/** Path to ~/.agents-system/hooks/promptcuts.yaml (system defaults). */
+/** Path to ~/.agents/.system/hooks/promptcuts.yaml (system defaults). */
 export declare function getPromptcutsPath(): string;
 /**
  * Resolve the effective promptcuts file: user file if it exists, otherwise
@@ -101,6 +107,15 @@ export declare function getCacheDir(): string;
 export declare function getPackagesDir(): string;
 /** Path to routine YAML definitions (~/.agents/routines/). */
 export declare function getRoutinesDir(): string;
+/**
+ * Path to a project-scoped routines directory (`<project>/.agents/routines/`),
+ * or null when no project `.agents/` is found by walking up from cwd.
+ *
+ * Project routines participate in `list`/`view`/`run` for inspection but are
+ * NOT fired by the daemon (which runs from $HOME and only loads user routines).
+ * Opt-in firing for project routines is tracked as a follow-up.
+ */
+export declare function getProjectRoutinesDir(cwd?: string): string | null;
 /** Path to routine execution logs (~/.agents/.history/runs/). */
 export declare function getRunsDir(): string;
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
@@ -117,6 +132,12 @@ export declare function getBinDir(): string;
 export declare function getBackupsDir(): string;
 /** Path to plugin bundles (~/.agents/plugins/) — user-authored resource. */
 export declare function getPluginsDir(): string;
+/** Path to system plugin bundles (~/.agents/.system/plugins/) — npm-shipped, read-only defaults. */
+export declare function getSystemPluginsDir(): string;
+/** Path to an extra repo's plugin bundles (~/.agents-<alias>/plugins/). */
+export declare function getExtraPluginsDir(alias: string): string;
+/** Path to a project-scoped plugins directory (<project>/.agents/plugins/), or null when none. */
+export declare function getProjectPluginsDir(cwd?: string): string | null;
 /** Path to synced remote session data (~/.agents/.cache/drive/). */
 export declare function getDriveDir(): string;
 /** Path to soft-deleted resources (~/.agents/.history/trash/). */
@@ -149,6 +170,8 @@ export declare function getHelpersDir(): string;
 export declare function getDaemonDir(): string;
 /** Path to PTY server scratch (~/.agents/.cache/helpers/pty/). */
 export declare function getPtyDir(): string;
+/** Path to tmux scratch (~/.agents/.cache/helpers/tmux/) — shared server socket + per-session meta JSONs. */
+export declare function getTmuxDir(): string;
 /** Path to remote-resource auto-pull cache (~/.agents/.cache/.fetch/). */
 export declare function getFetchCacheDir(): string;
 /** Path to the CLI version cache file (~/.agents/.cache/.cli-version-cache.json). */

package/dist/lib/state.js

@@ -1,22 +1,26 @@
 /**
  * Filesystem layout and persistent state for agents-cli.
  *
- * Two roots:
- *  - ~/.agents-system/ — system repo (npm-shipped resources, read-only defaults)
- *  - ~/.agents/        — user repo (resources + agents.yaml + operational state)
+ * Single root at ~/.agents/ with three internal buckets:
  *
- * Inside ~/.agents/, top-level paths hold ONLY resources + agents.yaml.
- * Operational state lives in two sibling buckets:
- *
- *  - ~/.agents/.history/ — durable runtime data (sessions, versions, runs,
+ *   ~/.agents/           — user repo: user-authored resources + agents.yaml
+ *                          (git-tracked via `agents repo push`).
+ *   ~/.agents/.system/   — system repo: npm-shipped resources, regenerable.
+ *                          Don't hand-edit; maintained by npm install /
+ *                          `agents repo pull system`.
+ *   ~/.agents/.history/  — durable runtime data (sessions, versions, runs,
  *                          teams/agents, trash, backups). Backed up by
  *                          `agents repo push`.
- *  - ~/.agents/.cache/   — regenerable runtime data (shims, packages, helpers
+ *   ~/.agents/.cache/    — regenerable runtime data (shims, packages, helpers
  *                          for daemon/pty, terminals, cloud, drive, browser
  *                          chrome-data, logs, companion). Gitignored.
  *
  * Resolution precedence for resources: project > user > system.
  * Every module that needs a path or reads/writes agents.yaml goes through here.
+ *
+ * Legacy layout (pre-fold): system repo lived at ~/.agents-system/ as a peer
+ * of ~/.agents/. runMigration() folds it into ~/.agents/.system/ on first run
+ * and leaves a back-compat symlink at the old path.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -26,10 +30,16 @@ import { ensureLockTarget, atomicWriteFileSync, withFileLock } from './fs-atomic
 import { SEEDED_REGISTRIES } from './types.js';
 const HOME = process.env.HOME ?? os.homedir();
 // ─── Root directories ─────────────────────────────────────────────────────────
-/** System repo — npm-shipped, read-only from user commands. */
-const SYSTEM_AGENTS_DIR = path.join(HOME, '.agents-system');
 /** User repo — user-authored resources and agents.yaml. Always-on. */
 const USER_AGENTS_DIR = path.join(HOME, '.agents');
+/** System repo — npm-shipped, read-only from user commands. Lives inside the user repo. */
+const SYSTEM_AGENTS_DIR = path.join(USER_AGENTS_DIR, '.system');
+/**
+ * Legacy system-repo location (pre-fold). Exported so the migrator can fold
+ * it into SYSTEM_AGENTS_DIR. No runtime code outside the migrator should
+ * reference this — use SYSTEM_AGENTS_DIR.
+ */
+const LEGACY_SYSTEM_AGENTS_DIR = path.join(HOME, '.agents-system');
 // ─── Meta file (agents.yaml lives in the user repo) ──────────────────────────
 const META_FILE = path.join(USER_AGENTS_DIR, 'agents.yaml');
 /** Legacy location — used only for one-shot migration in readMeta(). */
@@ -43,6 +53,7 @@ const SYSTEM_MCP_DIR = path.join(SYSTEM_AGENTS_DIR, 'mcp');
 const SYSTEM_PERMISSIONS_DIR = path.join(SYSTEM_AGENTS_DIR, 'permissions');
 const SYSTEM_SUBAGENTS_DIR = path.join(SYSTEM_AGENTS_DIR, 'subagents');
 const SYSTEM_WORKFLOWS_DIR = path.join(SYSTEM_AGENTS_DIR, 'workflows');
+const SYSTEM_PLUGINS_DIR = path.join(SYSTEM_AGENTS_DIR, 'plugins');
 const SYSTEM_PROMPTCUTS_FILE = path.join(SYSTEM_AGENTS_DIR, 'hooks', 'promptcuts.yaml');
 const SYSTEM_MCP_CONFIG_FILE = path.join(SYSTEM_AGENTS_DIR, 'mcp.json');
 const SYSTEM_INSTRUCTIONS_FILE = path.join(SYSTEM_AGENTS_DIR, 'instructions.md');
@@ -81,6 +92,7 @@ const BROWSER_RUNTIME_DIR = path.join(CACHE_DIR, 'browser');
 const HELPERS_DIR = path.join(CACHE_DIR, 'helpers');
 const DAEMON_DIR = path.join(HELPERS_DIR, 'daemon');
 const PTY_DIR = path.join(HELPERS_DIR, 'pty');
+const TMUX_DIR = path.join(HELPERS_DIR, 'tmux');
 const FETCH_CACHE_DIR = path.join(CACHE_DIR, '.fetch');
 const CLI_VERSION_CACHE_FILE = path.join(CACHE_DIR, '.cli-version-cache.json');
 const MODELS_CACHE_FILE = path.join(CACHE_DIR, '.models-cache.json');
@@ -103,14 +115,18 @@ const META_HEADER = `# agents-cli metadata
 
 `;
 // ─── Root getters ─────────────────────────────────────────────────────────────
-/** Root of the system data directory (~/.agents-system/). */
+/** Root of the system data directory (~/.agents/.system/). */
 export function getAgentsDir() {
     return SYSTEM_AGENTS_DIR;
 }
-/** Root of the system data directory (~/.agents-system/). */
+/** Root of the system data directory (~/.agents/.system/). */
 export function getSystemAgentsDir() {
     return SYSTEM_AGENTS_DIR;
 }
+/** Legacy system-repo location (~/.agents-system/). Exported for migration only. */
+export function getLegacySystemAgentsDir() {
+    return LEGACY_SYSTEM_AGENTS_DIR;
+}
 /** Root of the user repo (~/.agents/). Always present after ensureAgentsDir(). */
 export function getUserAgentsDir() {
     return USER_AGENTS_DIR;
@@ -187,7 +203,7 @@ export function getMcpDir() { return SYSTEM_MCP_DIR; }
 export function getPermissionsDir() { return SYSTEM_PERMISSIONS_DIR; }
 /** Path to subagent definition directories — system repo. */
 export function getSubagentsDir() { return SYSTEM_SUBAGENTS_DIR; }
-/** Path to ~/.agents-system/hooks/promptcuts.yaml (system defaults). */
+/** Path to ~/.agents/.system/hooks/promptcuts.yaml (system defaults). */
 export function getPromptcutsPath() { return SYSTEM_PROMPTCUTS_FILE; }
 /**
  * Resolve the effective promptcuts file: user file if it exists, otherwise
@@ -261,6 +277,20 @@ export function getCacheDir() { return CACHE_DIR; }
 export function getPackagesDir() { return PACKAGES_DIR; }
 /** Path to routine YAML definitions (~/.agents/routines/). */
 export function getRoutinesDir() { return ROUTINES_DIR; }
+/**
+ * Path to a project-scoped routines directory (`<project>/.agents/routines/`),
+ * or null when no project `.agents/` is found by walking up from cwd.
+ *
+ * Project routines participate in `list`/`view`/`run` for inspection but are
+ * NOT fired by the daemon (which runs from $HOME and only loads user routines).
+ * Opt-in firing for project routines is tracked as a follow-up.
+ */
+export function getProjectRoutinesDir(cwd = process.cwd()) {
+    const projectAgentsDir = getProjectAgentsDir(cwd);
+    if (!projectAgentsDir)
+        return null;
+    return path.join(projectAgentsDir, 'routines');
+}
 /** Path to routine execution logs (~/.agents/.history/runs/). */
 export function getRunsDir() { return RUNS_DIR; }
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
@@ -277,6 +307,19 @@ export function getBinDir() { return BIN_DIR; }
 export function getBackupsDir() { return BACKUPS_DIR; }
 /** Path to plugin bundles (~/.agents/plugins/) — user-authored resource. */
 export function getPluginsDir() { return PLUGINS_DIR; }
+/** Path to system plugin bundles (~/.agents/.system/plugins/) — npm-shipped, read-only defaults. */
+export function getSystemPluginsDir() { return SYSTEM_PLUGINS_DIR; }
+/** Path to an extra repo's plugin bundles (~/.agents-<alias>/plugins/). */
+export function getExtraPluginsDir(alias) {
+    return path.join(getExtraRepoDir(alias), 'plugins');
+}
+/** Path to a project-scoped plugins directory (<project>/.agents/plugins/), or null when none. */
+export function getProjectPluginsDir(cwd = process.cwd()) {
+    const projectAgentsDir = getProjectAgentsDir(cwd);
+    if (!projectAgentsDir)
+        return null;
+    return path.join(projectAgentsDir, 'plugins');
+}
 /** Path to synced remote session data (~/.agents/.cache/drive/). */
 export function getDriveDir() { return DRIVE_DIR; }
 /** Path to soft-deleted resources (~/.agents/.history/trash/). */
@@ -309,6 +352,8 @@ export function getHelpersDir() { return HELPERS_DIR; }
 export function getDaemonDir() { return DAEMON_DIR; }
 /** Path to PTY server scratch (~/.agents/.cache/helpers/pty/). */
 export function getPtyDir() { return PTY_DIR; }
+/** Path to tmux scratch (~/.agents/.cache/helpers/tmux/) — shared server socket + per-session meta JSONs. */
+export function getTmuxDir() { return TMUX_DIR; }
 /** Path to remote-resource auto-pull cache (~/.agents/.cache/.fetch/). */
 export function getFetchCacheDir() { return FETCH_CACHE_DIR; }
 /** Path to the CLI version cache file (~/.agents/.cache/.cli-version-cache.json). */

package/dist/lib/subagents.d.ts

@@ -73,8 +73,6 @@ export declare function removeSubagentFromAgent(subagentName: string, agent: Age
  * Check if subagent content matches between source and installed
  */
 export declare function subagentContentMatches(installedDir: string, sourceDir: string): boolean;
-/** Agents that support the subagent system (Claude via flattened .md, OpenClaw via directory copy). */
-export declare const SUBAGENT_CAPABLE_AGENTS: AgentId[];
 /**
  * List subagents installed to a specific agent's home
  * Claude: scans ~/.claude/agents/{name}.md

package/dist/lib/subagents.js

@@ -9,6 +9,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
+import { capableAgents } from './capabilities.js';
 import { getSubagentsDir, getUserSubagentsDir, getTrashSubagentsDir } from './state.js';
 import { listInstalledVersions, getVersionHomePath } from './versions.js';
 import { safeJoin } from './paths.js';
@@ -333,8 +334,9 @@ export function subagentContentMatches(installedDir, sourceDir) {
     }
     return true;
 }
-/** Agents that support the subagent system (Claude via flattened .md, OpenClaw via directory copy). */
-export const SUBAGENT_CAPABLE_AGENTS = ['claude', 'openclaw'];
+// SUBAGENT_CAPABLE_AGENTS removed — use `capableAgents('subagents')` from
+// lib/capabilities.ts. The capability matrix on AgentConfig is the single
+// source of truth.
 /**
  * List subagents installed to a specific agent's home
  * Claude: scans ~/.claude/agents/{name}.md
@@ -408,8 +410,6 @@ export function listSubagentsForAgent(agentId, home) {
     }
     return subagents;
 }
-// Agents that support subagents
-const SUBAGENTS_CAPABLE_AGENTS = ['claude', 'openclaw'];
 /**
  * Compare a version home's subagents against discovered subagents.
  * Returns orphan subagent names.
@@ -461,9 +461,9 @@ export function diffVersionSubagents(agent, version) {
  */
 export function iterSubagentsCapableVersions(filter) {
     const pairs = [];
-    const agents = filter?.agent ? [filter.agent] : SUBAGENTS_CAPABLE_AGENTS;
+    const agents = filter?.agent ? [filter.agent] : capableAgents('subagents');
     for (const agent of agents) {
-        if (!SUBAGENTS_CAPABLE_AGENTS.includes(agent))
+        if (!capableAgents('subagents').includes(agent))
             continue;
         const versions = listInstalledVersions(agent);
         for (const version of versions) {

package/dist/lib/teams/agents.js

@@ -172,7 +172,7 @@ export function captureProcessStartTime(pid) {
     }
 }
 /** Agent types the team runner supports. */
-const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode', 'grok', 'antigravity'];
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'gemini', 'claude', 'opencode', 'grok', 'antigravity', 'kimi'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 

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

@@ -64,6 +64,73 @@ export interface TaskStatusResult {
     };
     cursor: string;
 }
+/**
+ * Compact per-teammate snapshot for the default `teams status` view.
+ *
+ * The detail shape (`AgentStatusDetail`) carries the full prompt (often many
+ * KB), every absolute path the agent has touched, and uncapped message
+ * bodies. That's the right shape for programmatic consumers, but it makes
+ * `teams status` unreadable for orchestrators who only need: what state are
+ * you in, what did you just do, what files have you touched.
+ *
+ * Use {@link toAgentStatusSummary} to derive this from a detail record.
+ */
+export interface AgentStatusSummary {
+    agent_id: string;
+    name: string | null;
+    agent_type: string;
+    status: string;
+    duration: string | null;
+    tool_count: number;
+    has_errors: boolean;
+    pr_url: string | null;
+    files: {
+        /** Count of files modified since the cursor (delta), plus basenames. */
+        modified: {
+            count: number;
+            names: string[];
+        };
+        created: {
+            count: number;
+            names: string[];
+        };
+        deleted: {
+            count: number;
+            names: string[];
+        };
+        /** Read is noisy (per-Read events fire constantly); only emit a count. */
+        read: {
+            count: number;
+        };
+    };
+    /** Already capped at 15 × 120 chars by the detail builder. */
+    bash_commands: string[];
+    /** Last 3 messages, each body trimmed to ~400 chars. */
+    last_messages: string[];
+    /** ISO timestamp — feed back via --since for delta polling. */
+    cursor: string;
+}
+/** Compact aggregated result; mirrors {@link TaskStatusResult} but agents[] is the summary shape. */
+export interface TaskStatusSummaryResult {
+    task_name: string;
+    agents: AgentStatusSummary[];
+    summary: {
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        stopped: number;
+    };
+    cursor: string;
+}
+/**
+ * Project a full AgentStatusDetail down to a compact AgentStatusSummary.
+ * Drops `prompt` entirely (caller knows what they queued), folds file lists
+ * to basenames + counts, caps `last_messages` to 3 × {@link SUMMARY_MESSAGE_MAX_CHARS}.
+ */
+export declare function toAgentStatusSummary(detail: AgentStatusDetail): AgentStatusSummary;
+/** Project a full TaskStatusResult down to the compact summary shape. */
+export declare function toTaskStatusSummary(result: TaskStatusResult): TaskStatusSummaryResult;
 /** Result of stopping one or more teammates. */
 export interface StopResult {
     task_name: string;