@phnx-labs/agents-cli 1.20.62 → 1.20.64

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

@@ -1,205 +1,18 @@
-/**
- * Subagents detector. Claude/Gemini/Grok: flat .md files under `<agentDir>/agents/`.
- * Codex: flat .toml files under `<versionHome>/.codex/agents/`.
- * Droid: flat .md files under `<versionHome>/.factory/droids/`.
- * Cursor: flat .md files under `<versionHome>/.cursor/agents/`.
- * ForgeCode: flat .md files under `<versionHome>/.forge/agents/`.
- * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
- * Mirrors versions.ts:521-539.
- */
-import * as fs from 'fs';
-import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
+import { listInstalledSubagentNames } from '../../subagents-registry.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
-function buildFlatMdAgentsDetector(agent, agentsRoot) {
+function buildSubagentsDetector(agent) {
     return {
         kind: 'subagents',
         agent,
         list({ versionHome }) {
-            const agentsDir = path.join(versionHome, agentsRoot, 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.md'))
-                .map(f => f.replace('.md', ''));
+            return listInstalledSubagentNames(agent, versionHome);
         },
     };
 }
-function buildClaudeDetector() {
-    return buildFlatMdAgentsDetector('claude', '.claude');
-}
-function buildGrokDetector() {
-    return buildFlatMdAgentsDetector('grok', '.grok');
-}
-function buildGeminiDetector() {
-    return buildFlatMdAgentsDetector('gemini', '.gemini');
-}
-function buildCodexDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'codex',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.codex', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.toml'))
-                .map(f => f.replace(/\.toml$/, ''));
-        },
-    };
-}
-function buildDroidDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'droid',
-        list({ versionHome }) {
-            const droidsDir = path.join(versionHome, '.factory', 'droids');
-            if (!fs.existsSync(droidsDir))
-                return [];
-            return fs.readdirSync(droidsDir)
-                .filter(f => f.endsWith('.md'))
-                .map(f => f.replace('.md', ''));
-        },
-    };
-}
-function buildCopilotDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'copilot',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.copilot', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.agent.md'))
-                .map(f => f.replace('.agent.md', ''));
-        },
-    };
-}
-function buildCursorDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'cursor',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.cursor', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.md'))
-                .map(f => f.replace(/\.md$/, ''));
-        },
-    };
-}
-function buildOpenclawDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'openclaw',
-        list({ versionHome }) {
-            const openclawDir = path.join(versionHome, '.openclaw');
-            if (!fs.existsSync(openclawDir))
-                return [];
-            return fs.readdirSync(openclawDir, { withFileTypes: true })
-                .filter(d => d.isDirectory() && fs.existsSync(path.join(openclawDir, d.name, 'AGENTS.md')))
-                .map(d => d.name);
-        },
-    };
-}
-function buildKimiDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'kimi',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.kimi-code', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            // Parent is `_agents-cli.yaml` (underscore-prefixed reserved name).
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.yaml') && !f.startsWith('_'))
-                .map(f => f.replace(/\.yaml$/, ''));
-        },
-    };
-}
-function buildKiroDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'kiro',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.kiro', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.json'))
-                .map(f => f.replace(/\.json$/, ''));
-        },
-    };
-}
-function buildForgeDetector() {
-    return buildFlatMdAgentsDetector('forge', '.forge');
-}
-function buildGooseDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'goose',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.config', 'goose', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.yaml'))
-                .map(f => f.replace(/\.yaml$/, ''));
-        },
-    };
-}
-function buildOpenCodeDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'opencode',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.config', 'opencode', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir)
-                .filter(f => f.endsWith('.md'))
-                .map(f => f.replace(/\.md$/, ''));
-        },
-    };
-}
-function buildAntigravityDetector() {
-    return {
-        kind: 'subagents',
-        agent: 'antigravity',
-        list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.gemini', 'config', 'agents');
-            if (!fs.existsSync(agentsDir))
-                return [];
-            return fs.readdirSync(agentsDir, { withFileTypes: true })
-                .filter(d => d.isDirectory() && fs.existsSync(path.join(agentsDir, d.name, 'agent.md')))
-                .map(d => d.name);
-        },
-    };
-}
-const handlers = {
-    claude: buildClaudeDetector,
-    copilot: buildCopilotDetector,
-    gemini: buildGeminiDetector,
-    grok: buildGrokDetector,
-    codex: buildCodexDetector,
-    kimi: buildKimiDetector,
-    opencode: buildOpenCodeDetector,
-    antigravity: buildAntigravityDetector,
-    droid: buildDroidDetector,
-    openclaw: buildOpenclawDetector,
-    kiro: buildKiroDetector,
-    cursor: buildCursorDetector,
-    forge: buildForgeDetector,
-    goose: buildGooseDetector,
-};
 export const subagentsDetectors = lazyAgentMap(() => {
     const m = {};
-    for (const agent of capableAgents('subagents')) {
-        const f = handlers[agent];
-        if (f)
-            m[agent] = f();
-    }
+    for (const agent of capableAgents('subagents'))
+        m[agent] = buildSubagentsDetector(agent);
     return m;
 });

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

@@ -1,3 +1,13 @@
+/**
+ * Subagents writer. Every agent's on-disk layout (target dir, file/dir shape,
+ * transform, and any post-sync finalize such as Kimi's parent index) is
+ * declared once in the subagent registry; this writer is generic and iterates
+ * the registry instead of a per-agent `else if` chain.
+ *
+ * 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 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

@@ -1,123 +1,32 @@
-/**
- * Subagents writer. Claude/Gemini/Grok flatten each subagent into a single
- * .md file under their native agents directory. Codex writes TOML under
- * `.codex/agents/`.
- * Droid (Factory AI) flattens each into a custom droid .md under
- * `<versionHome>/.factory/droids/`. Cursor flattens each into a custom
- * subagent .md under `<versionHome>/.cursor/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, transformSubagentForCodex, transformSubagentForCopilot, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForAntigravity, transformSubagentForDroid, transformSubagentForForge, transformSubagentForKiro, transformSubagentForCursor, transformSubagentForGoose, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
-import { safeJoin } from '../../paths.js';
+import { listInstalledSubagents } from '../../subagents.js';
+import { subagentTarget } from '../../subagents-registry.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
     return {
         kind: 'subagents',
         agent,
         write({ versionHome, selection }) {
+            const target = subagentTarget(agent);
+            if (!target)
+                return { synced: [] };
             const all = listInstalledSubagents();
             const map = new Map(all.map(s => [s.name, s]));
+            const dir = target.dir(versionHome);
             const synced = [];
             for (const name of selection) {
                 const sub = map.get(name);
                 if (!sub)
                     continue;
                 try {
-                    if (agent === 'claude' || agent === 'gemini' || agent === 'grok') {
-                        const agentsRoot = agent === 'grok' ? '.grok' : agent === 'gemini' ? '.gemini' : '.claude';
-                        const agentsDir = path.join(versionHome, agentsRoot, 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForClaude(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'codex') {
-                        const agentsDir = path.join(versionHome, '.codex', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.toml`), transformSubagentForCodex(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'kimi') {
-                        writeKimiSubagentFiles(path.join(versionHome, '.kimi-code', 'agents'), sub.path, sub.name);
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'opencode') {
-                        const agentsDir = path.join(versionHome, '.config', 'opencode', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForOpenCode(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'antigravity') {
-                        const agentDir = safeJoin(path.join(versionHome, '.gemini', 'config', 'agents'), sub.name);
-                        fs.mkdirSync(agentDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentDir, 'agent.md'), transformSubagentForAntigravity(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'droid') {
-                        const droidsDir = path.join(versionHome, '.factory', 'droids');
-                        fs.mkdirSync(droidsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(droidsDir, `${sub.name}.md`), transformSubagentForDroid(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'copilot') {
-                        const agentsDir = path.join(versionHome, '.copilot', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.agent.md`), transformSubagentForCopilot(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);
-                    }
-                    else if (agent === 'kiro') {
-                        const agentsDir = path.join(versionHome, '.kiro', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.json`), transformSubagentForKiro(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'cursor') {
-                        const agentsDir = path.join(versionHome, '.cursor', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForCursor(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'forge') {
-                        const agentsDir = path.join(versionHome, '.forge', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForForge(sub.path));
-                        synced.push(sub.name);
-                    }
-                    else if (agent === 'goose') {
-                        const agentsDir = path.join(versionHome, '.config', 'goose', 'agents');
-                        fs.mkdirSync(agentsDir, { recursive: true });
-                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.yaml`), transformSubagentForGoose(sub.path));
-                        synced.push(sub.name);
-                    }
+                    target.write(dir, sub);
+                    synced.push(sub.name);
                 }
                 catch { /* per-item sync failure: skip */ }
             }
-            // Kimi parent agent file listing all synced subagents for --agent-file.
-            if (agent === 'kimi' && synced.length > 0) {
-                const agentsDir = path.join(versionHome, '.kimi-code', 'agents');
-                const entries = synced.map((name) => {
-                    const sub = map.get(name);
-                    const fm = parseSubagentFrontmatter(path.join(sub.path, 'AGENT.md'));
-                    return {
-                        name,
-                        description: fm?.description ?? name,
-                        relativePath: `./${name}.yaml`,
-                    };
-                });
-                fs.writeFileSync(safeJoin(agentsDir, KIMI_SUBAGENTS_PARENT_FILE), buildKimiSubagentsParentYaml(entries));
+            // Optional cross-item pass (e.g. Kimi's `_agents-cli.yaml` parent index).
+            if (target.finalize && synced.length > 0) {
+                target.finalize(dir, synced.map((name) => map.get(name)));
             }
             return { synced };
         },

package/dist/lib/startup/command-registry.d.ts

@@ -74,6 +74,7 @@ export declare const loadWatchdog: ModuleLoader;
 export declare const loadBrowser: ModuleLoader;
 export declare const loadComputer: ModuleLoader;
 export declare const loadHosts: ModuleLoader;
+export declare const loadLease: ModuleLoader;
 export declare const loadLogs: ModuleLoader;
 export declare const loadEvents: ModuleLoader;
 export declare const loadSsh: ModuleLoader;
@@ -86,8 +87,11 @@ export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
 export declare const loadFeed: ModuleLoader;
+export declare const loadMailboxes: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadAudit: ModuleLoader;
+export declare const loadWebhook: ModuleLoader;
+export declare const loadFunnel: ModuleLoader;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help

package/dist/lib/startup/command-registry.js

@@ -52,6 +52,7 @@ export const loadWatchdog = async () => (await import('../../commands/watchdog.j
 export const loadBrowser = async () => (await import('../../commands/browser.js')).registerBrowserCommand;
 export const loadComputer = async () => (await import('../../commands/computer.js')).registerComputerCommand;
 export const loadHosts = async () => (await import('../../commands/hosts.js')).registerHostsCommand;
+export const loadLease = async () => (await import('../../commands/lease.js')).registerLeaseCommand;
 export const loadLogs = async () => (await import('../../commands/logs.js')).registerLogsCommand;
 export const loadEvents = async () => (await import('../../commands/events.js')).registerEventsCommand;
 export const loadSsh = async () => (await import('../../commands/ssh.js')).registerSshCommands;
@@ -64,8 +65,11 @@ export const loadTeams = async () => (await import('../../commands/teams.js')).r
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
 export const loadMessage = async () => (await import('../../commands/message.js')).registerMessageCommand;
 export const loadFeed = async () => (await import('../../commands/feed.js')).registerFeedCommand;
+export const loadMailboxes = async () => (await import('../../commands/mailboxes.js')).registerMailboxesCommand;
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadAudit = async () => (await import('../../commands/audit.js')).registerAuditCommands;
+export const loadWebhook = async () => (await import('../../commands/webhook.js')).registerWebhookCommand;
+export const loadFunnel = async () => (await import('../../commands/funnel.js')).registerFunnelCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help
@@ -147,12 +151,20 @@ export const COMMAND_LOADERS = {
     browser: [loadBrowser],
     computer: [loadComputer],
     hosts: [loadHosts],
+    lease: [loadLease],
     logs: [loadLogs],
     events: [loadEvents],
     ssh: [loadSsh],
     devices: [loadSsh],
+    // `fleet` is a commander alias of `devices` (see commands/ssh.ts); list it so
+    // lazy registration loads the devices tree when the user types `agents fleet`.
+    fleet: [loadSsh],
     pull: [loadPull],
     push: [loadPush],
+    // `repos` is the canonical command name; `repo` remains a convenience alias
+    // (see commands/repo.ts). List both so lazy registration loads the tree
+    // whichever the user types.
+    repos: [loadRepo],
     repo: [loadRepo],
     setup: [loadSetup],
     sessions: [loadSessions],
@@ -160,6 +172,10 @@ export const COMMAND_LOADERS = {
     cloud: [loadCloud],
     message: [loadMessage],
     feed: [loadFeed],
+    mailboxes: [loadMailboxes],
+    mailbox: [loadMailboxes],
     serve: [loadServe],
     audit: [loadAudit],
+    webhook: [loadWebhook],
+    funnel: [loadFunnel],
 };

package/dist/lib/state.d.ts

@@ -109,13 +109,21 @@ export declare function getCacheDir(): string;
 export declare function getPackagesDir(): string;
 /** Path to routine YAML definitions (~/.agents/routines/). */
 export declare function getRoutinesDir(): string;
+/**
+ * Path to built-in routine definitions shipped in the system repo
+ * (`~/.agents/.system/routines/`). Unioned under the user routines dir by
+ * listJobs()/readJob(): a routine shipped here fires for every install, and a
+ * user routine of the same name overrides it (a user copy with `enabled: false`
+ * disables the built-in). The daemon fires these; the directory need not exist.
+ */
+export declare function getSystemRoutinesDir(): 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.
+ * NOT fired by the daemon (which runs from $HOME and loads only user + system
+ * 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/). */

package/dist/lib/state.js

@@ -69,6 +69,10 @@ 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');
+// Built-in routines shipped in the system repo (gh:phnx-labs/.agents-system).
+// Unioned under user routines by listJobs()/readJob() so a routine shipped here
+// fires for every install, while a user routine of the same name overrides it.
+const SYSTEM_ROUTINES_DIR = path.join(SYSTEM_AGENTS_DIR, 'routines');
 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');
@@ -296,13 +300,21 @@ 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 built-in routine definitions shipped in the system repo
+ * (`~/.agents/.system/routines/`). Unioned under the user routines dir by
+ * listJobs()/readJob(): a routine shipped here fires for every install, and a
+ * user routine of the same name overrides it (a user copy with `enabled: false`
+ * disables the built-in). The daemon fires these; the directory need not exist.
+ */
+export function getSystemRoutinesDir() { return SYSTEM_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.
+ * NOT fired by the daemon (which runs from $HOME and loads only user + system
+ * routines). Opt-in firing for project routines is tracked as a follow-up.
  */
 export function getProjectRoutinesDir(cwd = process.cwd()) {
     const projectAgentsDir = getProjectAgentsDir(cwd);

package/dist/lib/subagents-registry.d.ts

@@ -0,0 +1,85 @@
+import type { AgentId, InstalledSubagent, SubagentFrontmatter } from './types.js';
+/** A path an installed subagent occupies, tagged for removal/trash handling. */
+export interface OccupiedEntry {
+    path: string;
+    kind: 'file' | 'dir';
+}
+/** Parsed metadata for one installed subagent (drives the rich listing). */
+export interface SubagentMeta {
+    frontmatter: SubagentFrontmatter;
+    files: string[];
+    /** Primary on-disk path for the listing's `path` field (a file or a dir, per layout). */
+    path: string;
+}
+/**
+ * The complete on-disk contract for one agent's subagents. Every operation is
+ * expressed here so the engine below never branches on the agent id.
+ */
+export interface SubagentTarget {
+    /** Absolute container dir under a home root (a version home or an agent home). */
+    dir(home: string): string;
+    /** Materialize central subagent `sub` into container `dir`. Throws on fs error. */
+    write(dir: string, sub: {
+        name: string;
+        path: string;
+    }): void;
+    /** Installed subagent names in `dir` (detector + orphan diff). */
+    names(dir: string): string[];
+    /** On-disk paths subagent `name` occupies (for removal / soft-delete). */
+    occupied(dir: string, name: string): OccupiedEntry[];
+    /** Rich metadata for `name`; `null` skips it from the listing. */
+    read(dir: string, name: string): SubagentMeta | null;
+    /** Optional post-sync pass over the just-synced subagents (Kimi's parent index). */
+    finalize?(dir: string, synced: Array<{
+        name: string;
+        path: string;
+    }>): void;
+}
+/**
+ * Copy every file in `src` into `dest` (created if missing), applying
+ * `rename` (source filename -> target filename) on the way. Directories in
+ * `src` are skipped -- subagents are flat file sets. Throws on fs error.
+ */
+export declare function copyDirWithRename(src: string, dest: string, rename?: Record<string, string>): void;
+/**
+ * Single source of truth for how each subagents-capable agent stores subagents.
+ * The keys MUST match `capableAgents('subagents')` (the `subagents` flag in
+ * `agents.ts`): the capability flag is the version gate, this table is the shape.
+ */
+export declare const SUBAGENT_TARGETS: Partial<Record<AgentId, SubagentTarget>>;
+/** The registry entry for `agent`, or undefined if it stores no subagents. */
+export declare function subagentTarget(agent: AgentId): SubagentTarget | undefined;
+/**
+ * Materialize central subagent `sub` into `home` for `agent`. Returns whether a
+ * write happened (false when the agent has no registry entry). Throws only on
+ * unexpected fs errors -- bulk callers wrap per-item.
+ */
+export declare function writeSubagentToHome(agent: AgentId, home: string, sub: {
+    name: string;
+    path: string;
+}): boolean;
+/** Installed subagent names for `agent` under `home` (detector + orphan diff). */
+export declare function listInstalledSubagentNames(agent: AgentId, home: string): string[];
+/**
+ * Rich listing of subagents installed for `agent` under `home`, with parsed
+ * metadata. Enumerates names, then reads each -- entries whose metadata is
+ * unreadable (per the target's reader) are dropped.
+ */
+export declare function listInstalledSubagentsRich(agent: AgentId, home: string): InstalledSubagent[];
+/**
+ * Remove subagent `name` for `agent` from `home` (hard delete). No-op success
+ * when the agent has no registry entry or nothing is installed.
+ */
+export declare function removeSubagentFromHome(agent: AgentId, home: string, name: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Soft-delete subagent `name` for `agent` from `home` into `trashDir`, stamping
+ * each moved entry. Files land as `<basename>.<stamp>`, directories as
+ * `<stamp>/`. No-op success when nothing is installed.
+ */
+export declare function trashSubagentFromHome(agent: AgentId, home: string, name: string, trashDir: string, stamp: string): {
+    success: boolean;
+    error?: string;
+};