@phnx-labs/agents-cli 1.20.93 → 1.21.0

package/dist/lib/remote-agents-json.js

@@ -15,6 +15,15 @@ import { loadDevices, isControlDevice, isDialableDevice } from './devices/regist
 import { remoteShellFor, buildWindowsAgentsCommand } from './hosts/remote-cmd.js';
 import { machineId, normalizeHost } from './machine-id.js';
 const REMOTE_TIMEOUT_MS = 12_000;
+export function normalizeRemoteAgentsJsonParse(parsed) {
+    return Array.isArray(parsed) ? { items: parsed, valid: true } : parsed;
+}
+export function parseRemoteAgentsJsonPayload(stdout, machine, parse) {
+    const parsed = normalizeRemoteAgentsJsonParse(parse(stdout, machine));
+    return parsed.valid
+        ? { items: parsed.items, parseFailed: false }
+        : { items: [], parseFailed: true };
+}
 /** Build the command one peer runs, with a guard that prevents recursive fan-out. */
 export function remoteAgentsJsonCommand(args, noFanoutEnv, os) {
     if (remoteShellFor(os) === 'powershell') {
@@ -59,7 +68,7 @@ export async function gatherRemoteAgentsJson(options) {
             devices = await loadDevices();
         }
         catch {
-            return { items: [], deviceCount: 0, skipped: [] };
+            return { items: [], deviceCount: 0, skipped: [], parseFailed: [], discoveryFailed: true };
         }
         for (const device of Object.values(devices)) {
             // Live SSH-probe verdict first, cached tailscale snapshot only as a
@@ -90,6 +99,7 @@ export async function gatherRemoteAgentsJson(options) {
         }
     }
     const skipped = [];
+    const parseFailed = [];
     const results = await Promise.all(targets.map(async (target) => {
         const command = remoteAgentsJsonCommand(options.args, options.noFanoutEnv, target.os);
         const result = await sshCapture(target.target, command);
@@ -100,7 +110,15 @@ export async function gatherRemoteAgentsJson(options) {
             }
             return [];
         }
-        return options.parse(result.stdout, target.machine);
+        const parsed = parseRemoteAgentsJsonPayload(result.stdout, target.machine, options.parse);
+        if (parsed.parseFailed) {
+            parseFailed.push(target.name);
+            if (!options.quiet) {
+                process.stderr.write(chalk.gray(`  ${target.name}: unreachable or no agents CLI — skipped\n`));
+            }
+            return [];
+        }
+        return parsed.items;
     }));
-    return { items: results.flat(), deviceCount: targets.length, skipped };
+    return { items: results.flat(), deviceCount: targets.length, skipped, parseFailed, discoveryFailed: false };
 }

package/dist/lib/routines.d.ts

@@ -293,6 +293,47 @@ export declare function finalizeRunMeta(meta: RunMeta, status: RunMeta['status']
  * catchup/overdue, manual run) gates on this.
  */
 export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'devices'>): boolean;
+/**
+ * The ONE device that owns a routine — the single daemon allowed to fire it.
+ *
+ * `devices` is an allowlist, and every listed device used to fire
+ * independently, so a routine pinned to two boxes ran **twice** per schedule:
+ * two full agent sessions doing identical work, burning double the quota. On
+ * this fleet seven routines were in that state, e.g. `security-sweep` running
+ * at 15:30:02 on one box and 15:30:03 on the other, both completing.
+ *
+ * Ownership is a pure function of the config — the first entry in normalized
+ * sort order — so every daemon independently reaches the same answer with no
+ * lease, no cross-device coordination, and no split brain when the fleet
+ * partitions. A multi-entry pin is a misconfiguration
+ * ({@link hasAmbiguousDevicePin}); this keeps such a routine running exactly
+ * once instead of silently dropping it, while `validateJob` refuses to create
+ * a new one and `agents doctor` surfaces the existing ones.
+ *
+ * Returns null when the routine is unrestricted (empty or omitted `devices`).
+ */
+export declare function routineOwnerDevice(config: Pick<JobConfig, 'devices'>): string | null;
+/**
+ * Does this routine name more than one distinct device? Such a pin used to mean
+ * "fire on each of them"; it now means "fire only on the first", which is
+ * almost certainly not what the author intended either way — so it is reported
+ * as a misconfiguration rather than silently reinterpreted.
+ */
+export declare function hasAmbiguousDevicePin(config: Pick<JobConfig, 'devices'>): boolean;
+/** One routine whose `devices` names more than one machine, with its resolved owner. */
+export interface AmbiguousDevicePin {
+    name: string;
+    devices: string[];
+    /** The device that now fires it — the rest are inert. */
+    owner: string;
+}
+/**
+ * Every routine carrying a multi-device pin. Surfaced by `agents doctor` and
+ * `agents routines list` so an existing misconfiguration is visible rather than
+ * silently reinterpreted: before ownership became singular each of these fired
+ * once per listed device, doubling the work and the agent spend.
+ */
+export declare function findAmbiguousDevicePins(cwd?: string): AmbiguousDevicePin[];
 /**
  * Resolve the effective host strategy for a job.
  * Bare `host:` without an explicit strategy implies `host` (back-compat with
@@ -487,6 +528,18 @@ export declare function discoverJobsFromRepo(repoPath: string): Array<{
 export declare function jobExists(name: string): boolean;
 /** Get the filesystem path of a job's YAML config file, or null if not found. */
 export declare function getJobPath(name: string): string | null;
+/**
+ * Resolve a routine's YAML across EVERY layer `listJobs`/`readJob` read — user
+ * then system — not just the user dir.
+ *
+ * `getJobPath` is user-layer only because its callers write there. Read paths
+ * that ask "when did this routine come to exist" need the system layer too:
+ * a built-in shipped in the system repo has no user-layer file and no
+ * `createdAt`, so a user-layer-only lookup returns null, the overdue floor is
+ * skipped, and the routine reads as instantly overdue on first daemon start —
+ * exactly the case the floor exists to prevent.
+ */
+export declare function resolveJobFilePath(name: string): string | null;
 /**
  * Parse an "at" time string into a one-shot cron expression.
  * Supports formats like:

package/dist/lib/routines.js

@@ -81,10 +81,67 @@ export function finalizeRunMeta(meta, status, exitCode, opts) {
  * catchup/overdue, manual run) gates on this.
  */
 export function jobRunsOnThisDevice(config) {
-    if (!config.devices || config.devices.length === 0)
+    const owner = routineOwnerDevice(config);
+    // Unrestricted: no pin means fleet-wide by design (`watchdog`, `check-updates`).
+    if (owner === null)
         return true;
-    const self = machineId();
-    return config.devices.some((d) => normalizeHost(d) === self);
+    return owner === machineId();
+}
+/**
+ * The ONE device that owns a routine — the single daemon allowed to fire it.
+ *
+ * `devices` is an allowlist, and every listed device used to fire
+ * independently, so a routine pinned to two boxes ran **twice** per schedule:
+ * two full agent sessions doing identical work, burning double the quota. On
+ * this fleet seven routines were in that state, e.g. `security-sweep` running
+ * at 15:30:02 on one box and 15:30:03 on the other, both completing.
+ *
+ * Ownership is a pure function of the config — the first entry in normalized
+ * sort order — so every daemon independently reaches the same answer with no
+ * lease, no cross-device coordination, and no split brain when the fleet
+ * partitions. A multi-entry pin is a misconfiguration
+ * ({@link hasAmbiguousDevicePin}); this keeps such a routine running exactly
+ * once instead of silently dropping it, while `validateJob` refuses to create
+ * a new one and `agents doctor` surfaces the existing ones.
+ *
+ * Returns null when the routine is unrestricted (empty or omitted `devices`).
+ */
+export function routineOwnerDevice(config) {
+    // A non-array `devices` is a separate validation error; don't throw here and
+    // don't double-report it.
+    if (!Array.isArray(config.devices))
+        return null;
+    const devices = config.devices.map((d) => normalizeHost(String(d))).filter(Boolean);
+    if (devices.length === 0)
+        return null;
+    return [...devices].sort()[0];
+}
+/**
+ * Does this routine name more than one distinct device? Such a pin used to mean
+ * "fire on each of them"; it now means "fire only on the first", which is
+ * almost certainly not what the author intended either way — so it is reported
+ * as a misconfiguration rather than silently reinterpreted.
+ */
+export function hasAmbiguousDevicePin(config) {
+    if (!Array.isArray(config.devices))
+        return false;
+    const devices = new Set(config.devices.map((d) => normalizeHost(String(d))).filter(Boolean));
+    return devices.size > 1;
+}
+/**
+ * Every routine carrying a multi-device pin. Surfaced by `agents doctor` and
+ * `agents routines list` so an existing misconfiguration is visible rather than
+ * silently reinterpreted: before ownership became singular each of these fired
+ * once per listed device, doubling the work and the agent spend.
+ */
+export function findAmbiguousDevicePins(cwd) {
+    return listJobs(cwd)
+        .filter((job) => job.enabled && hasAmbiguousDevicePin(job))
+        .map((job) => ({
+        name: job.name,
+        devices: (job.devices ?? []).map((d) => normalizeHost(d)),
+        owner: routineOwnerDevice(job) ?? '',
+    }));
 }
 /**
  * Resolve the effective host strategy for a job.
@@ -130,7 +187,10 @@ export function checkJobDeviceEligibility(config) {
         return null;
     const allowed = (config.devices ?? []).map((d) => normalizeHost(d));
     const allowedLabel = allowed.join(', ');
-    const firstHost = allowed[0] ?? 'HOST';
+    // The owner is the lowest normalized name, not the first entry as written —
+    // suggesting allowed[0] on an unsorted list points at a device that will
+    // refuse the run for exactly the same reason.
+    const firstHost = routineOwnerDevice(config) ?? allowed[0] ?? 'HOST';
     const message = `Job '${config.name}' can only run on: ${allowedLabel}`;
     const suggestion = `agents routines run ${config.name} --host ${firstHost}`;
     return { message, suggestion, allowedLabel, firstHost };
@@ -251,6 +311,17 @@ function readJobFile(filePath) {
         // treated as unavailable/inert rather than unrestricted.
         if (Object.prototype.hasOwnProperty.call(parsed, 'device'))
             return null;
+        // Fail closed on a malformed `devices` too. Ownership treats a non-array as
+        // "no pin", and the daemon's load path never calls validateJob — so a YAML
+        // typo (`devices: yosemite-s0` instead of a list) would silently promote the
+        // routine to fleet-wide and fire it on EVERY box. Inert-and-loud beats
+        // unrestricted-and-silent.
+        if (Object.prototype.hasOwnProperty.call(parsed, 'devices')
+            && parsed.devices !== undefined
+            && parsed.devices !== null
+            && !Array.isArray(parsed.devices)) {
+            return null;
+        }
         return {
             ...JOB_DEFAULTS,
             ...parsed,
@@ -523,6 +594,14 @@ export function validateJob(config) {
             }
         }
     }
+    // A routine belongs to exactly one device. Listing several used to fire it
+    // once per device — duplicate work, duplicate spend — and making them elect
+    // one owner at runtime would need cross-device coordination nobody wants.
+    if (hasAmbiguousDevicePin(config)) {
+        errors.push(`devices lists ${new Set(config.devices.map((d) => normalizeHost(String(d)))).size} devices; a routine runs on exactly one. ` +
+            'Pin the single device that should own it, e.g. devices: [yosemite-s0]. ' +
+            'Omit devices entirely for a routine that genuinely belongs on every machine.');
+    }
     if (config.catchup !== undefined && typeof config.catchup !== 'boolean') {
         errors.push('catchup must be a boolean (false to skip running a missed fire late)');
     }
@@ -946,6 +1025,28 @@ export function getJobPath(name) {
     }
     return null;
 }
+/**
+ * Resolve a routine's YAML across EVERY layer `listJobs`/`readJob` read — user
+ * then system — not just the user dir.
+ *
+ * `getJobPath` is user-layer only because its callers write there. Read paths
+ * that ask "when did this routine come to exist" need the system layer too:
+ * a built-in shipped in the system repo has no user-layer file and no
+ * `createdAt`, so a user-layer-only lookup returns null, the overdue floor is
+ * skipped, and the routine reads as instantly overdue on first daemon start —
+ * exactly the case the floor exists to prevent.
+ */
+export function resolveJobFilePath(name) {
+    const userPath = getJobPath(name);
+    if (userPath)
+        return userPath;
+    for (const ext of ['.yml', '.yaml']) {
+        const filePath = safeJoin(getSystemRoutinesDir(), name + ext);
+        if (fs.existsSync(filePath))
+            return filePath;
+    }
+    return null;
+}
 /**
  * Parse an "at" time string into a one-shot cron expression.
  * Supports formats like:

package/dist/lib/rules/run-sync.d.ts

@@ -0,0 +1,18 @@
+import type { AgentId } from '../types.js';
+/**
+ * Re-apply the active rules preset for (agent, version) into its version
+ * home when the composed source set has drifted since the last time this ran.
+ * Returns true when the version-home rules file was (re)written.
+ *
+ * No-cwd fingerprint on purpose: the version-home rules file never includes
+ * the project layer (see `staleness/writers/rules.ts` — project rules are
+ * resolved separately, at launch, into the workspace `AGENTS.md` by
+ * `compileRulesForProject`). Fingerprinting with a cwd would pull the project
+ * layer's subrules into the comparison and trigger a pointless version-home
+ * rewrite every time a project's own `.agents/rules/` changes.
+ *
+ * Silent on any failure (no rules.yaml, unknown preset, unsupported agent) —
+ * mirrors `syncResourcesToVersion`'s own catch-and-skip for rules: a bad
+ * preset must never block a launch, and this now also runs on the hot path.
+ */
+export declare function applyActiveRulesPresetAtRun(agent: AgentId, version: string, versionHome: string): boolean;

package/dist/lib/rules/run-sync.js

@@ -0,0 +1,92 @@
+/**
+ * Rules preset auto-apply at `agents run` launch time.
+ *
+ * `agents rules switch <agent>@<version> --preset <name>` persists the active
+ * preset (`state.ts:setActiveRulesPreset`) and immediately recompiles it into
+ * the version home via `syncResourcesToVersion` → the rules writer
+ * (`staleness/writers/rules.ts`). Same for `agents add`/`use`. But nothing
+ * re-applies the preset on a LATER `agents run` — if `setActiveRulesPreset`
+ * is ever called without a follow-up sync (or a subrule file changes after
+ * the last sync), the harness launches against a stale rules file until the
+ * next explicit `agents rules switch` / `agents sync`.
+ *
+ * This closes that gap the same way `runLaunchSync` (project-launch.ts)
+ * recompiles PROJECT rules on every launch: idempotent, and skip-fast when
+ * nothing changed. The skip-fast reuses the staleness checkers' mtime+size
+ * fingerprint comparison (`staleness/checkers/rules.ts`,
+ * `staleness/fingerprint.ts`) against a small per-(agent,version) sentinel —
+ * the same "hash the cheap inputs, compare, skip the write on a match" shape
+ * `installScope` (project-launch.ts) uses for plugin marketplaces. The common
+ * case (no preset or subrule change since the last run) costs one JSON read
+ * plus a handful of `stat()` calls — no recompose, no write.
+ *
+ * Version-level scope only — the active preset is keyed by (agent, version),
+ * matching `getActiveRulesPreset`. Per-model preset scoping is a follow-up.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { AGENTS } from '../agents.js';
+import { getActiveRulesPreset, getCacheDir } from '../state.js';
+import { getWriter } from '../staleness/registry.js';
+import { buildRules, isRulesStale } from '../staleness/checkers/rules.js';
+/** ~/.agents/.cache/rules-run-sync/ — regenerable; a lost sentinel just costs one extra compose+write. */
+function sentinelPath(agent, version) {
+    const key = `${agent}@${version}`.replace(/[^a-zA-Z0-9@._-]/g, '_');
+    return path.join(getCacheDir(), 'rules-run-sync', `${key}.json`);
+}
+function loadSentinel(agent, version) {
+    try {
+        return JSON.parse(fs.readFileSync(sentinelPath(agent, version), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveSentinel(agent, version, sentinel) {
+    const p = sentinelPath(agent, version);
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(sentinel));
+    }
+    catch {
+        // Best-effort — a failed write just means the next run redoes the compose+write.
+    }
+}
+/**
+ * Re-apply the active rules preset for (agent, version) into its version
+ * home when the composed source set has drifted since the last time this ran.
+ * Returns true when the version-home rules file was (re)written.
+ *
+ * No-cwd fingerprint on purpose: the version-home rules file never includes
+ * the project layer (see `staleness/writers/rules.ts` — project rules are
+ * resolved separately, at launch, into the workspace `AGENTS.md` by
+ * `compileRulesForProject`). Fingerprinting with a cwd would pull the project
+ * layer's subrules into the comparison and trigger a pointless version-home
+ * rewrite every time a project's own `.agents/rules/` changes.
+ *
+ * Silent on any failure (no rules.yaml, unknown preset, unsupported agent) —
+ * mirrors `syncResourcesToVersion`'s own catch-and-skip for rules: a bad
+ * preset must never block a launch, and this now also runs on the hot path.
+ */
+export function applyActiveRulesPresetAtRun(agent, version, versionHome) {
+    const cap = AGENTS[agent].capabilities.rules;
+    if (cap === false)
+        return false;
+    const rulesWriter = getWriter('rules', agent);
+    if (!rulesWriter)
+        return false;
+    const preset = getActiveRulesPreset(agent, version);
+    const current = buildRules(agent, version, '');
+    const stored = loadSentinel(agent, version);
+    if (stored && stored.preset === preset && !isRulesStale(stored.entry, agent, version, '')) {
+        return false; // skip-fast: preset unchanged AND composed source set unchanged
+    }
+    try {
+        rulesWriter.write({ version, versionHome, selection: { preset }, cwd: '' });
+    }
+    catch {
+        return false;
+    }
+    saveSentinel(agent, version, { preset, entry: current });
+    return true;
+}

package/dist/lib/scheduler.js

@@ -6,7 +6,7 @@
  * on startup and reloads them on SIGHUP.
  */
 import { Cron } from 'croner';
-import { listJobs, deleteJob, isPastEndAt, isPastOneShotRoutine, isOneShotRoutine, setJobEnabled, shouldPurgeCompletedOneShotRoutine, jobRunsOnThisDevice, } from './routines.js';
+import { listJobs, deleteJob, isPastEndAt, isPastOneShotRoutine, isOneShotRoutine, setJobEnabled, shouldPurgeCompletedOneShotRoutine, jobRunsOnThisDevice, hasAmbiguousDevicePin, routineOwnerDevice, } from './routines.js';
 /** In-memory cron scheduler that triggers a callback when jobs fire. */
 export class JobScheduler {
     jobs = new Map();
@@ -20,7 +20,17 @@ export class JobScheduler {
             // Trigger-only jobs (no cron schedule) fire via the webhook receiver,
             // not the cron loop — skip them here. Jobs pinned to another device
             // (routines are fleet-synced) never enter this machine's cron loop.
-            if (!config.enabled || !config.schedule || !jobRunsOnThisDevice(config))
+            if (!config.enabled || !config.schedule)
+                continue;
+            // A multi-device pin is a misconfiguration: it used to fire the routine
+            // once per listed device. It now fires only on the owner, but say so —
+            // silently reinterpreting someone's config is how this went unnoticed.
+            if (hasAmbiguousDevicePin(config)) {
+                const owner = routineOwnerDevice(config);
+                console.warn(`Job '${config.name}' pins ${config.devices.length} devices; a routine runs on exactly one. ` +
+                    `Firing only on '${owner}'. Fix with: agents routines devices ${config.name} --set ${owner}`);
+            }
+            if (!jobRunsOnThisDevice(config))
                 continue;
             if (shouldPurgeCompletedOneShotRoutine(config)) {
                 deleteJob(config.name);

package/dist/lib/secrets/index.d.ts

@@ -193,11 +193,10 @@ export declare function rekeyStatus(): {
  * Throws when the item cannot be reached — on macOS, when the signed helper is
  * unavailable. That is deliberate: this primitive gates destructive writes as
  * well as reads. Through `bundleExists()` it guards the `--force` overwrite
- * checks in `agents secrets create` (`../../commands/secrets.ts`), the
- * bundle-rename purge (`./bundles.ts`), the pull-rollback bookkeeping
- * (`./sync.ts`), and the reuse-never-overwrite rule for `R2_SYNC_ENC_KEY`
- * (`../session/sync/provision.ts`). A false "absent" silently disarms every one
- * of them, so an unreachable keychain must fail loudly rather than answer "no".
+ * checks in `agents secrets create` (`../../commands/secrets.ts`) and the
+ * bundle-rename purge (`./bundles.ts`), and the pull-rollback bookkeeping
+ * (`./sync.ts`). A false "absent" silently disarms every one of them, so an
+ * unreachable keychain must fail loudly rather than answer "no".
  *
  * Tests needing this path without a helper install a backend via
  * `setKeychainBackendForTest()`, which short-circuits on the next line.

package/dist/lib/secrets/index.js

@@ -680,11 +680,10 @@ export function rekeyStatus() {
  * Throws when the item cannot be reached — on macOS, when the signed helper is
  * unavailable. That is deliberate: this primitive gates destructive writes as
  * well as reads. Through `bundleExists()` it guards the `--force` overwrite
- * checks in `agents secrets create` (`../../commands/secrets.ts`), the
- * bundle-rename purge (`./bundles.ts`), the pull-rollback bookkeeping
- * (`./sync.ts`), and the reuse-never-overwrite rule for `R2_SYNC_ENC_KEY`
- * (`../session/sync/provision.ts`). A false "absent" silently disarms every one
- * of them, so an unreachable keychain must fail loudly rather than answer "no".
+ * checks in `agents secrets create` (`../../commands/secrets.ts`) and the
+ * bundle-rename purge (`./bundles.ts`), and the pull-rollback bookkeeping
+ * (`./sync.ts`). A false "absent" silently disarms every one of them, so an
+ * unreachable keychain must fail loudly rather than answer "no".
  *
  * Tests needing this path without a helper install a backend via
  * `setKeychainBackendForTest()`, which short-circuits on the next line.

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

@@ -265,6 +265,14 @@ export declare function activeStatusFromCloudStatus(status: CloudTaskStatus): Ac
 export interface ActiveQueryOptions {
     /** Skip the `ps` scan for ad-hoc headless agents. */
     skipHeadless?: boolean;
+    /**
+     * A `--local` query: this machine only. Never dial a remote-host teammate
+     * (one dispatched via `agents teams add --device`) over ssh — report its
+     * last-persisted meta.json state instead of polling it. RUSH-2118: without
+     * this, `agents sessions --active --local` still fired one ssh round-trip
+     * per remote-host teammate (finished or not) on every call.
+     */
+    localOnly?: boolean;
 }
 /**
  * A live process can only borrow an indexed session file if that transcript
@@ -421,8 +429,14 @@ export declare function computeLiveSignals(kind: string, sessionFile: string | u
  * and truncates. Exported for tests.
  */
 export declare function summarizeMission(prompt: string | null | undefined): string | undefined;
-/** Live teams teammates. Reuses AgentManager which already polls PIDs via `kill -0`. */
-export declare function listTeamsActive(): Promise<ActiveSession[]>;
+/**
+ * Live teams teammates. Reuses AgentManager which already polls PIDs via
+ * `kill -0`. `localOnly` (RUSH-2118) skips the ssh round-trip AgentManager
+ * would otherwise issue for every distributed (remote-host) teammate.
+ */
+export declare function listTeamsActive(opts?: {
+    localOnly?: boolean;
+}): Promise<ActiveSession[]>;
 /** Live editor-terminal agents across every IDE window. */
 export declare function listTerminalsActive(): Promise<ActiveSession[]>;
 /** Cloud tasks still in a non-terminal state. `tasks.db` may not exist; that's fine. */

package/dist/lib/session/active.js

@@ -697,9 +697,13 @@ export function summarizeMission(prompt) {
         return undefined;
     return cleaned.length > 80 ? `${cleaned.slice(0, 79)}…` : cleaned;
 }
-/** Live teams teammates. Reuses AgentManager which already polls PIDs via `kill -0`. */
-export async function listTeamsActive() {
-    const mgr = new AgentManager();
+/**
+ * Live teams teammates. Reuses AgentManager which already polls PIDs via
+ * `kill -0`. `localOnly` (RUSH-2118) skips the ssh round-trip AgentManager
+ * would otherwise issue for every distributed (remote-host) teammate.
+ */
+export async function listTeamsActive(opts = {}) {
+    const mgr = new AgentManager(undefined, undefined, undefined, undefined, undefined, opts.localOnly ?? false);
     const running = await mgr.listRunning();
     return running.map((a) => {
         // The teammate's OWN transcript is `remoteSessionId` (captured from its first
@@ -1438,7 +1442,7 @@ export async function listTmuxAgentSessions() {
 export async function getActiveSessions(opts = {}) {
     const [tmuxAgents, teams, terminals, cloud] = await Promise.all([
         listTmuxAgentSessions().catch(() => []),
-        listTeamsActive().catch(() => []),
+        listTeamsActive({ localOnly: opts.localOnly }).catch(() => []),
         listTerminalsActive().catch(() => []),
         Promise.resolve(listCloudActive()),
     ]);

package/dist/lib/session/bundle.js

@@ -19,12 +19,16 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import * as crypto from 'crypto';
 import { SYNC_AGENTS, mirrorPath } from './sync/agents.js';
-import { hashContent } from './sync/manifest.js';
 import { redactSecrets } from '../redact.js';
 import { encryptTranscript, decryptTranscriptBody } from './sync/transcript-crypto.js';
 export const BUNDLE_KIND = 'agents-session-bundle';
 export const BUNDLE_VERSION = 1;
+/** SHA-256 of a file body, used for the bundle's dedup/conflict check on import. */
+function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
 /** Look up the sync spec for an agent id (undefined → agent not sync-representable). */
 export function specForAgent(agentId) {
     return SYNC_AGENTS.find(s => s.id === agentId);

package/dist/lib/session/remote-list.d.ts

@@ -1,12 +1,4 @@
 import type { SessionMeta } from './types.js';
-/**
- * The command run on each peer: answer for itself, as JSON, without recursing.
- * `forwardedArgs` carry the caller's own query/filters (already including the
- * leading `sessions` and a `--json`) so each peer returns a comparable slice.
- * A Windows peer gets a PowerShell invocation (ssh lands in cmd.exe/PowerShell
- * there, where `bash -lc` is not a command); every other OS keeps `bash -lc`.
- */
-export declare function remoteListCommand(forwardedArgs: string[], os?: string): string;
 /**
  * Parse a peer's `sessions --json` stdout into `SessionMeta[]`, tagging each
  * with `machine`. Defensive against version skew / partial output: non-JSON or
@@ -17,15 +9,9 @@ export declare function remoteListCommand(forwardedArgs: string[], os?: string):
  */
 export declare function parseRemoteList(stdout: string, machine: string): SessionMeta[];
 export declare function parseRemoteListPayload(stdout: string, machine: string, safeResolver?: boolean): {
-    sessions: SessionMeta[];
+    items: SessionMeta[];
     valid: boolean;
 };
-/** Convert one completed peer process into the exact aggregation result. This
- * is the production parent/peer seam and is exercised with real child output. */
-export declare function remoteListCaptureResult(code: number | null, stdout: string, machine: string, display: string, safeResolver?: boolean): {
-    sessions: SessionMeta[];
-    unreachable?: string;
-};
 export interface RemoteListResult {
     sessions: SessionMeta[];
     /** How many peer machines we attempted to reach (drives the empty-fleet tip). */