@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/lib/mailbox-target.js

@@ -48,7 +48,7 @@ export function resolveMessageTarget(target, sessions, isCloudTask) {
  * local/cloud session (RUSH-2366 follow-up): `getActiveSessions()` has no
  * visibility into a detached `agents run --device <host> --no-follow`
  * dispatch, whose only local record is the `~/.agents/.cache/hosts/<id>.json`
- * sidecar `agents hosts ps` reads. Pure — the caller does the actual lookup
+ * sidecar `agents devices ps` reads. Pure — the caller does the actual lookup
  * (`resolveTaskRef`) and I/O (the ssh reroute).
  *
  * `remoteRef` prefers the remote agent's OWN identity (its captured session id

package/dist/lib/manifest.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import * as yaml from 'yaml';
+import { stringifyDoc } from './yaml-io.js';
 import { ensureLockTarget, atomicWriteFileSync, withFileLock } from './fs-atomic.js';
 import { safeJoin } from './paths.js';
 /** Canonical filename for the manifest in any agents repo or project root. */
@@ -54,10 +55,12 @@ export function serializeManifest(manifest, existingContent) {
     // Nothing changed → keep the file byte-identical (comments intact).
     if (!changed)
         return existingContent;
-    // Force BLOCK style: an existing flow root (e.g. legacy `{}`) would otherwise
-    // make edited nodes render flow. collectionStyle pins the whole doc block
-    // while parseDocument still preserves comments + key ordering.
-    return isEmpty ? '' : doc.toString({ collectionStyle: 'block' });
+    // stringifyDoc still normalizes a legacy flow root (`{}`) to block so edited
+    // nodes do not render flow, but no longer forces block on a normal document —
+    // that flattened committed flow sequences and made this writer disagree with
+    // the other agents.yaml writers (RUSH-2505). parseDocument still preserves
+    // comments + key ordering.
+    return isEmpty ? '' : stringifyDoc(doc);
 }
 /** Read and parse agents.yaml from a directory. Returns null if the file does not exist. */
 export function readManifest(repoPath) {

package/dist/lib/menubar/snapshot.d.ts

@@ -2,8 +2,8 @@ import type { WatchdogTickResult } from '../watchdog/runner.js';
 /**
  * One registered fleet device, for the menu-bar's collapsible DEVICES section.
  * Sourced from the local registry read (`loadDevices`) — no network probe — so
- * it carries only what the registry knows for sure (name, platform, whether it
- * is the interactive host, whether it is this machine). Live load% is merged in
+ * it carries only local persisted state (name, platform, preferred status,
+ * whether it is the interactive host, whether it is this machine). Live load% is merged in
  * on the Swift side from the daemon-warmed `.fleet-stats.json`; online/offline
  * is deliberately NOT claimed here (the registry's cached tailscale flag is
  * documented as stale in both directions — registry.ts isLikelyOnline).
@@ -13,6 +13,7 @@ export interface MenubarDevice {
     platform: string;
     interactive: boolean;
     isLocal: boolean;
+    preferred: boolean;
 }
 export interface MenubarSnapshot {
     version: 1;

package/dist/lib/menubar/snapshot.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { buildRoutineListJson } from '../../commands/routines.js';
 import { backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../../commands/sessions.js';
-import { getConfigValue } from '../device-config.js';
+import { getConfigValue, loadAutoLaunchPreferences } from '../device-config.js';
 import { loadDevices } from '../devices/registry.js';
 import { machineId } from '../machine-id.js';
 import { querySessions } from '../session/db.js';
@@ -14,7 +14,10 @@ import { getRuntimeStateDir } from '../state.js';
  * it rides the same 3-minute snapshot poll instead of a second timer.
  */
 async function buildMenubarDevices() {
-    const reg = await loadDevices();
+    const [reg, prefs] = await Promise.all([
+        loadDevices(),
+        loadAutoLaunchPreferences(),
+    ]);
     const interactiveHost = getConfigValue('interactive.host').value;
     const self = machineId();
     return Object.keys(reg)
@@ -24,6 +27,7 @@ async function buildMenubarDevices() {
         platform: reg[name].platform,
         interactive: name === interactiveHost,
         isLocal: name === self,
+        preferred: prefs[name]?.preferred === true,
     }));
 }
 export function readLastWatchdogTick(stateDir = path.join(getRuntimeStateDir(), 'watchdog')) {

package/dist/lib/migrate-fold.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Leaf migrator: fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * Kept separate from migrate.ts so the always-on startup hop (index.ts) does
+ * not load the hosts/routine/teams/daemon/menubar graph that migrate.ts's
+ * static imports pull in (RUSH-2454). migrate.ts re-exports and still calls
+ * foldLegacySystemRepo() at the top of runMigration().
+ *
+ * HOME is resolved at call time (not module load) so tests can point at a
+ * fixture tree via process.env.HOME without cache-busting the module.
+ */
+/**
+ * Fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
+ * (the new path), so the contents have to be there before they execute.
+ *
+ * Strategy:
+ *   1. If legacy dir doesn't exist or is already a symlink, no-op.
+ *   2. If new path doesn't exist yet, rename in one shot (fast path).
+ *   3. If both exist (mid-migration / re-run on partially-migrated state),
+ *      merge legacy → new with new winning on collision, then drop legacy.
+ *
+ * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
+ * so external tooling that still references ~/.agents-system/ keeps
+ * resolving correctly. The symlink is harmless on its own and can be
+ * removed with `rm ~/.agents-system` once everything has updated.
+ *
+ * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
+ * LEGACY_SYSTEM_DIR" without duplicating data.
+ */
+export declare function foldLegacySystemRepo(): void;
+export declare function copyDirSkipExisting(src: string, dest: string): void;

package/dist/lib/migrate-fold.js

@@ -0,0 +1,130 @@
+/**
+ * Leaf migrator: fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * Kept separate from migrate.ts so the always-on startup hop (index.ts) does
+ * not load the hosts/routine/teams/daemon/menubar graph that migrate.ts's
+ * static imports pull in (RUSH-2454). migrate.ts re-exports and still calls
+ * foldLegacySystemRepo() at the top of runMigration().
+ *
+ * HOME is resolved at call time (not module load) so tests can point at a
+ * fixture tree via process.env.HOME without cache-busting the module.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createLink } from './platform/links.js';
+function homeDir() {
+    return process.env.HOME ?? os.homedir();
+}
+function userDir() {
+    return path.join(homeDir(), '.agents');
+}
+function systemDir() {
+    return path.join(userDir(), '.system');
+}
+function legacySystemDir() {
+    return path.join(homeDir(), '.agents-system');
+}
+/**
+ * Fold ~/.agents-system/ into ~/.agents/.system/.
+ *
+ * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
+ * (the new path), so the contents have to be there before they execute.
+ *
+ * Strategy:
+ *   1. If legacy dir doesn't exist or is already a symlink, no-op.
+ *   2. If new path doesn't exist yet, rename in one shot (fast path).
+ *   3. If both exist (mid-migration / re-run on partially-migrated state),
+ *      merge legacy → new with new winning on collision, then drop legacy.
+ *
+ * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
+ * so external tooling that still references ~/.agents-system/ keeps
+ * resolving correctly. The symlink is harmless on its own and can be
+ * removed with `rm ~/.agents-system` once everything has updated.
+ *
+ * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
+ * LEGACY_SYSTEM_DIR" without duplicating data.
+ */
+export function foldLegacySystemRepo() {
+    const LEGACY_SYSTEM_DIR = legacySystemDir();
+    const SYSTEM_DIR = systemDir();
+    const USER_DIR = userDir();
+    let legacyStat = null;
+    try {
+        legacyStat = fs.lstatSync(LEGACY_SYSTEM_DIR);
+    }
+    catch { /* missing */ }
+    if (!legacyStat)
+        return;
+    if (legacyStat.isSymbolicLink())
+        return;
+    if (!legacyStat.isDirectory())
+        return;
+    try {
+        fs.mkdirSync(USER_DIR, { recursive: true, mode: 0o700 });
+    }
+    catch { /* best-effort */ }
+    if (!fs.existsSync(SYSTEM_DIR)) {
+        try {
+            fs.renameSync(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+            try {
+                createLink(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+            }
+            catch { /* best-effort */ }
+            console.error('Folded ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+            return;
+        }
+        catch {
+            // Cross-device rename or perm issue — fall through to copy + remove.
+        }
+    }
+    try {
+        copyDirSkipExisting(LEGACY_SYSTEM_DIR, SYSTEM_DIR);
+        fs.rmSync(LEGACY_SYSTEM_DIR, { recursive: true, force: true });
+        try {
+            createLink(SYSTEM_DIR, LEGACY_SYSTEM_DIR);
+        }
+        catch { /* best-effort */ }
+        console.error('Merged ~/.agents-system/ into ~/.agents/.system/ (left back-compat symlink)');
+    }
+    catch { /* best-effort */ }
+}
+export function copyDirSkipExisting(src, dest) {
+    let entries;
+    try {
+        entries = fs.readdirSync(src, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
+    for (const entry of entries) {
+        const s = path.join(src, entry.name);
+        const d = path.join(dest, entry.name);
+        if (fs.existsSync(d)) {
+            if (entry.isDirectory()) {
+                const dStat = fs.lstatSync(d);
+                if (dStat.isDirectory())
+                    copyDirSkipExisting(s, d);
+            }
+            continue;
+        }
+        try {
+            fs.renameSync(s, d);
+        }
+        catch {
+            try {
+                if (entry.isDirectory()) {
+                    copyDirSkipExisting(s, d);
+                }
+                else if (entry.isSymbolicLink()) {
+                    fs.symlinkSync(fs.readlinkSync(s), d);
+                }
+                else {
+                    fs.copyFileSync(s, d);
+                }
+            }
+            catch { /* best-effort */ }
+        }
+    }
+}

package/dist/lib/migrate.d.ts

@@ -4,27 +4,7 @@
  * Called from postinstall and as a command-time fallback from agents view/use/pull.
  * Each migration is guarded by an existence check so re-running is safe.
  */
-/**
- * Fold ~/.agents-system/ into ~/.agents/.system/.
- *
- * MUST run first in runMigration() — every other migrator reads SYSTEM_DIR
- * (the new path), so the contents have to be there before they execute.
- *
- * Strategy:
- *   1. If legacy dir doesn't exist or is already a symlink, no-op.
- *   2. If new path doesn't exist yet, rename in one shot (fast path).
- *   3. If both exist (mid-migration / re-run on partially-migrated state),
- *      merge legacy → new with new winning on collision, then drop legacy.
- *
- * After the contents move, the legacy path becomes a symlink → SYSTEM_DIR
- * so external tooling that still references ~/.agents-system/ keeps
- * resolving correctly. The symlink is harmless on its own and can be
- * removed with `rm ~/.agents-system` once everything has updated.
- *
- * Idempotent: re-running converges to "contents at SYSTEM_DIR, symlink at
- * LEGACY_SYSTEM_DIR" without duplicating data.
- */
-export declare function foldLegacySystemRepo(): void;
+export { foldLegacySystemRepo } from './migrate-fold.js';
 /**
  * Migrate a legacy single-repo agents.yaml into ~/.agents/agents.yaml.
  *
@@ -59,7 +39,7 @@ export declare function foldBrowserSessionsIntoProfiles(browserDir?: string): vo
 /**
  * Repair self-referential agent binary symlinks.
  *
- * Some installScript-based agents — notably Factory's `droid`, whose installer
+ * Some installScript-based agents — notably Factory.ai's `droid`, whose installer
  * drops a standalone native binary at ~/.local/bin/droid — were registered at
  * install time by resolving the post-install binary with `which <cli>`. Because
  * ~/.agents/.cache/shims sits ahead of ~/.local/bin on PATH, `which` could
@@ -145,21 +125,23 @@ export declare function migrateRoutineRemoteCwdToCwd(routinesDir?: string): void
  */
 export declare function pauseUnreadyEnabledRoutines(): void;
 /**
- * Fold the legacy watchdog enable sentinel into the watchdog routine.
+ * Fold the legacy watchdog enable sentinel into the `watchdog.enabled` config.
  *
  * The always-on watchdog used to be gated by a presence sentinel at
- * `<runtime-state>/watchdog/enabled`; it is now a daemon routine. A user who had
- * run `agents watchdog enable` under the old build has that file on disk — without
- * this, upgrading would silently drop them back to OFF (the always-on nudge just
- * stops), the worst failure mode for a "survives reboots" feature. If the sentinel
- * exists, ensure the `watchdog` routine exists AND is enabled, then delete the
- * sentinel so this runs exactly once. If ensuring the routine fails, the sentinel
- * is left in place so a later run retries rather than silently losing the opt-in.
- *
- * Both seams are injectable so the migration is unit-testable without touching the
- * real routines dir (and without racing the routine module's own tests).
+ * `<runtime-state>/watchdog/enabled`; it is now a daemon-owned timer (RUSH-2495)
+ * gated by the `watchdog.enabled` device-config flag — the same flag
+ * `agents watchdog enable` writes. A user who had run `agents watchdog enable`
+ * under the old build has that file on disk; without this, upgrading would
+ * silently drop them back to OFF (the nudge just stops), the worst failure mode
+ * for a "survives reboots" feature. If the sentinel exists, set
+ * `watchdog.enabled: true`, then delete the sentinel so this runs exactly once.
+ * If setting it fails, the sentinel is left in place so a later run retries
+ * rather than silently losing the opt-in.
+ *
+ * The setter seam is injectable so the migration is unit-testable without
+ * touching the real device config.
  */
-export declare function migrateWatchdogSentinelToRoutine(sentinelPath?: string, enable?: (name: string, enabled: boolean) => void): void;
+export declare function migrateWatchdogSentinelToConfig(sentinelPath?: string, enable?: (value: boolean) => void): void;
 /**
  * Rename cli/ → clis/ in each of the given `.agents/` directories.
  *
@@ -179,5 +161,23 @@ export declare function migrateCliDirToClis(agentsDirs: string[]): void;
  * (where ~/.cursor is a real dir, not a symlink into a version home).
  */
 export declare function seedActiveCursorLoginPerVersion(): void;
+/**
+ * Fold the pre-markdown Kimi subagent layout out of every kimi version home.
+ *
+ * agents-cli used to write each Kimi subagent as a `<name>.yaml` +
+ * `<name>.system.md` pair plus a managed `_agents-cli.yaml` index, against the
+ * agentspec of `kimi-cli` — a different product from the `kimi-code` harness we
+ * install, which never read any of it. Those files are inert, but not harmless:
+ * `<name>.system.md` ends in `.md`, so the subagent enumerator would surface it
+ * as a phantom subagent named `<name>.system`, and kimi-code logs
+ * `Missing frontmatter` for it once per session.
+ *
+ * This is the ONE place that knows about the old layout — the registry target
+ * describes only the current `<name>.md` shape. A pair is identified by its
+ * signature (a `<name>.yaml` with a sibling `<name>.system.md`), so a subagent a
+ * user legitimately named e.g. `foo.system` is never touched: it has no
+ * `foo.yaml` beside it. Idempotent; a no-op once the dirs are clean.
+ */
+export declare function migrateKimiSubagentsToMarkdown(versionsDir?: string): void;
 /** Run all idempotent migrations. Safe to call multiple times. */
 export declare function runMigration(): Promise<void>;