@phnx-labs/agents-cli 1.22.35 → 1.22.38

package/dist/lib/versions.js

@@ -41,8 +41,9 @@ import { listInstalledSubagents } from './subagents.js';
 import { listInstalledWorkflows } from './workflows.js';
 import { parseHookManifest, registerHooksToSettings, selectHookManifest, pruneVersionHomeHookEntriesFromSettings } from './hooks.js';
 import { supports, explainSkip } from './capabilities.js';
-import { discoverPlugins, marketplaceSpecForName } from './plugins.js';
+import { discoverPlugins, syncPluginToVersion, pluginSupportsAgent, cleanOrphanedPluginSkills, marketplaceSpecForName } from './plugins.js';
 import { loadManifest, saveManifest, buildManifest as buildSyncManifest, isStale } from './staleness/index.js';
+import { pruneRemovedResources } from './staleness/prune.js';
 import { emit } from './events.js';
 import { safeJoin } from './paths.js';
 import { readSkillSourceCommandMarker, shouldAlsoInstallCommandAsSkill, shouldInstallCommandAsSkill, } from './command-skills.js';
@@ -896,6 +897,59 @@ export function parseAgentSpec(spec) {
 export function getVersionDir(agent, version) {
     return path.join(getVersionsDir(), agent, version);
 }
+/**
+ * Grok binaries are never trusted below this size when picking among several
+ * `grok-*` candidates with no exact version match (see
+ * {@link resolveGrokFallbackBinary}). Grok's real native binary is ~100MB+; a
+ * stray non-binary artifact sharing the `grok-*` naming pattern (a wrapper or
+ * alias script) is at most a few hundred bytes, so 1MB comfortably separates
+ * the two without depending on file content.
+ */
+const MIN_GROK_BINARY_BYTES = 1_000_000;
+/**
+ * Pick the real grok binary among `grok-*` entries in `downloadsDir` when NO
+ * filename carries the pinned version string. Grok self-updates its binary in
+ * place while running under the shim, so a version-home's downloads dir can
+ * accumulate several `grok-*` files whose names have drifted away from that
+ * version-home's pinned version (RUSH-2459: on yosemite-s0, version-home
+ * `0.2.82` held `grok-1.0.0-linux-aarch64` after grok self-updated, plus a
+ * stale, unrelated 99-byte `grok-0.2.118-linux-aarch64` wrapper script that
+ * happened to sort alphabetically first).
+ *
+ * Never blindly take whatever `fs.readdirSync` returns first — that is exactly
+ * the bug this replaces. Instead: exclude anything under
+ * {@link MIN_GROK_BINARY_BYTES} (rejects wrapper/alias artifacts on size
+ * alone, no content sniffing needed) and, among the survivors, prefer the most
+ * recently modified — the file grok's self-updater actually wrote last.
+ * Returns null (fail loud, never guess) when nothing survives the size filter.
+ */
+export function resolveGrokFallbackBinary(downloadsDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(downloadsDir);
+    }
+    catch {
+        return null;
+    }
+    let best = null;
+    for (const entry of entries) {
+        if (!entry.startsWith('grok-'))
+            continue;
+        const full = path.join(downloadsDir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile() || stat.size < MIN_GROK_BINARY_BYTES)
+            continue;
+        if (!best || stat.mtimeMs > best.mtimeMs)
+            best = { name: entry, mtimeMs: stat.mtimeMs };
+    }
+    return best ? path.join(downloadsDir, best.name) : null;
+}
 /**
  * Get the binary path for a specific agent version.
  */
@@ -909,15 +963,15 @@ export function getBinaryPath(agent, version) {
             const match = entries.find((e) => e.includes(version) && e.startsWith('grok-'));
             if (match)
                 return path.join(grokDownloads, match);
-            const first = entries.find((e) => e.startsWith('grok-'));
-            if (first)
-                return path.join(grokDownloads, first);
         }
         catch { }
+        const fallback = resolveGrokFallbackBinary(grokDownloads);
+        if (fallback)
+            return fallback;
         return path.join(grokDownloads, `grok-${version}`);
     }
     if (agent === 'droid') {
-        // Factory's installer drops a standalone native binary (no npm package,
+        // Factory.ai's installer drops a standalone native binary (no npm package,
         // nothing in node_modules/.bin). The binary is global, not per-version —
         // config isolation rides the ~/.factory symlink switch, not a separate
         // binary per version. Install location is platform-specific:
@@ -941,19 +995,18 @@ export function getBinaryPath(agent, version) {
             : path.join(getHomeDir(), '.local', 'bin', 'muse');
     }
     if (agent === 'warp') {
-        // Warp Agent CLI installs a single global, self-updating `oz` binary — brew
-        // cask on macOS, the `oz-stable` apt|yum|pacman package on Linux — so, unlike
-        // droid/muse (which land at ~/.local/bin), its install location is
-        // platform/package specific. Resolve the real binary on PATH (findInPath
-        // skips our own shims dir) so isVersionInstalled / agents view agree with
-        // what executes. When oz is not installed, fall back to a deterministic path
-        // that won't exist, so isVersionInstalled reports uninstalled honestly.
-        const onPath = findInPath('oz');
+        // Warp Agent CLI installs a single global, self-updating `warp` binary at
+        // ~/.local/bin/warp via the curl installer (Windows: the agent-cli.ps1) —
+        // like droid/muse. Resolve the real binary on PATH (findInPath skips our own
+        // shims dir) so isVersionInstalled / agents view agree with what executes.
+        // When warp is not installed, fall back to its default install path so
+        // isVersionInstalled reports uninstalled honestly.
+        const onPath = findInPath('warp');
         if (onPath)
             return onPath;
         return IS_WINDOWS
-            ? path.join(getHomeDir(), 'bin', 'oz.exe')
-            : '/opt/warpdotdev/oz-stable/oz';
+            ? path.join(getHomeDir(), 'bin', 'warp.exe')
+            : path.join(getHomeDir(), '.local', 'bin', 'warp');
     }
     const versionDir = getVersionDir(agent, version);
     return path.join(versionDir, 'node_modules', '.bin', agentConfig.cliCommand);
@@ -2528,36 +2581,89 @@ function resourceSourceMap(kind, cwd, available) {
         }
     }
 }
+/**
+ * Build a ResourceSelection from source-pattern expansion and an optional
+ * per-kind name filter. Both dimensions are optional and compose:
+ *
+ *   patterns only   → resources from those source layers (all matching names)
+ *   kindFilter only → only those specific kinds / names, no source restriction
+ *   both combined   → patterns scope the source layer; kindFilter further
+ *                     limits which names within each kind are included
+ *
+ * Typical callers:
+ *   `--repo system`   → buildSelection(['system:*'])
+ *   `--plugin`        → buildSelection([], { plugins: 'all' })
+ *   `--plugin fleet`  → buildSelection([], { plugins: ['fleet'] })
+ *   no flags          → buildSelection([]) → full selection
+ *
+ * Memory (`kindFilter.memory`):
+ *   - Always `'all'` when patterns are active (repo scope must recompile the
+ *     composed file from all layers, RUSH-1354).
+ *   - `'all'` when `kindFilter.memory` is set (--rule / --memory flag).
+ *   - Absent (skipped) when kindFilter is given but does not include memory,
+ *     so `--plugin fleet` does NOT trigger a memory recompile.
+ *   - `'all'` when no kindFilter is given (full sync includes everything).
+ */
+export function buildSelection(patterns, kindFilter, cwd = process.cwd()) {
+    const hasPatterns = patterns.length > 0;
+    const hasKindFilter = kindFilter !== undefined;
+    // Fast path: no restrictions → sync every kind
+    if (!hasPatterns && !hasKindFilter) {
+        return {
+            commands: 'all', skills: 'all', hooks: 'all',
+            subagents: 'all', permissions: 'all', mcp: 'all',
+            plugins: 'all', workflows: 'all', memory: 'all',
+        };
+    }
+    const selection = {};
+    const allKinds = [
+        'commands', 'skills', 'hooks', 'subagents',
+        'permissions', 'mcp', 'plugins', 'workflows',
+    ];
+    const available = hasPatterns ? getAvailableResources(cwd) : undefined;
+    for (const kind of allKinds) {
+        const filterVal = kindFilter?.[kind];
+        // When a kind filter is active, skip kinds not listed in it
+        if (hasKindFilter && filterVal === undefined)
+            continue;
+        if (hasPatterns) {
+            const sourceMap = resourceSourceMap(kind, cwd, available);
+            const patternNames = expandPatterns(patterns, sourceMap);
+            if (patternNames.length === 0)
+                continue;
+            if (!filterVal || filterVal === 'all') {
+                selection[kind] = patternNames;
+            }
+            else {
+                // Intersect pattern-expanded names with the caller's name filter
+                const filterSet = new Set(filterVal);
+                const intersected = patternNames.filter(n => filterSet.has(n));
+                if (intersected.length > 0)
+                    selection[kind] = intersected;
+            }
+        }
+        else {
+            // Kind filter only — no pattern restriction; use the filter value directly
+            selection[kind] = filterVal === 'all' || !filterVal ? 'all' : filterVal;
+        }
+    }
+    // Memory is always 'all' when patterns are active (RUSH-1354), when the
+    // memory/rule flag was given, or when no kind filter restricts what is synced.
+    const memoryRequested = hasPatterns || kindFilter?.memory !== undefined || !hasKindFilter;
+    if (memoryRequested)
+        selection.memory = 'all';
+    return selection;
+}
 /**
  * Build a ResourceSelection scoped to a single DotAgent repo (`system`,
- * `user`, `project`, or an extra-repo alias). Every resource kind is filtered
- * to the entries whose source layer matches `repo`, reusing the same
- * name→source maps and `source:*` pattern expansion the persisted-pattern
- * sync path uses. Passing the result as an explicit `selection` means the sync
- * touches only that repo's resources — no orphan-sweep of the other layers.
+ * `user`, `project`, or an extra-repo alias). Delegates to `buildSelection`
+ * so the source-map and pattern-expansion logic stays in one place.
  *
- * `memory` is set to `'all'`, NOT `[]`: the composed rules-memory file is a
- * merge of ALL layers, so scoping the sync to a single repo must still
- * recompile it in the same pass (RUSH-1354). Leaving it out — or using the
- * `[]` skip-sentinel — silently strands the memory file at its old content
- * whenever a repo-scoped sync runs after a rules change. `'all'` makes
- * `syncResourcesToVersion` recompose from every layer via the active preset,
- * exactly as an unscoped full reconcile does.
+ * `memory` is always `'all'`: the composed rules-memory file spans all layers
+ * and must be recompiled in the same pass (RUSH-1354).
  */
 export function buildRepoScopedSelection(repo, cwd = process.cwd()) {
-    const patterns = [`${repo}:*`];
-    const available = getAvailableResources(cwd);
-    const selection = {};
-    const kinds = ['commands', 'skills', 'hooks', 'subagents', 'permissions', 'mcp', 'plugins', 'workflows'];
-    for (const kind of kinds) {
-        const names = expandPatterns(patterns, resourceSourceMap(kind, cwd, available));
-        if (names.length > 0)
-            selection[kind] = names;
-    }
-    // Recompile the memory file from all layers even under a repo scope — it is
-    // composed, not a per-repo artifact (see skipMemory below and RUSH-1354).
-    selection.memory = 'all';
-    return selection;
+    return buildSelection([`${repo}:*`], undefined, cwd);
 }
 /**
  * Union several ResourceSelections into one, deduping names per kind. Pure — no
@@ -2605,7 +2711,7 @@ export function mergeRepoScopedSelections(repos, cwd = process.cwd()) {
  */
 export function syncResourcesToVersion(agent, version, selection, options = {}) {
     if (isAgentHardDeprecated(agent)) {
-        return { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [] };
+        return { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [], pruned: { commands: [], skills: [] } };
     }
     const agentConfig = AGENTS[agent];
     const versionHome = getVersionHomePath(agent, version);
@@ -2616,7 +2722,7 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     // care about the ORIGINAL intent: a caller passing no selection means
     // "full sync; persist the staleness manifest after."
     const userPassedSelection = selection !== undefined;
-    const result = { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [] };
+    const result = { commands: false, skills: false, hooks: false, memory: [], permissions: false, mcp: [], subagents: [], plugins: [], workflows: [], projectSkipped: [], pruned: { commands: [], skills: [] } };
     const cwd = options.cwd || process.cwd();
     const projectAgentsDir = options.projectDir || getProjectAgentsDir(cwd);
     const userAgentsDir = getUserAgentsDir();
@@ -3037,10 +3143,27 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
             }
         }
     }
-    // Sync plugins — dispatch through WRITERS.plugins.
+    // Sync plugins — dispatch through WRITERS.plugins (or directly via
+    // syncPluginToVersion when allowExecSurfaces is requested, since WriteArgs
+    // has no channel for that option).
     if (pluginsToSync.length > 0 && pluginsWriter) {
-        const r = pluginsWriter.write({ version, versionHome, selection: pluginsToSync, cwd });
-        result.plugins.push(...r.synced);
+        if (options.allowExecSurfaces) {
+            const allPlugins = discoverPlugins();
+            cleanOrphanedPluginSkills(agent, versionHome, new Set(allPlugins.map(p => p.name)));
+            const pluginMap = new Map(allPlugins.map(p => [p.name, p]));
+            for (const name of pluginsToSync) {
+                const plugin = pluginMap.get(name);
+                if (!plugin || !pluginSupportsAgent(plugin, agent))
+                    continue;
+                const r = syncPluginToVersion(plugin, agent, versionHome, { version, allowExecSurfaces: true });
+                if (r.success)
+                    result.plugins.push(name);
+            }
+        }
+        else {
+            const r = pluginsWriter.write({ version, versionHome, selection: pluginsToSync, cwd });
+            result.plugins.push(...r.synced);
+        }
     }
     // Sync workflows — dispatch through WRITERS.workflows.
     const workflowsWriter = getWriter('workflows', agent);
@@ -3068,6 +3191,33 @@ export function syncResourcesToVersion(agent, version, selection, options = {})
     if (supports(agent, 'memory', version).ok) {
         syncMemoryToVersionHome(agent, versionHome, cwd);
     }
+    // Prune resources deleted from source (RUSH-2438). Runs only on a repo-scope
+    // reconcile (`options.prune`) with a caller selection — a full sync
+    // (`!userPassedSelection`) already sweeps orphans above, and an additive
+    // interactive/`agents add` selection must not delete anything. The prune is
+    // manifest-bounded: only names the last full sync recorded are candidates,
+    // and only when they are gone from ALL source layers — so a user-authored
+    // file the sync never placed, or a same-named resource still provided by
+    // another layer, is never removed. No manifest → fail loud (delete nothing).
+    if (options.prune && userPassedSelection) {
+        const previousManifest = loadManifest(agent, version);
+        const outcome = pruneRemovedResources({
+            agent,
+            version,
+            versionHome,
+            cwd,
+            previousManifest,
+            sourceNames: {
+                commands: available.commands,
+                skills: available.skills,
+            },
+        });
+        result.pruned = outcome.pruned;
+        if (outcome.skippedNoManifest) {
+            console.warn(`agents: prune skipped for ${agent}@${version} — no sync manifest yet, so no removed resources were pruned. ` +
+                `Run 'agents sync ${agent}@${version}' (a full sync) to establish the baseline.`);
+        }
+    }
     // Write manifest after a full sync (no user-passed selection) so the next
     // launch can skip the slow path. Pattern-derived selections still count as
     // "full" — the agents.yaml patterns describe the intended scope, not a

package/dist/lib/watchdog/log.d.ts

@@ -1,4 +1,4 @@
-/** Same path the Factory reader pulls (apps/factory/src/core/watchdogLog.ts). */
+/** Same path the Fleet reader pulls (apps/ext/src/core/watchdogLog.ts). */
 export declare const WATCHDOG_LOG_PATH: string;
 /** Kinds the Factory reader accepts. Keep in lockstep with watchdogLog.ts. */
 export type WatchdogEventKind = 'tick' | 'decision' | 'nudge' | 'rotate' | 'error';

package/dist/lib/watchdog/log.js

@@ -1,12 +1,12 @@
 /**
  * Canonical watchdog event log (watchdog-brain-v2).
  *
- * The Factory Floor renders a read-only "Watchdog activity" card from the JSONL
+ * The Fleet renders a read-only "Watchdog activity" card from the JSONL
  * feed at ~/.agents/.cache/logs/watchdog.log. That feed was historically written
  * by the retired extension-side watchdog; now the always-on CLI watchdog owns it.
  *
  * The event SHAPE here is a deliberate, verbatim replica of the reader in
- * apps/factory/src/core/watchdogLog.ts (WatchdogEvent / WatchdogEventKind /
+ * apps/ext/src/core/watchdogLog.ts (WatchdogEvent / WatchdogEventKind /
  * WATCHDOG_LOG_PATH / the trim cap). The repo forbids cross-app imports
  * (CLAUDE.md repo map), so the two files are kept in sync by hand — a change to
  * the Factory reader's shape must be mirrored here. There is no import between
@@ -16,7 +16,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { withFileLock, atomicWriteFileSync, ensureLockTarget } from '../fs-atomic.js';
-/** Same path the Factory reader pulls (apps/factory/src/core/watchdogLog.ts). */
+/** Same path the Fleet reader pulls (apps/ext/src/core/watchdogLog.ts). */
 export const WATCHDOG_LOG_PATH = path.join(os.homedir(), '.agents', '.cache', 'logs', 'watchdog.log');
 const WATCHDOG_EVENT_KINDS = new Set(['tick', 'decision', 'nudge', 'rotate', 'error']);
 /** Parse the audit log without letting a partial final append hide valid rows. */

package/dist/lib/watchdog/rotate.d.ts

@@ -7,13 +7,13 @@
  * weekly limit · resets …"), the daemon watchdog rotates it instead of nudging:
  *
  *   1. DETECT  — classifyTailForRotate() matches the tail against the limit
- *      patterns (ported from apps/factory/src/core/autoRotate.ts) and parses the
+ *      patterns (ported from apps/ext/src/core/autoRotate.ts) and parses the
  *      `resets <time>` clause when present.
  *   2. GATE    — defaultRotateGate() runs the SAME first-party selection
  *      `agents run auto` would (collectHarnessCandidates + pickHarnessWeighted,
  *      ../rotate.ts). Zero healthy → ONE `rotate` skip event per cooldown window
  *      and the terminal is left untouched. No `agents view` subprocess anywhere.
- *   3. RELAUNCH — the per-harness exit sequence (ported from apps/factory
+ *   3. RELAUNCH — the per-harness exit sequence (ported from apps/ext
  *      prewarm.ts PREWARM_CONFIGS) is injected, then
  *      `agents run auto --interactive --session-id <uuid>`.
  *   4. REPLAY   — when the new session's TUI is live (bounded wait, default
@@ -31,7 +31,7 @@ import type { InjectTarget } from '../terminal/inject.js';
 import type { ActiveSession } from '../session/active.js';
 /**
  * Agent-reported hard-limit texts, matched against a session transcript tail.
- * Ported verbatim from apps/factory/src/core/autoRotate.ts RATE_LIMIT_PATTERNS —
+ * Ported verbatim from apps/ext/src/core/autoRotate.ts RATE_LIMIT_PATTERNS —
  * kept specific on purpose: a transcript carries prose, so a loose "rate limit"
  * match would rotate terminals whose agent merely DISCUSSED limits. The first
  * two patterns cover the weekly/session variants, including claude's
@@ -54,7 +54,7 @@ export type RotateTailVerdict = {
 export declare function classifyTailForRotate(tailLines: string[], nowMs: number): RotateTailVerdict;
 /**
  * Parse the `resets <time>` clause of a limit line into an epoch-ms horizon.
- * Ported from apps/factory/src/core/autoRotate.ts parseResetTimeMs (behavior
+ * Ported from apps/ext/src/core/autoRotate.ts parseResetTimeMs (behavior
  * verbatim): the ISO form (milliseconds + Z) is matched EXPLICITLY and first —
  * a generic capture stops at the milliseconds dot and drops the Z, which makes
  * Date.parse read LOCAL time (the suppression would end hours off). Time-of-day
@@ -64,7 +64,7 @@ export declare function classifyTailForRotate(tailLines: string[], nowMs: number
  */
 export declare function parseRotateResetMs(text: string, nowMs: number): number | undefined;
 /**
- * Clean-exit key sequences per harness, ported verbatim from apps/factory
+ * Clean-exit key sequences per harness, ported verbatim from apps/ext
  * prewarm.ts PREWARM_CONFIGS. Injected as RAW BYTES with no trailing Enter — a
  * literal \x03 written to the pty IS Ctrl+C (SIGINT), \x1b IS Esc. claude's Ink
  * TUI needs the Esc first to leave any open mode before the interrupt pair.
@@ -76,7 +76,7 @@ export declare function exitSequenceFor(agent: string): string[];
 /**
  * The rotate relaunch, typed into the same tab: full auto — the CLI resolves
  * host (affinity) → harness (cross-harness headroom) → account (balanced) and
- * exits nonzero when every layer is exhausted. Ported from apps/factory
+ * exits nonzero when every layer is exhausted. Ported from apps/ext
  * autoRotate.ts buildAutoRotateLaunchCommand. A terminal on a REMOTE device
  * rotates ON that device (`--host`); a local terminal omits it. `--session-id`
  * is honored only when the CLI picks claude (existing claude-only semantics)

package/dist/lib/watchdog/rotate.js

@@ -7,13 +7,13 @@
  * weekly limit · resets …"), the daemon watchdog rotates it instead of nudging:
  *
  *   1. DETECT  — classifyTailForRotate() matches the tail against the limit
- *      patterns (ported from apps/factory/src/core/autoRotate.ts) and parses the
+ *      patterns (ported from apps/ext/src/core/autoRotate.ts) and parses the
  *      `resets <time>` clause when present.
  *   2. GATE    — defaultRotateGate() runs the SAME first-party selection
  *      `agents run auto` would (collectHarnessCandidates + pickHarnessWeighted,
  *      ../rotate.ts). Zero healthy → ONE `rotate` skip event per cooldown window
  *      and the terminal is left untouched. No `agents view` subprocess anywhere.
- *   3. RELAUNCH — the per-harness exit sequence (ported from apps/factory
+ *   3. RELAUNCH — the per-harness exit sequence (ported from apps/ext
  *      prewarm.ts PREWARM_CONFIGS) is injected, then
  *      `agents run auto --interactive --session-id <uuid>`.
  *   4. REPLAY   — when the new session's TUI is live (bounded wait, default
@@ -35,7 +35,7 @@ import { resolveWatchdogSessionPath } from './read.js';
 // --- detection ---------------------------------------------------------------
 /**
  * Agent-reported hard-limit texts, matched against a session transcript tail.
- * Ported verbatim from apps/factory/src/core/autoRotate.ts RATE_LIMIT_PATTERNS —
+ * Ported verbatim from apps/ext/src/core/autoRotate.ts RATE_LIMIT_PATTERNS —
  * kept specific on purpose: a transcript carries prose, so a loose "rate limit"
  * match would rotate terminals whose agent merely DISCUSSED limits. The first
  * two patterns cover the weekly/session variants, including claude's
@@ -66,7 +66,7 @@ export function classifyTailForRotate(tailLines, nowMs) {
 }
 /**
  * Parse the `resets <time>` clause of a limit line into an epoch-ms horizon.
- * Ported from apps/factory/src/core/autoRotate.ts parseResetTimeMs (behavior
+ * Ported from apps/ext/src/core/autoRotate.ts parseResetTimeMs (behavior
  * verbatim): the ISO form (milliseconds + Z) is matched EXPLICITLY and first —
  * a generic capture stops at the milliseconds dot and drops the Z, which makes
  * Date.parse read LOCAL time (the suppression would end hours off). Time-of-day
@@ -137,7 +137,7 @@ function nextOccurrenceMs(hour, minute, timeZone, nowMs) {
 }
 // --- exit sequences ------------------------------------------------------------
 /**
- * Clean-exit key sequences per harness, ported verbatim from apps/factory
+ * Clean-exit key sequences per harness, ported verbatim from apps/ext
  * prewarm.ts PREWARM_CONFIGS. Injected as RAW BYTES with no trailing Enter — a
  * literal \x03 written to the pty IS Ctrl+C (SIGINT), \x1b IS Esc. claude's Ink
  * TUI needs the Esc first to leave any open mode before the interrupt pair.
@@ -158,7 +158,7 @@ export function exitSequenceFor(agent) {
 /**
  * The rotate relaunch, typed into the same tab: full auto — the CLI resolves
  * host (affinity) → harness (cross-harness headroom) → account (balanced) and
- * exits nonzero when every layer is exhausted. Ported from apps/factory
+ * exits nonzero when every layer is exhausted. Ported from apps/ext
  * autoRotate.ts buildAutoRotateLaunchCommand. A terminal on a REMOTE device
  * rotates ON that device (`--host`); a local terminal omits it. `--session-id`
  * is honored only when the CLI picks claude (existing claude-only semantics)

package/dist/lib/workflows.d.ts

@@ -9,7 +9,7 @@ import type { AgentId } from './types.js';
 /**
  * The `loop:` block as it appears in WORKFLOW.md frontmatter (YAML, snake_case).
  * Parsed defensively and translated to the camelCase LoopConfig the driver
- * consumes (src/lib/loop.ts). See docs/07-entrypoints-and-loops.md.
+ * consumes (src/lib/loop.ts). See docs/entrypoints-and-loops.md.
  */
 export interface LoopConfigRaw {
     /** Stop condition. Only `signal` is supported today. */

package/dist/lib/yaml-io.d.ts

@@ -0,0 +1,47 @@
+import * as yaml from 'yaml';
+/**
+ * The single serialization used by every writer that edits a shared, committed
+ * YAML document in place.
+ *
+ * RUSH-2505 had two halves. The first: the `yaml` emitter pads flow collections
+ * by default, so a round trip rewrote
+ *
+ *     command: [agents, notify, "{message}"]
+ * as
+ *     command: [ agents, notify, "{message}" ]
+ *
+ * The second, which outlived the first fix: `agents.yaml` has five in-place
+ * writers, and they did not agree on collection style. `state.ts` and
+ * `manifest.ts` forced block while `feed.ts`, `activity.ts` and `migrate.ts`
+ * took the defaults, so an empty map came out as
+ *
+ *     mcp:            from two of them, and      mcp: {}
+ *       {}                                        from the other three,
+ *
+ * and each group rewrote the other's output on the next command.
+ *
+ * Both diffs are semantically no-ops, which is what made them dangerous. The
+ * working tree went permanently dirty, then `agents repo pull` refused
+ * ("Blocked by local changes") and `git merge --ff-only` refused, so the box
+ * silently stopped receiving fleet config. Seven boxes fell 37-52 commits
+ * behind and nothing reported it.
+ *
+ * Two constraints pull in opposite directions, and both are real:
+ *
+ *  - Forcing `collectionStyle: 'block'` unconditionally flattens a committed
+ *    flow sequence into a block list — its own dirtying diff, asserted against
+ *    by the RUSH-2505 case in `feed.test.ts`.
+ *  - Never forcing it regresses what `state.ts` and `manifest.ts` were guarding:
+ *    when the document ROOT is flow (a legacy `{}` or `{a: 1}` file), every
+ *    edited node inherits flow, so a `doc.set()` yields
+ *    `{a: 1, disabledCommands: [teams]}` instead of a block mapping.
+ *
+ * So block is forced exactly when the root is flow, which is the only case that
+ * needs it, and left alone otherwise. Every writer gets the same rule, so the
+ * same document can only produce one result and there is nothing left to
+ * oscillate.
+ *
+ * Caller options merge last, so a writer with a genuine reason to differ still
+ * can — but it then owns the drift it causes.
+ */
+export declare function stringifyDoc(doc: yaml.Document, options?: yaml.ToStringOptions): string;

package/dist/lib/yaml-io.js

@@ -0,0 +1,55 @@
+/**
+ * The single serialization used by every writer that edits a shared, committed
+ * YAML document in place.
+ *
+ * RUSH-2505 had two halves. The first: the `yaml` emitter pads flow collections
+ * by default, so a round trip rewrote
+ *
+ *     command: [agents, notify, "{message}"]
+ * as
+ *     command: [ agents, notify, "{message}" ]
+ *
+ * The second, which outlived the first fix: `agents.yaml` has five in-place
+ * writers, and they did not agree on collection style. `state.ts` and
+ * `manifest.ts` forced block while `feed.ts`, `activity.ts` and `migrate.ts`
+ * took the defaults, so an empty map came out as
+ *
+ *     mcp:            from two of them, and      mcp: {}
+ *       {}                                        from the other three,
+ *
+ * and each group rewrote the other's output on the next command.
+ *
+ * Both diffs are semantically no-ops, which is what made them dangerous. The
+ * working tree went permanently dirty, then `agents repo pull` refused
+ * ("Blocked by local changes") and `git merge --ff-only` refused, so the box
+ * silently stopped receiving fleet config. Seven boxes fell 37-52 commits
+ * behind and nothing reported it.
+ *
+ * Two constraints pull in opposite directions, and both are real:
+ *
+ *  - Forcing `collectionStyle: 'block'` unconditionally flattens a committed
+ *    flow sequence into a block list — its own dirtying diff, asserted against
+ *    by the RUSH-2505 case in `feed.test.ts`.
+ *  - Never forcing it regresses what `state.ts` and `manifest.ts` were guarding:
+ *    when the document ROOT is flow (a legacy `{}` or `{a: 1}` file), every
+ *    edited node inherits flow, so a `doc.set()` yields
+ *    `{a: 1, disabledCommands: [teams]}` instead of a block mapping.
+ *
+ * So block is forced exactly when the root is flow, which is the only case that
+ * needs it, and left alone otherwise. Every writer gets the same rule, so the
+ * same document can only produce one result and there is nothing left to
+ * oscillate.
+ *
+ * Caller options merge last, so a writer with a genuine reason to differ still
+ * can — but it then owns the drift it causes.
+ */
+export function stringifyDoc(doc, options = {}) {
+    // A flow root makes every edited node render flow; normalize the whole doc to
+    // block in that case only. `contents.flow` is undefined for a block root.
+    const rootIsFlow = doc.contents?.flow === true;
+    return doc.toString({
+        flowCollectionPadding: false,
+        ...(rootIsFlow ? { collectionStyle: 'block' } : {}),
+        ...options,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.35",
+  "version": "1.22.38",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -95,6 +95,7 @@
     "@zed-industries/agent-client-protocol": "0.4.5",
     "acorn": "8.18.0",
     "age-encryption": "0.3.0",
+    "aws4fetch": "1.0.20",
     "chalk": "5.6.2",
     "commander": "15.0.0",
     "croner": "10.0.1",

package/scripts/install-helper.js

@@ -72,8 +72,8 @@ function main() {
   if (!src) {
     // No source bundle to install. Stay silent during postinstall so we don't
     // create noise on Linux/Windows or on builds that intentionally omit the
-    // helper. `agents helper install` surfaces a clearer error if a user
-    // actually needs the helper.
+    // helper. The lazy staleness check in getKeychainHelperPath() surfaces a
+    // clearer error if a user actually needs the helper.
     return;
   }