@phnx-labs/agents-cli 1.20.60 → 1.20.62

package/dist/lib/routines.js

@@ -298,6 +298,24 @@ export function validateJob(config) {
             errors.push('workflow must be a lowercase alphanumeric name (hyphens and underscores allowed, e.g. autodev)');
         }
     }
+    if (config.resume !== undefined) {
+        // Only claude/codex support native `--resume`; other agents would emit a resume
+        // flag they don't understand. Resume reopens an agent session, so it is
+        // incompatible with workflow and loop jobs (which have no single session to reopen).
+        const RESUMABLE_AGENTS = ['claude', 'codex'];
+        if (typeof config.resume !== 'string' || config.resume.trim() === '') {
+            errors.push('resume must be a non-empty session id string');
+        }
+        if (hasWorkflow) {
+            errors.push('resume cannot be combined with workflow (resume reopens an existing agent session)');
+        }
+        if (config.loop) {
+            errors.push('resume cannot be combined with loop');
+        }
+        if (hasAgent && config.agent && !RESUMABLE_AGENTS.includes(config.agent)) {
+            errors.push(`resume is only supported for agents with native --resume (${RESUMABLE_AGENTS.join(', ')}); got '${config.agent}'`);
+        }
+    }
     if (config.mode && !['plan', 'edit', 'auto', 'skip', 'full'].includes(config.mode)) {
         errors.push("mode must be plan, edit, auto, or skip ('full' accepted as alias for skip)");
     }

package/dist/lib/runner.d.ts

@@ -50,6 +50,13 @@ export declare function resolveRoutineLaunch(config: JobConfig, cwd?: string): P
  * surface as "agents: no version of X configured".
  */
 export declare function pinJobBinary(cmd: string[], agent: AgentId, version: string | undefined): string[];
+/**
+ * Whether a job's command is dispatched through `agents run` (so `cmd[0] === 'agents'`)
+ * rather than the agent binary directly. True for workflow jobs and for resume jobs.
+ * Such commands must NOT be binary-pinned (pinning rewrites cmd[0] to the agent binary,
+ * producing a broken `<binary> run …`) and must not receive a version-pinned spawn env.
+ */
+export declare function dispatchesViaAgentsRun(config: Pick<JobConfig, 'workflow' | 'resume'>): boolean;
 /**
  * Merge sandbox/base env with the canonical per-version exec env
  * (CLAUDE_CONFIG_DIR / CODEX_HOME / …) so routines share account isolation

package/dist/lib/runner.js

@@ -44,6 +44,14 @@ export function buildJobCommand(config, resolvedPrompt) {
         const cmd = ['agents', 'run', config.workflow, resolvedPrompt, '--mode', config.mode];
         return cmd;
     }
+    // Resume branch: reopen an EXISTING session via `agents run <agent> --resume <id>`
+    // instead of starting fresh. The real session resumes with its full prior context
+    // (index-based lookup, cwd-independent) and `resolvedPrompt` becomes its next turn —
+    // so a self-scheduled wake (e.g. /hibernate) is handled by the session that scheduled
+    // it, not a fresh, context-less agent that would refuse an "opaque" instruction.
+    if (config.resume) {
+        return ['agents', 'run', config.agent, '--resume', config.resume, resolvedPrompt, '--mode', config.mode];
+    }
     const template = AGENT_COMMANDS[config.agent];
     if (!template) {
         throw new Error(`Unsupported agent for daemon jobs: ${config.agent}`);
@@ -263,6 +271,15 @@ export function pinJobBinary(cmd, agent, version) {
     next[0] = binary;
     return next;
 }
+/**
+ * Whether a job's command is dispatched through `agents run` (so `cmd[0] === 'agents'`)
+ * rather than the agent binary directly. True for workflow jobs and for resume jobs.
+ * Such commands must NOT be binary-pinned (pinning rewrites cmd[0] to the agent binary,
+ * producing a broken `<binary> run …`) and must not receive a version-pinned spawn env.
+ */
+export function dispatchesViaAgentsRun(config) {
+    return Boolean(config.workflow || config.resume);
+}
 /**
  * Merge sandbox/base env with the canonical per-version exec env
  * (CLAUDE_CONFIG_DIR / CODEX_HOME / …) so routines share account isolation
@@ -394,7 +411,11 @@ export async function executeJob(config, deps) {
         schedule: config.schedule,
     });
     const resolvedPrompt = resolveJobPrompt(config);
-    const useSandbox = config.sandbox !== false;
+    // Resume must run against the REAL home: `--resume <id>` resolves the session from
+    // the agent's config dir, and the sandbox overlay home has only a freshly-generated
+    // config with no session store. So a resume job is never sandboxed, regardless of
+    // `config.sandbox` (see the resume branch in buildJobCommand).
+    const useSandbox = config.sandbox !== false && !config.resume;
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = generateRunId();
     const runDir = getRunDir(config.name, runId);
@@ -470,10 +491,11 @@ export async function executeJob(config, deps) {
         if (i === 0) {
             process.stderr.write(`[agents] routine ${config.name}: running ${label}\n`);
         }
-        const cmd = config.workflow
+        const viaAgentsRun = dispatchesViaAgentsRun(config);
+        const cmd = viaAgentsRun
             ? baseCmd
             : pinJobBinary(baseCmd, attemptAgent, attemptVersion);
-        const spawnEnv = config.workflow
+        const spawnEnv = viaAgentsRun
             ? (() => {
                 const e = { ...baseEnv };
                 if (config.timezone)
@@ -553,10 +575,16 @@ export async function executeJobDetached(config) {
     const version = launch.chain[0]?.version ?? config.version;
     const resolvedPrompt = resolveJobPrompt(config);
     let cmd = buildJobCommand(config, resolvedPrompt);
-    if (!config.workflow && version) {
+    // workflow AND resume dispatch through `agents run` — never binary-pin them (pinning
+    // rewrites cmd[0] to the agent binary → broken `<binary> run …`).
+    if (!dispatchesViaAgentsRun(config) && version) {
         cmd = pinJobBinary(cmd, config.agent, version);
     }
-    const useSandbox = config.sandbox !== false;
+    // Resume must run against the REAL home: `--resume <id>` resolves the session from
+    // the agent's config dir, and the sandbox overlay home has only a freshly-generated
+    // config with no session store. So a resume job is never sandboxed, regardless of
+    // `config.sandbox` (see the resume branch in buildJobCommand).
+    const useSandbox = config.sandbox !== false && !config.resume;
     const overlayHome = useSandbox ? prepareJobHome(config) : undefined;
     const runId = generateRunId();
     const runDir = getRunDir(config.name, runId);
@@ -566,7 +594,7 @@ export async function executeJobDetached(config) {
     const baseEnv = useSandbox
         ? buildSpawnEnv(overlayHome)
         : { ...process.env };
-    const spawnEnv = config.workflow
+    const spawnEnv = dispatchesViaAgentsRun(config)
         ? (() => {
             const e = { ...baseEnv };
             if (config.timezone)

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

@@ -1,6 +1,6 @@
 import type { CloudTaskStatus } from '../cloud/types.js';
 import { type PidSessionEntry } from './pid-registry.js';
-import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
+import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type TodoProgress, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
 import type { SessionAttachment } from './types.js';
 import { type SessionProvenance } from './provenance.js';
 /**
@@ -46,6 +46,13 @@ export interface ActiveSession {
      * says whether it is still pending.
      */
     plan?: string;
+    /**
+     * Live plan progress from the most recent `TodoWrite` (RUSH-1380): the checklist
+     * items + a done/total tally + the current step. The Factory Floor renders this
+     * as an N/M pill + checklist for every session — including remote and
+     * device-dispatched agents that have no local tool-call stream to parse.
+     */
+    todos?: TodoProgress;
     /** Last few assistant turns (most-recent last), for at-a-glance context in the UI. */
     tail?: string[];
     /** PR opened during the session. */

package/dist/lib/session/active.js

@@ -267,6 +267,7 @@ function applyState(base, state, fallbackFile) {
         awaitingReason: state.awaitingReason,
         question: state.question,
         plan: state.plan,
+        todos: state.todos,
         tail: state.tail,
         // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
         preview: state.preview ?? base.preview,

package/dist/lib/session/parse.js

@@ -225,6 +225,18 @@ export function summarizeToolUse(tool, args) {
             const steps = Array.isArray(args.plan) ? args.plan.length : 0;
             return `Plan: ${steps} step${steps === 1 ? '' : 's'}`;
         }
+        // Claude's live checklist: show progress + the current step, not a bare "TodoWrite".
+        case 'TodoWrite': {
+            const todos = Array.isArray(args.todos) ? args.todos : [];
+            if (todos.length === 0)
+                return 'Plan: 0 steps';
+            const done = todos.filter((t) => t?.status === 'completed').length;
+            const active = todos.find((t) => t?.status === 'in_progress');
+            const step = active?.activeForm || active?.content;
+            return step
+                ? `Plan ${done}/${todos.length}: ${truncate(String(step), 80)}`
+                : `Plan: ${done}/${todos.length} done`;
+        }
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;

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

@@ -41,6 +41,28 @@ export interface StructuredQuestion {
     reason: AwaitingReason;
     options?: QuestionOption[];
 }
+/** One `TodoWrite` checklist item, as Claude's plan tool emits it. */
+export interface TodoItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    /** Present-continuous label shown while this item is the active step. */
+    activeForm?: string;
+}
+/**
+ * Live plan progress derived from the most recent `TodoWrite` in the transcript
+ * (RUSH-1380). Lets the Factory Floor show "N/M done" + the current step for any
+ * session — including remote / device-dispatched agents that carry no local
+ * tool-call stream — instead of only a coarse working/idle verb.
+ */
+export interface TodoProgress {
+    items: TodoItem[];
+    /** Count of completed items. */
+    done: number;
+    /** Total items. */
+    total: number;
+    /** The in-progress item's activeForm (falls back to its content). The live step. */
+    activeForm?: string;
+}
 export interface DetectedPr {
     url: string;
     number?: number;
@@ -88,6 +110,12 @@ export interface SessionState {
      * render the actual plan without re-parsing the transcript.
      */
     plan?: string;
+    /**
+     * Live plan progress from the most recent `TodoWrite` (RUSH-1380). Present when
+     * the session has written a todo list; drives the Factory Floor N/M pill +
+     * checklist, notably for remote/device-dispatched agents with no local stream.
+     */
+    todos?: TodoProgress;
     /** Last few assistant turns (most-recent last), one line each — panel context. */
     tail?: string[];
     lastActivityMs?: number;
@@ -111,6 +139,11 @@ export interface StateContext {
     /** Override the running window (defaults to 2 min, matching active.ts). */
     activeWindowMs?: number;
 }
+/**
+ * Derive live plan progress from a `TodoWrite` tool call's args. Returns undefined
+ * when there is no usable list, so a session with no plan carries no `todos` field.
+ */
+export declare function extractTodoProgress(args?: Record<string, any>): TodoProgress | undefined;
 /** Detect a worktree from the session cwd, per the `.agents/worktrees/<slug>/` convention. */
 export declare function detectWorktree(cwd?: string, branch?: string): DetectedWorktree | undefined;
 /** Detect a tracker ticket from free text (prompt/topic) then a branch name. */

package/dist/lib/session/state.js

@@ -47,6 +47,40 @@ const PROSE_QUESTION_FRESH_MS = 30 * 60_000;
 /** Claude tool names that structurally mean "the agent handed control back to you". */
 const PLAN_TOOL = 'ExitPlanMode';
 const ASK_TOOL = 'AskUserQuestion';
+/** Claude's live plan/checklist tool. */
+const TODO_TOOL = 'TodoWrite';
+/**
+ * Derive live plan progress from a `TodoWrite` tool call's args. Returns undefined
+ * when there is no usable list, so a session with no plan carries no `todos` field.
+ */
+export function extractTodoProgress(args) {
+    const raw = args?.todos;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const items = [];
+    for (const t of raw) {
+        const activeForm = typeof t?.activeForm === 'string' && t.activeForm ? t.activeForm : undefined;
+        const content = typeof t?.content === 'string' && t.content
+            ? t.content
+            : typeof t?.text === 'string' && t.text
+                ? t.text
+                : activeForm ?? '';
+        if (!content)
+            continue;
+        const status = t?.status === 'completed' || t?.status === 'in_progress' ? t.status : 'pending';
+        items.push(activeForm ? { content, status, activeForm } : { content, status });
+    }
+    if (items.length === 0)
+        return undefined;
+    const done = items.filter(i => i.status === 'completed').length;
+    const inProgress = items.find(i => i.status === 'in_progress');
+    return {
+        items,
+        done,
+        total: items.length,
+        activeForm: inProgress ? inProgress.activeForm ?? inProgress.content : undefined,
+    };
+}
 /** Trailing '?' or a leading interrogative — a question aimed at the user. */
 const QUESTION_TRAILING = /\?["'”)\]]?\s*$/;
 const QUESTION_PHRASE = /\b(shall i|should i|do you want|would you like|which (?:one|option|approach|of)|can you (?:confirm|clarify)|please (?:confirm|clarify|advise)|let me know|are you (?:ok|okay|sure)|proceed\?)\b/i;
@@ -281,12 +315,18 @@ export function inferActivity(events, ctx = {}) {
         .slice(-3)
         .map(e => oneLine(e.content ?? ''))
         .filter(Boolean);
+    // Live plan progress: the most recent TodoWrite's checklist (RUSH-1380). Attached
+    // to `base` so every return path below carries it — a working, waiting, or idle
+    // session all keep showing how far the plan got.
+    const lastTodo = lastOf(meaningful, e => e.type === 'tool_use' && e.tool === TODO_TOOL);
+    const todos = lastTodo ? extractTodoProgress(lastTodo.args) : undefined;
     const base = {
         activity: 'idle',
         lastRole: lastMsg?.role,
         lastEventKind: last?.type,
         lastActivityMs: ctx.mtimeMs,
         preview: previewSource ? describeEvent(previewSource) : undefined,
+        todos,
         tail: tail.length ? tail : undefined,
     };
     if (!last)

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

@@ -266,6 +266,28 @@ function buildKiroDetector() {
         },
     };
 }
+function buildOpenClawDetector() {
+    return {
+        kind: 'permissions',
+        agent: 'openclaw',
+        list({ versionHome }) {
+            const configPath = path.join(versionHome, '.openclaw', 'openclaw.json');
+            if (!fs.existsSync(configPath))
+                return [];
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                const tools = config.tools;
+                const hasAllow = Array.isArray(tools?.alsoAllow) && tools.alsoAllow.length > 0;
+                const hasDeny = Array.isArray(tools?.deny) && tools.deny.length > 0;
+                if (hasAllow || hasDeny) {
+                    return discoverPermissionGroups().map(g => g.name);
+                }
+            }
+            catch { /* parse fail */ }
+            return [];
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
     codex: buildCodexDetector,
@@ -278,6 +300,7 @@ const handlers = {
     cursor: buildCursorDetector,
     droid: buildDroidDetector,
     kiro: buildKiroDetector,
+    openclaw: buildOpenClawDetector,
 };
 export const permissionsDetectors = lazyAgentMap(() => {
     const m = {};

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

@@ -2,6 +2,8 @@
  * 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.
  */
@@ -74,6 +76,20 @@ function buildCopilotDetector() {
         },
     };
 }
+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',
@@ -117,6 +133,23 @@ function buildKiroDetector() {
         },
     };
 }
+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',
@@ -157,6 +190,9 @@ const handlers = {
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
     kiro: buildKiroDetector,
+    cursor: buildCursorDetector,
+    forge: buildForgeDetector,
+    goose: buildGooseDetector,
 };
 export const subagentsDetectors = lazyAgentMap(() => {
     const m = {};

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

@@ -3,6 +3,7 @@
  * containing WORKFLOW.md. Mirrors versions.ts:551-558.
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { capableAgents } from '../../capabilities.js';
@@ -36,6 +37,34 @@ function buildWorkflowsDetector(agent) {
                 })
                     .map(d => d.name);
             }
+            if (agent === 'antigravity') {
+                // Antigravity user workflows are HOME-global and shared across versions,
+                // not version-isolated — see workflows.ts:antigravityWorkflowsDir(). agy
+                // scans the real ~/.gemini/config/global_workflows/, so the detector reads
+                // the same shared dir the writer targets (versionHome is intentionally unused).
+                const dir = path.join(process.env.HOME ?? os.homedir(), '.gemini', 'config', 'global_workflows');
+                if (!fs.existsSync(dir))
+                    return [];
+                return fs.readdirSync(dir, { withFileTypes: true })
+                    .filter(d => d.isFile() && d.name.endsWith('.md') && !d.name.startsWith('.'))
+                    .filter(d => {
+                    try {
+                        const content = fs.readFileSync(path.join(dir, d.name), 'utf-8');
+                        const lines = content.split('\n');
+                        if (lines[0] !== '---')
+                            return false;
+                        const endIndex = lines.slice(1).findIndex(l => l === '---');
+                        if (endIndex < 0)
+                            return false;
+                        const parsed = yaml.parse(lines.slice(1, endIndex + 1).join('\n'));
+                        return parsed?.agents_workflow === d.name.slice(0, -'.md'.length);
+                    }
+                    catch {
+                        return false;
+                    }
+                })
+                    .map(d => d.name.slice(0, -'.md'.length));
+            }
             if (agent === 'goose') {
                 const recipesDir = path.join(versionHome, '.config', 'goose', 'recipes');
                 if (!fs.existsSync(recipesDir))

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

@@ -25,6 +25,7 @@ import { safeJoin } from '../../paths.js';
 import { markdownToToml } from '../../convert.js';
 import { commandAppliesTo, parseCommandMetadata } from '../../commands.js';
 import { installCommandSkillToVersion, shouldInstallCommandAsSkill } from '../../command-skills.js';
+import { installGooseCommandToVersion } from '../../goose-commands.js';
 import { resolveCommandSource, trustedSkillRoots } from './sources.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildCommandsWriter(agent) {
@@ -59,6 +60,12 @@ function buildCommandsWriter(agent) {
                     if (!installed.success)
                         continue;
                 }
+                else if (agent === 'goose') {
+                    // Goose: recipe YAML + config.yaml slash_commands entry, not a file copy.
+                    const installed = installGooseCommandToVersion(versionHome, cmd, srcFile);
+                    if (!installed.success)
+                        continue;
+                }
                 else if (agentConfig.format === 'toml') {
                     const content = fs.readFileSync(srcFile, 'utf-8');
                     const tomlContent = markdownToToml(cmd, content);

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

@@ -36,7 +36,7 @@ function buildHooksWriter(agent) {
             // 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') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced };

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

@@ -3,8 +3,9 @@
  * .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/`. OpenClaw copies the full subagent
- * directory (with AGENT.md renamed to AGENTS.md) into
+ * `<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 —
@@ -14,7 +15,7 @@
 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, transformSubagentForKiro, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.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 { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -83,6 +84,24 @@ function buildSubagentsWriter(agent) {
                         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);
+                    }
                 }
                 catch { /* per-item sync failure: skip */ }
             }

package/dist/lib/subagents.d.ts

@@ -68,6 +68,27 @@ export declare function transformSubagentForDroid(subagentDir: string): string;
  * See GitHub docs for custom agents.
  */
 export declare const transformSubagentForCopilot: typeof transformSubagentForDroid;
+/**
+ * Transform a subagent into a Cursor CLI custom subagent `.md` file.
+ *
+ * Cursor loads subagents from `.cursor/agents/*.md` (project) or
+ * `~/.cursor/agents/*.md` (user) — Markdown with YAML frontmatter
+ * (name, description, model; also readonly/is_background, which our
+ * frontmatter schema doesn't carry). Cursor has no `color` field, so this is
+ * an alias of transformSubagentForDroid, same as Copilot.
+ * See https://cursor.com/docs/subagents.
+ */
+export declare const transformSubagentForCursor: typeof transformSubagentForDroid;
+/**
+ * Transform a subagent into a ForgeCode custom subagent `.md` file.
+ *
+ * ForgeCode loads named agents from `.forge/agents/*.md` (project) or
+ * `~/.forge/agents/*.md` (user) — Markdown with YAML frontmatter (id, title,
+ * description, tools, model, temperature) + a system-prompt body. ForgeCode has
+ * no `color` field, so this is an alias of transformSubagentForDroid, same as
+ * Copilot/Cursor. See https://forgecode.dev/docs/agent-definition-guide/.
+ */
+export declare const transformSubagentForForge: typeof transformSubagentForDroid;
 /**
  * Transform a subagent into Antigravity's custom-agent markdown shape.
  *
@@ -138,6 +159,17 @@ export declare function transformSubagentForCodex(subagentDir: string): string;
  * set so the subagent can actually run.
  */
 export declare function transformSubagentForKiro(subagentDir: string): string;
+/**
+ * Transform a subagent into a Goose recipe YAML file.
+ *
+ * Goose has no dedicated subagent file format — a named subagent IS a recipe.
+ * Goose resolves named agents from `~/.config/goose/agents/<name>.yaml` (global)
+ * and delegates to them by name in autonomous mode. The recipe schema mirrors the
+ * one agents-cli already emits for Goose workflow recipes (`writeGooseSubrecipe`):
+ * `version`, `title`, `description`, `instructions`, `prompt`, plus an optional
+ * `settings.goose_model`. See goose-docs.ai context-engineering/subagents.
+ */
+export declare function transformSubagentForGoose(subagentDir: string): string;
 /**
  * Sync a subagent to an OpenClaw workspace
  * Copies full directory, renames AGENT.md to AGENTS.md