@phnx-labs/agents-cli 1.20.52 → 1.20.53

package/dist/lib/session/tail.d.ts

@@ -8,11 +8,30 @@
  * chunk to the existing content parsers so there's zero duplicated parse logic.
  */
 import type { SessionAgentId, SessionEvent } from './types.js';
+/** A tail read: the last few normalized events plus the raw text they came from. */
+export interface SessionTail {
+    events: SessionEvent[];
+    /** The raw JSONL chunk (leading partial line dropped), for content-level math. */
+    content: string;
+}
+/**
+ * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
+ * begins mid-file yields one malformed leading line, which is dropped here so
+ * downstream per-line parsers only see whole lines. Returns '' on any error or
+ * empty file.
+ */
+export declare function readSessionTailContent(filePath: string, maxBytes?: number): string;
 /**
  * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events. A tail that begins mid-line yields one
- * malformed leading line, which the per-line JSON try/catch in the content
- * parsers skips. Only Claude and Codex are supported (the prioritized harnesses
- * for live state); other agents return `[]`.
+ * `maxEvents` normalized events *and* the raw text they were parsed from — the
+ * raw text feeds content-level readouts (e.g. token throughput) that need the
+ * lines the event model discards (Codex `token_count`). Only Claude and Codex
+ * are supported (the prioritized harnesses for live state); other agents return
+ * an empty tail.
+ */
+export declare function readSessionTailWithRaw(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionTail;
+/**
+ * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
+ * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
  */
 export declare function readSessionTail(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionEvent[];

package/dist/lib/session/tail.js

@@ -12,26 +12,23 @@ import { parseClaudeContent, parseCodexContent, sanitizeEvents } from './parse.j
 const DEFAULT_MAX_BYTES = 128 * 1024;
 const DEFAULT_MAX_EVENTS = 60;
 /**
- * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events. A tail that begins mid-line yields one
- * malformed leading line, which the per-line JSON try/catch in the content
- * parsers skips. Only Claude and Codex are supported (the prioritized harnesses
- * for live state); other agents return `[]`.
+ * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
+ * begins mid-file yields one malformed leading line, which is dropped here so
+ * downstream per-line parsers only see whole lines. Returns '' on any error or
+ * empty file.
  */
-export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
-    if (agent !== 'claude' && agent !== 'codex')
-        return [];
+export function readSessionTailContent(filePath, maxBytes = DEFAULT_MAX_BYTES) {
     let fd;
     try {
         fd = fs.openSync(filePath, 'r');
     }
     catch {
-        return [];
+        return '';
     }
     try {
         const size = fs.fstatSync(fd).size;
         if (size === 0)
-            return [];
+            return '';
         const start = Math.max(0, size - maxBytes);
         const len = size - start;
         const buf = Buffer.alloc(len);
@@ -42,16 +39,37 @@ export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, m
             const nl = content.indexOf('\n');
             content = nl >= 0 ? content.slice(nl + 1) : '';
         }
-        if (!content.trim())
-            return [];
-        const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
-        sanitizeEvents(events);
-        return events.length > maxEvents ? events.slice(-maxEvents) : events;
+        return content;
     }
     catch {
-        return [];
+        return '';
     }
     finally {
         fs.closeSync(fd);
     }
 }
+/**
+ * Read the last `maxBytes` of a JSONL transcript and return its last
+ * `maxEvents` normalized events *and* the raw text they were parsed from — the
+ * raw text feeds content-level readouts (e.g. token throughput) that need the
+ * lines the event model discards (Codex `token_count`). Only Claude and Codex
+ * are supported (the prioritized harnesses for live state); other agents return
+ * an empty tail.
+ */
+export function readSessionTailWithRaw(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
+    if (agent !== 'claude' && agent !== 'codex')
+        return { events: [], content: '' };
+    const content = readSessionTailContent(filePath, maxBytes);
+    if (!content.trim())
+        return { events: [], content: '' };
+    const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
+    sanitizeEvents(events);
+    return { events: events.length > maxEvents ? events.slice(-maxEvents) : events, content };
+}
+/**
+ * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
+ * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
+ */
+export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
+    return readSessionTailWithRaw(filePath, agent, maxBytes, maxEvents).events;
+}

package/dist/lib/session/throughput.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Live output-token throughput.
+ *
+ * Computes a rolling tokens-per-second readout from a session transcript's raw
+ * content. This is the single source of truth for the throughput number the
+ * Factory Floor shows next to a running agent — the extension used to carry its
+ * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
+ * straight off `agents sessions --active --json` instead (issue #741).
+ */
+/** Agents whose transcript formats report per-turn output-token usage. */
+export type ThroughputAgent = 'claude' | 'codex' | 'gemini';
+/** Rolling window (seconds) the throughput average is computed over. */
+export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+/**
+ * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
+ *
+ * Sums output tokens (plus reasoning/thoughts tokens when the format reports
+ * them separately) from entries whose timestamp falls within the window, and
+ * divides by the window length.
+ *
+ * Formats:
+ *   - Claude: JSONL. Each assistant turn is `{type: 'assistant', timestamp,
+ *     message: {usage: {output_tokens}}}`.
+ *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
+ *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
+ *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
+ *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
+ *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
+ */
+export declare function computeTokPerSec(sessionContent: string, agent: ThroughputAgent, windowSec?: number, now?: number): number;

package/dist/lib/session/throughput.js

@@ -0,0 +1,86 @@
+/**
+ * Live output-token throughput.
+ *
+ * Computes a rolling tokens-per-second readout from a session transcript's raw
+ * content. This is the single source of truth for the throughput number the
+ * Factory Floor shows next to a running agent — the extension used to carry its
+ * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
+ * straight off `agents sessions --active --json` instead (issue #741).
+ */
+/** Rolling window (seconds) the throughput average is computed over. */
+export const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+/**
+ * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
+ *
+ * Sums output tokens (plus reasoning/thoughts tokens when the format reports
+ * them separately) from entries whose timestamp falls within the window, and
+ * divides by the window length.
+ *
+ * Formats:
+ *   - Claude: JSONL. Each assistant turn is `{type: 'assistant', timestamp,
+ *     message: {usage: {output_tokens}}}`.
+ *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
+ *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
+ *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
+ *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
+ *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
+ */
+export function computeTokPerSec(sessionContent, agent, windowSec = DEFAULT_THROUGHPUT_WINDOW_SEC, now = Date.now()) {
+    const cutoff = now - windowSec * 1000;
+    let total = 0;
+    if (agent === 'gemini') {
+        try {
+            const d = JSON.parse(sessionContent);
+            const messages = Array.isArray(d?.messages) ? d.messages : [];
+            for (const m of messages) {
+                if (m?.type !== 'gemini')
+                    continue;
+                const ts = typeof m.timestamp === 'string' ? Date.parse(m.timestamp) : 0;
+                if (!ts || ts < cutoff)
+                    continue;
+                const out = typeof m?.tokens?.output === 'number' ? m.tokens.output : 0;
+                const thoughts = typeof m?.tokens?.thoughts === 'number' ? m.tokens.thoughts : 0;
+                total += out + thoughts;
+            }
+        }
+        catch { /* malformed gemini file → 0 */ }
+        return total / windowSec;
+    }
+    const lines = sessionContent.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line || line[0] !== '{')
+            continue;
+        if (!line.includes('output_tokens'))
+            continue;
+        try {
+            const d = JSON.parse(line);
+            const ts = typeof d.timestamp === 'string' ? Date.parse(d.timestamp) : 0;
+            if (!ts)
+                continue;
+            if (ts < cutoff)
+                break;
+            if (agent === 'claude') {
+                if (d?.type !== 'assistant')
+                    continue;
+                const out = typeof d?.message?.usage?.output_tokens === 'number' ? d.message.usage.output_tokens : 0;
+                total += out;
+            }
+            else {
+                if (d?.type !== 'event_msg')
+                    continue;
+                const payload = d?.payload;
+                if (payload?.type !== 'token_count')
+                    continue;
+                const last = payload?.info?.last_token_usage;
+                if (!last)
+                    continue;
+                const out = typeof last.output_tokens === 'number' ? last.output_tokens : 0;
+                const reasoning = typeof last.reasoning_output_tokens === 'number' ? last.reasoning_output_tokens : 0;
+                total += out + reasoning;
+            }
+        }
+        catch { /* skip malformed line */ }
+    }
+    return total / windowSec;
+}

package/dist/lib/shim-heal.d.ts

@@ -1,7 +1,16 @@
+import type { SelfHealReport } from './self-heal/types.js';
+export interface InteractiveShimHealResult {
+    noticeLines: string[] | null;
+    report: SelfHealReport;
+}
 /**
- * Heal the shim/shadow/PATH conditions silently, then return the notice lines to
- * print ONCE for whatever is left (a real-binary shadow we won't move; a PATH entry
- * that was just added / needs a reload), or null when there's nothing new to say.
+ * Heal the shim/shadow/PATH conditions silently, then return both the raw report
+ * and the notice lines to print ONCE for whatever is left (a real-binary shadow we
+ * won't move; a PATH entry that was just added / needs a reload).
+ */
+export declare function runInteractiveShimHeal(): Promise<InteractiveShimHealResult>;
+/**
+ * Back-compat wrapper for callers that only need the persistent one-time notice.
  */
 export declare function healShimsInteractive(): Promise<string[] | null>;
 type PathNoticeState = 'ok' | 'added' | 'reload';

package/dist/lib/shim-heal.js

@@ -12,11 +12,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getRuntimeStateDir } from './state.js';
 /**
- * Heal the shim/shadow/PATH conditions silently, then return the notice lines to
- * print ONCE for whatever is left (a real-binary shadow we won't move; a PATH entry
- * that was just added / needs a reload), or null when there's nothing new to say.
+ * Heal the shim/shadow/PATH conditions silently, then return both the raw report
+ * and the notice lines to print ONCE for whatever is left (a real-binary shadow we
+ * won't move; a PATH entry that was just added / needs a reload).
  */
-export async function healShimsInteractive() {
+export async function runInteractiveShimHeal() {
     const { runSelfHeal } = await import('./self-heal/registry.js');
     const report = await runSelfHeal({ checks: ['shims', 'shadowing', 'path'], mode: 'safe' });
     const shadowNotes = [];
@@ -37,7 +37,7 @@ export async function healShimsInteractive() {
     const pathState = pathAdded ? 'added' : pathReload ? 'reload' : 'ok';
     const signature = computeShimNoticeSignature({ shadowNotes, pathState });
     if (!shouldSurfaceShimNotice(signature))
-        return null;
+        return { noticeLines: null, report };
     const lines = [];
     if (pathAdded) {
         lines.push(pathAdded);
@@ -52,7 +52,13 @@ export async function healShimsInteractive() {
             lines.push(`  ${note}`);
         lines.push("It's a real binary (not a symlink), so agents-cli won't move it — reorder PATH or remove it to hand it over.");
     }
-    return lines.length > 0 ? lines : null;
+    return { noticeLines: lines.length > 0 ? lines : null, report };
+}
+/**
+ * Back-compat wrapper for callers that only need the persistent one-time notice.
+ */
+export async function healShimsInteractive() {
+    return (await runInteractiveShimHeal()).noticeLines;
 }
 function noticeStatePath() {
     return path.join(getRuntimeStateDir(), 'shim-notice.json');

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

@@ -1,5 +1,6 @@
 /**
  * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * Codex: flat .toml files under `<versionHome>/.codex/agents/`.
  * Droid: flat .md files under `<versionHome>/.factory/droids/`.
  * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
  * Mirrors versions.ts:521-539.
@@ -8,12 +9,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
-function buildClaudeDetector() {
+function buildFlatMdAgentsDetector(agent, agentsRoot) {
     return {
         kind: 'subagents',
-        agent: 'claude',
+        agent,
         list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.claude', 'agents');
+            const agentsDir = path.join(versionHome, agentsRoot, 'agents');
             if (!fs.existsSync(agentsDir))
                 return [];
             return fs.readdirSync(agentsDir)
@@ -22,6 +23,26 @@ function buildClaudeDetector() {
         },
     };
 }
+function buildClaudeDetector() {
+    return buildFlatMdAgentsDetector('claude', '.claude');
+}
+function buildGrokDetector() {
+    return buildFlatMdAgentsDetector('grok', '.grok');
+}
+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',
@@ -50,8 +71,41 @@ function buildOpenclawDetector() {
         },
     };
 }
+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 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$/, ''));
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
+    grok: buildGrokDetector,
+    codex: buildCodexDetector,
+    kimi: buildKimiDetector,
+    opencode: buildOpenCodeDetector,
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
 };

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

@@ -30,9 +30,13 @@ function buildHooksWriter(agent) {
                 fs.chmodSync(destFile, 0o755);
                 synced.push(hook);
             }
-            // Native hook registration in settings.json/hooks.json. Grok auto-
-            // discovers from ~/.grok/hooks/ so the file copy is sufficient.
-            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid') {
+            // Native hook registration in settings.json/hooks.json. Grok is included
+            // so subrule-bundled guards (absolute paths outside the central hooks/
+            // copy set) get registered into ~/.grok/hooks/hooks.json via
+            // registerHooksForGrok — file copy alone only sees top-level available.hooks
+            // names (RUSH-1353). Copilot/Kiro/Goose load managed *.json under their
+            // hooks dirs the same way.
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced };

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

@@ -1,8 +1,9 @@
 /**
  * Subagents writer. Claude flattens each subagent into a single .md file
- * under `<agentDir>/agents/`. Droid (Factory AI) flattens each into a custom
- * droid .md under `<versionHome>/.factory/droids/`. OpenClaw copies the full
- * subagent directory (with AGENT.md renamed to AGENTS.md) into
+ * under `<agentDir>/agents/`. Codex writes TOML under `.codex/agents/`.
+ * Droid (Factory AI) flattens each into a custom droid .md under
+ * `<versionHome>/.factory/droids/`. 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 —
@@ -12,7 +13,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForDroid, syncSubagentToOpenclaw } from '../../subagents.js';
+import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
 import { safeJoin } from '../../paths.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -28,12 +29,28 @@ function buildSubagentsWriter(agent) {
                 if (!sub)
                     continue;
                 try {
-                    if (agent === 'claude') {
-                        const agentsDir = path.join(versionHome, '.claude', 'agents');
+                    if (agent === 'claude' || agent === 'grok') {
+                        const agentsDir = path.join(versionHome, agent === 'grok' ? '.grok' : '.claude', '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 === 'droid') {
                         const droidsDir = path.join(versionHome, '.factory', 'droids');
                         fs.mkdirSync(droidsDir, { recursive: true });
@@ -49,6 +66,20 @@ function buildSubagentsWriter(agent) {
                 }
                 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));
+            }
             return { synced };
         },
     };

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

@@ -30,6 +30,7 @@ export declare const loadCommands: ModuleLoader;
 export declare const loadHooks: ModuleLoader;
 export declare const loadSkills: ModuleLoader;
 export declare const loadRules: ModuleLoader;
+export declare const loadMemory: ModuleLoader;
 export declare const loadPermissions: ModuleLoader;
 export declare const loadMcp: ModuleLoader;
 export declare const loadCli: ModuleLoader;

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

@@ -8,6 +8,7 @@ export const loadCommands = async () => (await import('../../commands/commands.j
 export const loadHooks = async () => (await import('../../commands/hooks.js')).registerHooksCommands;
 export const loadSkills = async () => (await import('../../commands/skills.js')).registerSkillsCommands;
 export const loadRules = async () => (await import('../../commands/rules.js')).registerRulesCommands;
+export const loadMemory = async () => (await import('../../commands/memory.js')).registerMemoryCommands;
 export const loadPermissions = async () => (await import('../../commands/permissions.js')).registerPermissionsCommands;
 export const loadMcp = async () => (await import('../../commands/mcp.js')).registerMcpCommands;
 export const loadCli = async () => (await import('../../commands/cli.js')).registerCliCommands;
@@ -94,6 +95,7 @@ export const COMMAND_LOADERS = {
     hooks: [loadHooks],
     skills: [loadSkills],
     rules: [loadRules],
+    memory: [loadMemory],
     permissions: [loadPermissions],
     mcp: [loadMcp],
     cli: [loadCli],

package/dist/lib/subagents.d.ts

@@ -56,6 +56,57 @@ export declare function transformSubagentForClaude(subagentDir: string): string;
  * See https://docs.factory.ai/cli/configuration/custom-droids.
  */
 export declare function transformSubagentForDroid(subagentDir: string): string;
+/**
+ * Transform a subagent into an OpenCode agent markdown file.
+ *
+ * OpenCode loads agents from ~/.config/opencode/agents/*.md (global) with
+ * YAML frontmatter (description required; mode: subagent for invocable
+ * subagents) and a prompt body. File stem becomes the agent name.
+ * https://opencode.ai/docs/agents/
+ */
+export declare function transformSubagentForOpenCode(subagentDir: string): string;
+/** Managed parent agent file for Kimi (underscore prefix avoids clobbering a user subagent named agents-cli). */
+export declare const KIMI_SUBAGENTS_PARENT_FILE = "_agents-cli.yaml";
+export interface KimiSubagentFiles {
+    /** Agent YAML content (uses system_prompt_path, not inline system_prompt). */
+    yaml: string;
+    /** Markdown body written next to the YAML and referenced by system_prompt_path. */
+    systemPrompt: string;
+    /** Sibling prompt filename, e.g. `reviewer.system.md`. */
+    systemPromptFileName: string;
+}
+/**
+ * Transform a subagent into Kimi Code agent files.
+ *
+ * Kimi's schema (agentspec) only accepts `system_prompt_path` (path relative to
+ * the agent YAML) — there is no inline `system_prompt` key. We write:
+ *   ~/.kimi-code/agents/<name>.yaml          — agent YAML
+ *   ~/.kimi-code/agents/<name>.system.md     — system prompt body
+ * plus a managed parent `_agents-cli.yaml` that lists them under agent.subagents
+ * for `kimi --agent-file …/_agents-cli.yaml`.
+ * https://moonshotai.github.io/kimi-cli/en/customization/agents.html
+ */
+export declare function transformSubagentForKimi(subagentDir: string, fileBaseName: string): KimiSubagentFiles;
+/**
+ * Build the managed parent agent YAML that declares all installed subagents
+ * so `kimi --agent-file ~/.kimi-code/agents/_agents-cli.yaml` can launch them.
+ */
+export declare function buildKimiSubagentsParentYaml(entries: Array<{
+    name: string;
+    description: string;
+    relativePath: string;
+}>): string;
+/** Write a Kimi subagent YAML + sibling system-prompt md into agentsDir. */
+export declare function writeKimiSubagentFiles(agentsDir: string, subagentDir: string, name: string): void;
+/**
+ * Transform a subagent into a Codex custom-agent TOML file.
+ *
+ * Codex loads standalone TOML under ~/.codex/agents/*.toml. Required fields:
+ * name, description, developer_instructions. Optional model maps from our
+ * frontmatter when present.
+ * https://developers.openai.com/codex/subagents (custom agents section)
+ */
+export declare function transformSubagentForCodex(subagentDir: string): string;
 /**
  * Sync a subagent to an OpenClaw workspace
  * Copies full directory, renames AGENT.md to AGENTS.md
@@ -85,6 +136,7 @@ export declare function subagentContentMatches(installedDir: string, sourceDir:
 /**
  * List subagents installed to a specific agent's home
  * Claude: scans ~/.claude/agents/{name}.md
+ * Kimi: scans ~/.kimi-code/agents/{name}.yaml (+ sibling .system.md)
  * OpenClaw: scans ~/.openclaw/{name}/AGENTS.md
  */
 export declare function listSubagentsForAgent(agentId: AgentId, home: string): InstalledSubagent[];