@phnx-labs/agents-cli 1.22.35 → 1.22.37

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

@@ -27,15 +27,8 @@ export interface SubagentTarget {
     names(dir: string): string[];
     /** On-disk paths subagent `name` occupies (for removal / soft-delete). */
     occupied(dir: string, name: string): OccupiedEntry[];
-    /** Cross-item files this target owns outside any one subagent's occupied paths. */
-    finalizeOccupied?(dir: 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

package/dist/lib/subagents-registry.js

@@ -14,16 +14,16 @@
  * every current agent, so most entries are a single call:
  *
  *   - `flatFile`  one `<name><ext>` file, body from a `transform` fn.
- *                 (claude, grok, droid, codex, opencode, copilot,
- *                  cursor, kiro, goose)
+ *                 (claude, grok, pi, droid, codex, opencode, copilot,
+ *                  cursor, kiro, goose, kimi)
  *   - `dirFile`   a `<name>/` directory holding one generated `<file>`.
  *                 (antigravity: `<name>/agent.md`)
  *   - `dirCopy`   copy the whole source directory to `<name>/`, applying
  *                 renames, detected by a `marker` file. (openclaw)
  *
- * Genuinely-bespoke agents keep an explicit handler in the same table -- Kimi
- * writes two files per subagent plus a managed parent index, so it is a hand
- * -written `SubagentTarget` rather than a builder call.
+ * Every agent now uses a builder; there are no bespoke handlers left. Legacy
+ * on-disk layouts are folded once by `lib/migrate.ts`, never by a target --
+ * a target describes the CURRENT shape and nothing else.
  *
  * The per-agent `transform`/metadata parsers are the escape hatch: they live in
  * `subagents.ts` and are referenced by the table, so the generic engine has zero
@@ -31,11 +31,12 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import * as TOML from 'smol-toml';
 import * as yaml from 'yaml';
 import { safeJoin } from './paths.js';
-import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, } from './subagents.js';
+import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, } from './subagents.js';
 // ── metadata readers (the per-format escape hatch) ───────────────────────────
-/** Frontmatter, skipping files that lack a valid block (claude/grok/droid/codex). */
+/** Frontmatter, skipping files that lack a valid block (claude/grok/droid). */
 function metaFrontmatterSkip(filePath) {
     return parseSubagentFrontmatter(filePath);
 }
@@ -63,6 +64,24 @@ function metaGooseYaml(filePath, name) {
         return null;
     }
 }
+/**
+ * Codex custom-agent TOML: name / description / model (optional).
+ * Codex writes no YAML frontmatter — without this reader, `flatFile.read`
+ * drops every installed `.toml` and `agents subagents list` reports codex
+ * targets as `missing` even when the files are present and Codex loads them.
+ */
+function metaToml(filePath, name) {
+    try {
+        const cfg = TOML.parse(fs.readFileSync(filePath, 'utf-8'));
+        const tomlName = typeof cfg.name === 'string' ? cfg.name : '';
+        const description = typeof cfg.description === 'string' ? cfg.description : '';
+        const model = typeof cfg.model === 'string' ? cfg.model : undefined;
+        return { name: tomlName || name, description, model };
+    }
+    catch {
+        return null;
+    }
+}
 // ── shared fs primitive ──────────────────────────────────────────────────────
 /**
  * Copy every file in `src` into `dest` (created if missing), applying
@@ -187,61 +206,6 @@ function dirCopy(opts) {
         },
     };
 }
-/**
- * Kimi (genuinely bespoke): each subagent is a `<name>.yaml` + sibling
- * `<name>.system.md`, and a managed `_agents-cli.yaml` parent lists them all for
- * `kimi --agent-file`. The parent index is a cross-item concern, so it is built
- * in `finalize`, not per-item.
- */
-const kimiTarget = {
-    dir: (home) => path.join(home, '.kimi-code', 'agents'),
-    write(dir, sub) {
-        writeKimiSubagentFiles(dir, sub.path, sub.name);
-    },
-    names(dir) {
-        if (!fs.existsSync(dir))
-            return [];
-        // The parent is `_agents-cli.yaml` (underscore-prefixed, reserved).
-        return fs
-            .readdirSync(dir)
-            .filter((f) => f.endsWith('.yaml') && !f.startsWith('_'))
-            .map((f) => f.slice(0, -'.yaml'.length));
-    },
-    occupied(dir, name) {
-        return [
-            { path: safeJoin(dir, `${name}.yaml`), kind: 'file' },
-            { path: safeJoin(dir, `${name}.system.md`), kind: 'file' },
-        ];
-    },
-    finalizeOccupied(dir) {
-        return [{ path: safeJoin(dir, KIMI_SUBAGENTS_PARENT_FILE), kind: 'file' }];
-    },
-    read(dir, name) {
-        const yamlPath = path.join(dir, `${name}.yaml`);
-        if (!fs.existsSync(yamlPath) || !fs.statSync(yamlPath).isFile())
-            return null;
-        let description = '';
-        try {
-            const parsed = yaml.parse(fs.readFileSync(yamlPath, 'utf-8'));
-            description = parsed?.agent?.description ?? '';
-        }
-        catch {
-            /* leave description empty */
-        }
-        const files = [`${name}.yaml`];
-        const promptFile = `${name}.system.md`;
-        if (fs.existsSync(path.join(dir, promptFile)))
-            files.push(promptFile);
-        return { frontmatter: { name, description }, files, path: yamlPath };
-    },
-    finalize(dir, synced) {
-        const entries = synced.map((sub) => {
-            const fm = parseSubagentFrontmatter(path.join(sub.path, 'AGENT.md'));
-            return { name: sub.name, description: fm?.description ?? sub.name, relativePath: `./${sub.name}.yaml` };
-        });
-        fs.writeFileSync(safeJoin(dir, KIMI_SUBAGENTS_PARENT_FILE), buildKimiSubagentsParentYaml(entries));
-    },
-};
 // ── the registry ─────────────────────────────────────────────────────────────
 /**
  * Single source of truth for how each subagents-capable agent stores subagents.
@@ -257,7 +221,12 @@ export const SUBAGENT_TARGETS = {
     pi: flatFile({ subdir: ['.omp', 'agent', 'agents'], ext: '.md', transform: transformSubagentForClaude, readMeta: metaFrontmatterFallback }),
     droid: flatFile({ subdir: ['.factory', 'droids'], ext: '.md', transform: transformSubagentForDroid }),
     // Bespoke frontmatter/format, still one flat file.
-    codex: flatFile({ subdir: ['.codex', 'agents'], ext: '.toml', transform: transformSubagentForCodex }),
+    codex: flatFile({
+        subdir: ['.codex', 'agents'],
+        ext: '.toml',
+        transform: transformSubagentForCodex,
+        readMeta: metaToml,
+    }),
     opencode: flatFile({
         subdir: ['.config', 'opencode', 'agents'],
         ext: '.md',
@@ -295,8 +264,12 @@ export const SUBAGENT_TARGETS = {
         transform: transformSubagentForAntigravity,
     }),
     openclaw: dirCopy({ subdir: ['.openclaw'], marker: 'AGENTS.md', rename: { 'AGENT.md': 'AGENTS.md' } }),
-    // Bespoke multi-file + parent index.
-    kimi: kimiTarget,
+    // Kimi discovers Claude-shaped agent markdown from its brand home's `agents/`
+    // dir (`USER_BRAND_DIRS = ["agents"]`, kimi-code >= 0.29.0). Frontmatter
+    // name/description + body, kebab-case name -- the same shape as claude/grok.
+    // The pre-markdown files agents-cli used to write here are swept once by
+    // `migrateKimiSubagentsToMarkdown` (lib/migrate.ts), not by this target.
+    kimi: flatFile({ subdir: ['.kimi-code', 'agents'], ext: '.md', transform: transformSubagentForClaude, readMeta: metaFrontmatterFallback }),
 };
 /** The registry entry for `agent`, or undefined if it stores no subagents. */
 export function subagentTarget(agent) {

package/dist/lib/subagents.d.ts

@@ -97,39 +97,6 @@ export declare function transformSubagentForAntigravity(subagentDir: string): st
  * 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.
  *

package/dist/lib/subagents.js

@@ -356,81 +356,6 @@ export function transformSubagentForOpenCode(subagentDir) {
     }
     return `---\n${yaml.stringify(fm).trim()}\n---\n\n${systemPrompt}\n`;
 }
-/** Managed parent agent file for Kimi (underscore prefix avoids clobbering a user subagent named agents-cli). */
-export const KIMI_SUBAGENTS_PARENT_FILE = '_agents-cli.yaml';
-/**
- * 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 function transformSubagentForKimi(subagentDir, fileBaseName) {
-    const agentMd = path.join(subagentDir, 'AGENT.md');
-    const frontmatter = parseSubagentFrontmatter(agentMd);
-    const body = getSubagentBody(agentMd);
-    if (!frontmatter) {
-        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
-    }
-    let systemPrompt = body.trim();
-    const files = fs.readdirSync(subagentDir)
-        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
-        .sort();
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
-        const sectionName = file.replace('.md', '');
-        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
-        systemPrompt += `\n\n## ${title}\n\n${content}`;
-    }
-    const systemPromptFileName = `${fileBaseName}.system.md`;
-    const doc = {
-        version: 1,
-        agent: {
-            extend: 'default',
-            name: frontmatter.name,
-            description: frontmatter.description,
-            system_prompt_path: `./${systemPromptFileName}`,
-        },
-    };
-    if (frontmatter.model) {
-        doc.agent.model = frontmatter.model;
-    }
-    return {
-        yaml: yaml.stringify(doc),
-        systemPrompt,
-        systemPromptFileName,
-    };
-}
-/**
- * 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 function buildKimiSubagentsParentYaml(entries) {
-    const subagents = {};
-    for (const e of entries) {
-        subagents[e.name] = { path: e.relativePath, description: e.description };
-    }
-    return yaml.stringify({
-        version: 1,
-        agent: {
-            extend: 'default',
-            name: 'agents-cli',
-            description: 'Managed parent agent listing agents-cli synced subagents',
-            subagents,
-        },
-    });
-}
-/** Write a Kimi subagent YAML + sibling system-prompt md into agentsDir. */
-export function writeKimiSubagentFiles(agentsDir, subagentDir, name) {
-    const { yaml: yml, systemPrompt, systemPromptFileName } = transformSubagentForKimi(subagentDir, name);
-    fs.mkdirSync(agentsDir, { recursive: true });
-    fs.writeFileSync(safeJoin(agentsDir, `${name}.yaml`), yml);
-    fs.writeFileSync(safeJoin(agentsDir, systemPromptFileName), systemPrompt);
-}
 /**
  * Transform a subagent into a Codex custom-agent TOML file.
  *

package/dist/lib/sync-umbrella.js

@@ -120,7 +120,7 @@ export async function runUmbrellaSync(args) {
         const { reconcilePendingSentinels } = await import('./devices/pending.js');
         const dev = await runDeviceSync({ soft: true, mode: 'refresh' });
         if (dev.ok)
-            reconcilePendingSentinels(dev.pending);
+            await reconcilePendingSentinels(dev.pending);
         result.devices = { synced: dev.synced, pending: dev.pending.length, skipped: !dev.ok };
         if (dev.ok) {
             log(`devices: ${dev.synced} refreshed${dev.pending.length ? `, ${dev.pending.length} new pending` : ''}`);

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

@@ -193,6 +193,7 @@ export declare class AgentProcess {
     cloudBranch: string | null;
     worktreeName: string | null;
     worktreePath: string | null;
+    project: string | null;
     hostName: string | null;
     hostTarget: string | null;
     hostIdentityFile: string | null;
@@ -304,6 +305,26 @@ export declare class AgentProcess {
      */
     private capEventsCache;
     saveMeta(): Promise<void>;
+    /**
+     * Rename an unreadable meta.json out of the way so it stops silently
+     * masquerading as "no record" (RUSH-2429). Before saveMeta() wrote atomically,
+     * a process killed mid-write left a truncated, unparseable meta.json that
+     * loadFromDisk() returned null for -- indistinguishable from ENOENT -- so
+     * retention (loadExistingAgents/rescanFromDisk) never reaped it and
+     * isWorktreeClaimed() (which reads meta.json directly, not through this
+     * method) failed CLOSED on it forever: it scans every record and answers
+     * "claimed" for every worktree name in every team the first time it cannot
+     * read one. Quarantining removes meta.json so the NEXT read of this record
+     * sees ENOENT (genuinely absent) instead of "unreadable" -- that is what lets
+     * isWorktreeClaimed's fail-closed guard recover once the corrupt record is
+     * gone, without weakening the guard itself for a record that is still
+     * present-but-unreadable at decision time.
+     *
+     * Best-effort: if the rename itself fails (e.g. EACCES on the directory),
+     * the record is left in place and the fail-closed guard keeps protecting
+     * worktree removal -- quarantine only ever ADDS a recovery path.
+     */
+    private static quarantineCorruptMeta;
     static loadFromDisk(agentId: string, baseDir?: string | null): Promise<AgentProcess | null>;
     isProcessAlive(): boolean;
     /**
@@ -478,7 +499,7 @@ export declare class AgentManager {
      *   asymmetry, not defensive coding: the caller acts destructively on `false`.
      */
     isWorktreeClaimed(worktreeName: string): Promise<boolean>;
-    spawn(taskName: string, agentType: AgentType, prompt: string, cwd?: string | null, mode?: Mode | null, effort?: EffortLevel, parentSessionId?: string | null, workspaceDir?: string | null, version?: string | null, name?: string | null, after?: string[], model?: string | null, envOverrides?: Record<string, string> | null, taskType?: TaskType | null, cloudProvider?: string | null, cloudSessionId?: string | null, cloudRepo?: string | null, cloudBranch?: string | null, worktreeName?: string | null, worktreePath?: string | null, profileName?: string | null, hostName?: string | null, hostTarget?: string | null, repoPath?: string | null): Promise<AgentProcess>;
+    spawn(taskName: string, agentType: AgentType, prompt: string, cwd?: string | null, mode?: Mode | null, effort?: EffortLevel, parentSessionId?: string | null, workspaceDir?: string | null, version?: string | null, name?: string | null, after?: string[], model?: string | null, envOverrides?: Record<string, string> | null, taskType?: TaskType | null, cloudProvider?: string | null, cloudSessionId?: string | null, cloudRepo?: string | null, cloudBranch?: string | null, worktreeName?: string | null, worktreePath?: string | null, profileName?: string | null, hostName?: string | null, hostTarget?: string | null, repoPath?: string | null, project?: string | null): Promise<AgentProcess>;
     /**
      * Resume a STOPPED teammate (completed / failed / stopped) by re-entering its
      * own session with `message` as the next user turn. Re-launches through the
@@ -613,6 +634,25 @@ export declare class AgentManager {
      */
     listCompleted(): Promise<AgentProcess[]>;
     listByTask(taskName: string): Promise<AgentProcess[]>;
+    /**
+     * Terminal removal of every teammate record for a team (RUSH-2450).
+     *
+     * `teams disband` used to delete log dirs and the registry entry, but left
+     * the in-memory AgentProcess cache intact. A concurrent `teams start --watch`
+     * supervisor then re-persisted those records via saveMeta, so a second
+     * disband still found N logs to clear and `teams start` could re-launch
+     * PENDING work that had already merged.
+     *
+     * This drops every matching record from the manager map AND removes its
+     * durable state. With `keepLogs`, only `meta.json` is removed so the
+     * teammate is no longer discoverable/startable while stdout/stderr logs
+     * remain for postmortem.
+     *
+     * Returns the agent_ids that were purged.
+     */
+    purgeByTask(taskName: string, opts?: {
+        keepLogs?: boolean;
+    }): Promise<string[]>;
     listByParentSession(parentSessionId: string): Promise<AgentProcess[]>;
     stopByTask(taskName: string): Promise<{
         stopped: string[];