@phnx-labs/agents-cli 1.20.63 → 1.20.65

package/dist/lib/ssh-tunnel.js

@@ -24,7 +24,7 @@ import { fileURLToPath } from 'url';
 import { randomBytes, createHash } from 'crypto';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
-import { sshExec, SSH_OPTS } from './ssh-exec.js';
+import { sshExec, SSH_OPTS, assertValidSshTarget } from './ssh-exec.js';
 import { backgroundSpawnOptions } from './platform/process.js';
 import { encodePowerShell } from './browser/drivers/ssh.js';
 import { getDevice } from './devices/registry.js';
@@ -57,6 +57,18 @@ export function buildTunnelArgs(user, host, localPort, remotePort) {
  */
 export function startSSHTunnel(user, host, localPort, remotePort, opts = {}) {
     return new Promise((resolve, reject) => {
+        // `user`/`host` can originate from a browser ssh:// profile or a device
+        // record. buildTunnelArgs places `${user}@${host}` before `-N`/SSH_OPTS, so
+        // a `-`-leading user would be parsed as an ssh option flag (option
+        // injection). Validate at the spawn sink so every caller is covered; reject
+        // (rather than throw synchronously) to keep the Promise contract.
+        try {
+            assertValidSshTarget(`${user}@${host}`);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         const args = buildTunnelArgs(user, host, localPort, remotePort);
         const tunnel = spawn('ssh', args, {
             stdio: opts.detached ? 'ignore' : ['ignore', 'ignore', 'pipe'],
@@ -91,6 +103,8 @@ export const REMOTE_HELPER_PORT = 8765;
 export const REMOTE_TASK_NAME = 'AgentsComputerHelper';
 /** Basename of the cross-published exe under native/computer-win/dist. */
 export const WIN_HELPER_EXE = 'computer-helper-win.exe';
+/** Basename of the daemon's shared-secret token file under %LOCALAPPDATA%\agents. */
+export const WIN_HELPER_TOKEN_FILE = 'helper-token';
 /**
  * Locate a locally built Windows daemon exe — a repo-checkout build output from
  * `scripts/build-win.sh`, or one bundled next to the package. Local paths are
@@ -222,6 +236,37 @@ export function clearRemoteState(device) {
         /* already gone */
     }
 }
+/**
+ * Local file holding the shared-secret token for a device's helper daemon.
+ * Written at `setup --host` (0600), read at `start --host` so the RPC client
+ * authenticates. The remote daemon reads the same value from its own
+ * `--token-file`; the CLI is the source of truth and never round-trips it back.
+ */
+export function helperTokenPath(device) {
+    return path.join(remoteStateDir(), `${device}.token`);
+}
+export function readHelperToken(device) {
+    try {
+        const t = fs.readFileSync(helperTokenPath(device), 'utf-8').trim();
+        return t.length > 0 ? t : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeHelperToken(device, token) {
+    const dir = remoteStateDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(helperTokenPath(device), token, { mode: 0o600 });
+}
+export function clearHelperToken(device) {
+    try {
+        fs.unlinkSync(helperTokenPath(device));
+    }
+    catch {
+        /* already gone */
+    }
+}
 /** Resolve a registered device to its ssh pieces, or throw a clear error. */
 export async function resolveRemoteDevice(name) {
     const device = await getDevice(name);
@@ -272,10 +317,26 @@ export function buildVerifyPushScript(remotePath, expectedBytes) {
  * survives ssh disconnect — the same rationale as the browser WMI launch. The
  * task is started immediately so the caller need not log out/in.
  */
-export function buildRegisterTaskScript(port, taskName) {
+/**
+ * PowerShell that writes the shared-secret token under %LOCALAPPDATA%\agents
+ * with an owner-only ACL (inheritance removed, read granted only to the current
+ * user) and echoes the resolved path so the caller can pass it to `--token-file`.
+ */
+export function buildWriteTokenScript(token) {
+    return [
+        `$dir = Join-Path $env:LOCALAPPDATA 'agents'`,
+        `New-Item -ItemType Directory -Force -Path $dir | Out-Null`,
+        `$tok = Join-Path $dir '${WIN_HELPER_TOKEN_FILE}'`,
+        `Set-Content -LiteralPath $tok -Value ${psSingleQuote(token)} -NoNewline -Encoding ascii`,
+        `icacls $tok /inheritance:r /grant:r ("$($env:USERNAME):(R)") | Out-Null`,
+        `Write-Output $tok`,
+    ].join('; ');
+}
+export function buildRegisterTaskScript(port, taskName, tokenPath) {
+    const argument = `--port ${port} --token-file "${tokenPath}"`;
     return [
         `$exe = Join-Path (Join-Path $env:LOCALAPPDATA 'agents') '${WIN_HELPER_EXE}'`,
-        `$action = New-ScheduledTaskAction -Execute $exe -Argument '--port ${port}'`,
+        `$action = New-ScheduledTaskAction -Execute $exe -Argument ${psSingleQuote(argument)}`,
         `$trigger = New-ScheduledTaskTrigger -AtLogOn`,
         `$principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive -RunLevel Highest`,
         `$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit ([TimeSpan]::Zero)`,
@@ -357,13 +418,28 @@ export async function setupRemoteHelper(name) {
     if (verify.code !== 0) {
         throw new Error(`verifying helper exe on '${name}' failed (exit ${verify.code ?? 'null'}): ${verify.stderr.trim() || verify.stdout.trim()}`);
     }
-    // Register + start the LOGON task.
-    const reg = sshExec(target, encodePowerShell(buildRegisterTaskScript(REMOTE_HELPER_PORT, REMOTE_TASK_NAME)), {
+    // Provision the auth token: generate it locally, write it on the remote with
+    // an owner-only ACL, and register the task with --token-file. The daemon now
+    // refuses to start without a token, so a token-less (open-to-any-local-process)
+    // daemon can no longer be stood up through the CLI.
+    const token = generateToken();
+    const tokWrite = sshExec(target, encodePowerShell(buildWriteTokenScript(token)), { timeoutMs: 60_000 });
+    if (tokWrite.code !== 0) {
+        throw new Error(`writing helper token on '${name}' failed (exit ${tokWrite.code ?? 'null'}): ${tokWrite.stderr.trim() || tokWrite.stdout.trim()}`);
+    }
+    const remoteTokenPath = tokWrite.stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (!remoteTokenPath) {
+        throw new Error(`writing helper token on '${name}' did not return a destination path`);
+    }
+    // Register + start the LOGON task, pointing it at the token file.
+    const reg = sshExec(target, encodePowerShell(buildRegisterTaskScript(REMOTE_HELPER_PORT, REMOTE_TASK_NAME, remoteTokenPath)), {
         timeoutMs: 60_000,
     });
     if (reg.code !== 0) {
         throw new Error(`registering scheduled task on '${name}' failed (exit ${reg.code ?? 'null'}): ${reg.stderr.trim() || reg.stdout.trim()}`);
     }
+    // Persist the token locally so `start --host` authenticates to the daemon.
+    writeHelperToken(name, token);
     return { target, taskName: REMOTE_TASK_NAME };
 }
 /** Reserve a free local TCP port by binding :0 and reading the assigned port. */
@@ -391,9 +467,17 @@ export async function startRemoteTunnel(name) {
     const tunnelPid = tunnel.pid ?? 0;
     // Verify the daemon answers through the tunnel before we record it. This is
     // the real end-to-end check: tunnel up + daemon listening + RPC round-trips.
-    const token = null; // tunnel-gated; the daemon runs token-less
+    // The daemon now requires a token, so the probe must authenticate with the one
+    // provisioned at `setup`. A missing token means setup predates auth — guide
+    // the user to re-run it rather than silently failing the RPC.
+    const token = readHelperToken(name);
     const prevTcp = process.env.COMPUTER_HELPER_TCP;
+    const prevTok = process.env.COMPUTER_HELPER_TOKEN;
     process.env.COMPUTER_HELPER_TCP = `127.0.0.1:${localPort}`;
+    if (token)
+        process.env.COMPUTER_HELPER_TOKEN = token;
+    else
+        delete process.env.COMPUTER_HELPER_TOKEN;
     const client = openComputerClient();
     let ok = false;
     let probeErr = '';
@@ -412,6 +496,10 @@ export async function startRemoteTunnel(name) {
             delete process.env.COMPUTER_HELPER_TCP;
         else
             process.env.COMPUTER_HELPER_TCP = prevTcp;
+        if (prevTok === undefined)
+            delete process.env.COMPUTER_HELPER_TOKEN;
+        else
+            process.env.COMPUTER_HELPER_TOKEN = prevTok;
     }
     if (!ok) {
         try {
@@ -419,8 +507,10 @@ export async function startRemoteTunnel(name) {
                 process.kill(tunnelPid);
         }
         catch { /* gone */ }
-        throw new Error(`tunnel to '${name}' opened but the daemon did not answer (${probeErr}). ` +
-            `Is it installed? Run: agents computer setup --host ${name}`);
+        const hint = token
+            ? `Is it installed? Run: agents computer setup --host ${name}`
+            : `No auth token on record for '${name}' — re-run: agents computer setup --host ${name}`;
+        throw new Error(`tunnel to '${name}' opened but the daemon did not answer (${probeErr}). ${hint}`);
     }
     const state = {
         device: name,
@@ -461,6 +551,7 @@ export async function stopRemoteHelper(name) {
         /* device gone / offline — local teardown still succeeds */
     }
     clearRemoteState(name);
+    clearHelperToken(name);
     return { tunnelKilled, taskRemoved };
 }
 /**

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

@@ -1,3 +1,8 @@
+/**
+ * Subagents detector. The installed-name enumeration for every agent's on-disk
+ * layout is declared once in the subagent registry; this detector is generic
+ * and delegates to `listInstalledSubagentNames` instead of a per-agent builder.
+ */
 import type { AgentId } from '../../types.js';
 import type { ResourceDetector } from './types.js';
 export declare const subagentsDetectors: Partial<Record<AgentId, ResourceDetector>>;

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

@@ -43,6 +43,7 @@ export declare const loadImport: ModuleLoader;
 export declare const loadPackages: ModuleLoader;
 export declare const loadDaemon: ModuleLoader;
 export declare const loadRoutines: ModuleLoader;
+export declare const loadMonitors: ModuleLoader;
 export declare const loadRun: ModuleLoader;
 export declare const loadDefaults: ModuleLoader;
 export declare const loadModels: ModuleLoader;
@@ -50,6 +51,7 @@ export declare const loadPrune: ModuleLoader;
 export declare const loadTrash: ModuleLoader;
 export declare const loadRestore: ModuleLoader;
 export declare const loadDoctor: ModuleLoader;
+export declare const loadApply: ModuleLoader;
 export declare const loadCheck: ModuleLoader;
 export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
@@ -74,6 +76,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,6 +89,7 @@ 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;

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

@@ -21,6 +21,7 @@ export const loadImport = async () => (await import('../../commands/import.js'))
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
 export const loadDaemon = async () => (await import('../../commands/daemon.js')).registerDaemonCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
+export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
 export const loadModels = async () => (await import('../../commands/models.js')).registerModelsCommand;
@@ -28,6 +29,7 @@ export const loadPrune = async () => (await import('../../commands/prune.js')).r
 export const loadTrash = async () => (await import('../../commands/trash.js')).registerTrashCommands;
 export const loadRestore = async () => (await import('../../commands/trash.js')).registerRestoreCommand;
 export const loadDoctor = async () => (await import('../../commands/doctor.js')).registerDoctorCommand;
+export const loadApply = async () => (await import('../../commands/apply.js')).registerApplyCommand;
 export const loadCheck = async () => (await import('../../commands/check.js')).registerCheckCommand;
 export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
@@ -52,6 +54,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,6 +67,7 @@ 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;
@@ -119,12 +123,14 @@ export const COMMAND_LOADERS = {
     install: [loadPackages],
     daemon: [loadDaemon],
     routines: [loadRoutines],
+    monitors: [loadMonitors],
     run: [loadRun],
     defaults: [loadDefaults],
     models: [loadModels],
     trash: [loadTrash],
     restore: [loadRestore],
     doctor: [loadDoctor],
+    apply: [loadApply],
     check: [loadCheck],
     status: [loadStatus],
     profiles: [loadProfiles],
@@ -149,6 +155,7 @@ export const COMMAND_LOADERS = {
     browser: [loadBrowser],
     computer: [loadComputer],
     hosts: [loadHosts],
+    lease: [loadLease],
     logs: [loadLogs],
     events: [loadEvents],
     ssh: [loadSsh],
@@ -169,6 +176,8 @@ export const COMMAND_LOADERS = {
     cloud: [loadCloud],
     message: [loadMessage],
     feed: [loadFeed],
+    mailboxes: [loadMailboxes],
+    mailbox: [loadMailboxes],
     serve: [loadServe],
     audit: [loadAudit],
     webhook: [loadWebhook],

package/dist/lib/state.d.ts

@@ -128,6 +128,11 @@ export declare function getSystemRoutinesDir(): string;
 export declare function getProjectRoutinesDir(cwd?: string): string | null;
 /** Path to routine execution logs (~/.agents/.history/runs/). */
 export declare function getRunsDir(): string;
+/** Path to monitor YAML definitions (~/.agents/monitors/). */
+export declare function getMonitorsDir(): string;
+/** Path to the durable per-monitor state-diff store + fire history
+ * (~/.agents/.history/monitors/). */
+export declare function getMonitorsHistoryDir(): string;
 /** Root for per-agent mailboxes (~/.agents/.history/mailbox/). */
 export declare function getMailboxRootDir(): string;
 /** Root for open-block feed records (~/.agents/.history/feed/). */