@phnx-labs/agents-cli 1.22.24 → 1.22.26

package/dist/lib/session/tool-store.js

@@ -28,11 +28,17 @@ export function toolEvidenceSourcePath(filePath, agent) {
     return filePath;
 }
 function deleteSessionCalls(db, sessionId) {
-    const keys = db.prepare(`SELECT call_key FROM tool_calls WHERE session_id = ?`).all(sessionId);
-    for (const { call_key } of keys) {
-        db.prepare(`DELETE FROM tool_call_programs WHERE call_key = ?`).run(call_key);
-        db.prepare(`DELETE FROM tool_program_occurrences WHERE call_key = ?`).run(call_key);
-        db.prepare(`DELETE FROM tool_call_text WHERE call_key = ?`).run(call_key);
+    const rows = db.prepare(`SELECT rowid, call_key FROM tool_calls WHERE session_id = ?`)
+        .all(sessionId);
+    const deletePrograms = db.prepare(`DELETE FROM tool_call_programs WHERE call_key = ?`);
+    const deleteOccurrences = db.prepare(`DELETE FROM tool_program_occurrences WHERE call_key = ?`);
+    // Addressed by rowid, never by the UNINDEXED call_key — see the tool_call_text
+    // schema comment in db.ts. A call_key predicate scans the whole FTS index.
+    const deleteText = db.prepare(`DELETE FROM tool_call_text WHERE rowid = ?`);
+    for (const { rowid, call_key } of rows) {
+        deletePrograms.run(call_key);
+        deleteOccurrences.run(call_key);
+        deleteText.run(rowid);
     }
     db.prepare(`DELETE FROM tool_calls WHERE session_id = ?`).run(sessionId);
 }
@@ -61,8 +67,11 @@ export function purgeMissingToolCallsInDirectory(db, dirPath, currentFilePaths)
     }
     return purged;
 }
-/** Persist one parser batch and its file stamp atomically. */
-export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replace', maxSessionBytes = TOOL_SESSION_EVIDENCE_MAX_BYTES) {
+/** Persist one parser batch, its file stamp, and its resume point atomically. */
+export function persistToolCalls(db, session, calls, sourceStamp, options = {}) {
+    const mode = options.mode ?? 'replace';
+    const maxSessionBytes = options.maxSessionBytes ?? TOOL_SESSION_EVIDENCE_MAX_BYTES;
+    const resume = options.resume ?? null;
     const sourcePath = toolEvidenceSourcePath(session.filePath, session.agent);
     const insertCall = db.prepare(`
     INSERT INTO tool_calls (
@@ -89,16 +98,19 @@ export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replac
     INSERT INTO tool_program_occurrences (call_key, occurrence_ordinal, program, role)
     VALUES (?, ?, ?, ?)
   `);
-    const insertText = db.prepare(`INSERT INTO tool_call_text (call_key, tool, input, output, error) VALUES (?, ?, ?, ?, ?)`);
+    // tool_call_text rows are addressed by the rowid of the tool_calls row they
+    // describe (db.ts schema comment): its UNINDEXED call_key cannot be seeked.
+    const insertText = db.prepare(`INSERT INTO tool_call_text (rowid, call_key, tool, input, output, error) VALUES (?, ?, ?, ?, ?, ?)`);
+    const callRowid = db.prepare(`SELECT rowid FROM tool_calls WHERE call_key = ?`);
     const deletePrograms = db.prepare(`DELETE FROM tool_call_programs WHERE call_key = ?`);
     const deleteOccurrences = db.prepare(`DELETE FROM tool_program_occurrences WHERE call_key = ?`);
-    const deleteText = db.prepare(`DELETE FROM tool_call_text WHERE call_key = ?`);
+    const deleteText = db.prepare(`DELETE FROM tool_call_text WHERE rowid = ?`);
     const deleteCall = db.prepare(`DELETE FROM tool_calls WHERE call_key = ?`);
     const writeLedger = db.prepare(`
     INSERT INTO tool_scan_ledger (
       session_id, file_path, file_mtime_ms, file_size, extractor_version, indexed_at, call_count,
-      evidence_bytes
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      evidence_bytes, parser_state, parsed_offset
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
       file_path = excluded.file_path,
       file_mtime_ms = excluded.file_mtime_ms,
@@ -106,7 +118,9 @@ export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replac
       extractor_version = excluded.extractor_version,
       indexed_at = excluded.indexed_at,
       call_count = excluded.call_count,
-      evidence_bytes = excluded.evidence_bytes
+      evidence_bytes = excluded.evidence_bytes,
+      parser_state = excluded.parser_state,
+      parsed_offset = excluded.parsed_offset
   `);
     const txn = db.transaction(() => {
         if (mode === 'replace')
@@ -119,7 +133,7 @@ export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replac
             throw new Error('Append tool evidence requires an existing tool ledger row.');
         }
         if (mode === 'append' && calls.length === 0) {
-            writeLedger.run(session.id, ledgerPath, sourceStamp.fileMtimeMs, sourceStamp.fileSize, TOOL_INDEX_VERSION, Date.now(), priorLedger.call_count, priorLedger.evidence_bytes);
+            writeLedger.run(session.id, ledgerPath, sourceStamp.fileMtimeMs, sourceStamp.fileSize, TOOL_INDEX_VERSION, Date.now(), priorLedger.call_count, priorLedger.evidence_bytes, resume?.parserState ?? null, resume?.parsedOffset ?? null);
             return;
         }
         const limitKey = toolCallKey(session.id, TOOL_INDEX_LIMIT_ORDINAL);
@@ -129,9 +143,11 @@ export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replac
         const priorLimit = mode === 'append'
             ? existingSize.get(session.id, TOOL_INDEX_LIMIT_ORDINAL)
             : undefined;
+        const limitRow = callRowid.get(limitKey);
         deletePrograms.run(limitKey);
         deleteOccurrences.run(limitKey);
-        deleteText.run(limitKey);
+        if (limitRow)
+            deleteText.run(limitRow.rowid);
         deleteCall.run(limitKey);
         const existingRows = mode === 'append'
             ? calls.map((call) => ({
@@ -182,17 +198,20 @@ export function persistToolCalls(db, session, calls, sourceStamp, mode = 'replac
         for (const call of accepted) {
             const key = toolCallKey(session.id, call.ordinal);
             insertCall.run(key, session.id, call.ordinal, call.sourceCallId ?? null, call.timestamp, call.tool, call.input, call.outcome, call.exitCode ?? null, call.statusCode ?? null, call.errorCode ?? null, call.output ?? null, call.error ?? null, call.parseError ?? null, toolCallEvidenceBytes(call));
+            // The upsert above preserves the rowid of a call it updated, so this is
+            // the same rowid the existing text row (if any) was written under.
+            const { rowid } = callRowid.get(key);
             deletePrograms.run(key);
             deleteOccurrences.run(key);
-            deleteText.run(key);
+            deleteText.run(rowid);
             for (const program of call.programs)
                 insertProgram.run(key, program);
             call.programOccurrences.forEach((occurrence, occurrenceOrdinal) => {
                 insertOccurrence.run(key, occurrenceOrdinal, occurrence.program, occurrence.role);
             });
-            insertText.run(key, call.tool, call.input, call.output ?? '', call.error ?? '');
+            insertText.run(rowid, key, call.tool, call.input, call.output ?? '', call.error ?? '');
         }
-        writeLedger.run(session.id, ledgerPath, sourceStamp.fileMtimeMs, sourceStamp.fileSize, TOOL_INDEX_VERSION, Date.now(), count, storedBytes);
+        writeLedger.run(session.id, ledgerPath, sourceStamp.fileMtimeMs, sourceStamp.fileSize, TOOL_INDEX_VERSION, Date.now(), count, storedBytes, resume?.parserState ?? null, resume?.parsedOffset ?? null);
     });
     txn();
 }

package/dist/lib/shims.js

@@ -584,6 +584,18 @@ elif [ "$AGENT" = "muse" ]; then
       esac
     fi
   fi
+elif [ "$AGENT" = "warp" ]; then
+  # Warp Agent CLI installs a global, self-updating oz binary (brew cask on
+  # macOS, the oz-stable apt|yum|pacman package on Linux) -- a platform/package
+  # specific location, not ~/.local/bin -- so resolve it from PATH with the same
+  # shims-dir re-exec guard as droid/muse.
+  BINARY=$(adopted_original_bin || echo "")
+  if [ -z "$BINARY" ]; then
+    BINARY=$(command -v oz 2>/dev/null || echo "")
+    case "$(readlink -f "$BINARY" 2>/dev/null)" in
+      "$AGENTS_USER_DIR/.cache/shims/"*) BINARY="" ;;
+    esac
+  fi
 else
   BINARY="$VERSION_DIR/node_modules/.bin/$CLI_COMMAND"
 fi
@@ -1041,7 +1053,15 @@ else
     "$HOME/.agents/.cache/shims/"*) BINARY="" ;;
   esac
 fi`
-                : `BINARY="${versionDir}/node_modules/.bin/${agentConfig.cliCommand}"`;
+                : agent === 'warp'
+                    ? `# Warp Agent CLI installs a global self-updating \`oz\` binary (brew cask on
+# macOS, oz-stable apt|yum|pacman on Linux) — a platform-specific location, not
+# ~/.local/bin — so resolve it from PATH, refusing anything under our shims dir.
+BINARY=$(command -v oz 2>/dev/null || echo "")
+case "$BINARY" in
+  "$HOME/.agents/.cache/shims/"*) BINARY="" ;;
+esac`
+                    : `BINARY="${versionDir}/node_modules/.bin/${agentConfig.cliCommand}"`;
     return `#!/bin/bash
 # Auto-generated by agents-cli - do not edit
 # ${VERSIONED_ALIAS_VERSION_MARKER} ${VERSIONED_ALIAS_SCHEMA_VERSION}

package/dist/lib/signin-badge.js

@@ -24,6 +24,8 @@ export function loginHint(agentId) {
             return `${cli}, then /login`;
         case 'codex':
         case 'grok':
+        // Warp Agent CLI: `oz login` opens a browser sign-in (or set WARP_API_KEY).
+        case 'warp':
             return `${cli} login`;
         case 'opencode':
             return `${cli} auth login`;

package/dist/lib/ssh-exec.js

@@ -117,7 +117,11 @@ export function sshExec(target, remoteCmd, opts = {}) {
         stdio: ['pipe', 'pipe', 'pipe'],
         windowsHide: true,
     });
-    const timedOut = !!(res.error && res.error.code === 'ETIMEDOUT');
+    // Node's spawnSync with a `timeout` option kills the child via SIGTERM and sets
+    // res.signal (e.g. 'SIGTERM') — it does NOT set res.error.code = 'ETIMEDOUT'.
+    // Check both so the detection fires whether the timeout is signalled or errored.
+    const timedOut = !!(res.error && res.error.code === 'ETIMEDOUT') ||
+        (!!opts.timeoutMs && res.signal !== null);
     return {
         code: typeof res.status === 'number' ? res.status : null,
         stdout: res.stdout ?? '',
@@ -206,7 +210,9 @@ export function sshExecRaw(target, remoteCmd, opts = {}) {
         stdio: ['pipe', 'pipe', 'pipe'],
         windowsHide: true,
     });
-    const timedOut = !!(res.error && res.error.code === 'ETIMEDOUT');
+    // Same fix as sshExec: spawnSync sets res.signal, not error.code = 'ETIMEDOUT'.
+    const timedOut = !!(res.error && res.error.code === 'ETIMEDOUT') ||
+        (!!opts.timeoutMs && res.signal !== null);
     return {
         code: typeof res.status === 'number' ? res.status : null,
         stdout: res.stdout ?? Buffer.alloc(0),

package/dist/lib/startup/command-registry.d.ts

@@ -47,6 +47,7 @@ export declare const loadMonitors: ModuleLoader;
 export declare const loadProjects: ModuleLoader;
 export declare const loadRun: ModuleLoader;
 export declare const loadResume: ModuleLoader;
+export declare const loadReconnect: ModuleLoader;
 export declare const loadFork: ModuleLoader;
 export declare const loadDefaults: ModuleLoader;
 export declare const loadSet: ModuleLoader;
@@ -131,3 +132,18 @@ export declare const LAZY_COMMAND_NAMES: ReadonlySet<string>;
  * are handled directly in src/index.ts.
  */
 export declare const COMMAND_LOADERS: Record<string, ModuleLoader[]>;
+/**
+ * Every top-level command name the CLI answers to — the loader table plus the
+ * inline aliases/tombstones above. This is the "does this command exist?"
+ * predicate for code that runs BEFORE commander parses, most importantly the
+ * `--host`/`--device` router (lib/hosts/passthrough.ts): without it a typo'd
+ * command carrying `--host` reported a flag-support error instead of
+ * `unknown command` (RUSH-2022).
+ *
+ * Commander sub-aliases (`sessions ls`, `teams rm`, …) are deliberately absent —
+ * this set is top-level only. `command-registry.test.ts` pins it against the real
+ * registered command tree so a new command can never drift out of it.
+ */
+export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
+/** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
+export declare function isKnownTopLevelCommand(name: string): boolean;

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

@@ -25,6 +25,7 @@ export const loadMonitors = async () => (await import('../../commands/monitors.j
 export const loadProjects = async () => (await import('../../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
 export const loadResume = async () => (await import('../../commands/resume.js')).registerResumeCommand;
+export const loadReconnect = async () => (await import('../../commands/reconnect.js')).registerReconnectCommand;
 export const loadFork = async () => (await import('../../commands/fork.js')).registerForkCommand;
 export const loadDefaults = async () => (await import('../../commands/defaults.js')).registerDefaultsCommands;
 export const loadSet = async () => (await import('../../commands/set.js')).registerSetCommand;
@@ -53,6 +54,7 @@ export const loadUsage = async () => (await import('../../commands/usage.js')).r
 export const loadCost = async () => (await import('../../commands/cost.js')).registerCostCommand;
 export const loadInsights = async () => (await import('../../commands/insights.js')).registerInsightsCommand;
 export const loadPerf = async () => (await import('../../commands/perf.js')).registerPerfCommand;
+// Thin deprecated alias of `agents insights mix` — no second mix implementation.
 export const loadTrends = async () => (await import('../../commands/trends.js')).registerTrendsCommand;
 export const loadOutput = async () => (await import('../../commands/output.js')).registerOutputCommand;
 export const loadBudget = async () => (await import('../../commands/budget.js')).registerBudgetCommand;
@@ -98,6 +100,7 @@ export const loadHumans = async () => (await import('../../commands/humans.js'))
 export const LAZY_COMMAND_NAMES = new Set([
     'sessions',
     'resume',
+    'reconnect',
     'roster',
     'teams',
     'cloud',
@@ -146,11 +149,17 @@ export const COMMAND_LOADERS = {
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
+    // packages.ts also registers `publish` at top level (commands/packages.ts:435).
+    // It was missing here, so `agents publish` only worked via the unknown-command
+    // fallback that registers the whole tree — and the --host router could not see
+    // it as a real command at all (RUSH-2022).
+    publish: [loadPackages],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     projects: [loadProjects],
     run: [loadRun],
     resume: [loadResume],
+    reconnect: [loadReconnect],
     fork: [loadFork],
     defaults: [loadDefaults],
     set: [loadSet],
@@ -231,3 +240,40 @@ export const COMMAND_LOADERS = {
     funnel: [loadFunnel],
     humans: [loadHumans],
 };
+/**
+ * Top-level names that {@link COMMAND_LOADERS} does not carry because they are
+ * registered inline in src/index.ts — closures over entry-point state (the
+ * deprecated aliases and tombstones) plus the internal/upgrade commands. They are
+ * real commands, so anything that asks "does this command exist?" must count them.
+ */
+const INLINE_COMMAND_NAMES = [
+    'perms', // deprecated alias -> permissions
+    'exec', // deprecated alias -> run
+    'jobs', // deprecated alias -> routines
+    'cron', // deprecated alias -> routines
+    'check', // tombstone -> doctor --check
+    'resources', // tombstone -> view --merged
+    'hq', // tombstone
+    '_internal',
+    'upgrade',
+];
+/**
+ * Every top-level command name the CLI answers to — the loader table plus the
+ * inline aliases/tombstones above. This is the "does this command exist?"
+ * predicate for code that runs BEFORE commander parses, most importantly the
+ * `--host`/`--device` router (lib/hosts/passthrough.ts): without it a typo'd
+ * command carrying `--host` reported a flag-support error instead of
+ * `unknown command` (RUSH-2022).
+ *
+ * Commander sub-aliases (`sessions ls`, `teams rm`, …) are deliberately absent —
+ * this set is top-level only. `command-registry.test.ts` pins it against the real
+ * registered command tree so a new command can never drift out of it.
+ */
+export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
+    ...Object.keys(COMMAND_LOADERS),
+    ...INLINE_COMMAND_NAMES,
+]);
+/** Whether `name` is a top-level command this CLI registers. See {@link KNOWN_TOP_LEVEL_COMMANDS}. */
+export function isKnownTopLevelCommand(name) {
+    return KNOWN_TOP_LEVEL_COMMANDS.has(name);
+}

package/dist/lib/teams/agents.d.ts

@@ -1,5 +1,6 @@
 import { captureProcessStartTime } from '../platform/index.js';
 import { AgentType } from './parsers.js';
+import { NoViableDeviceError } from './scheduler.js';
 /**
  * Compute the Lowest Common Ancestor (LCA) of multiple file paths.
  * Returns the deepest common directory shared by all paths.
@@ -405,6 +406,18 @@ export declare class AgentManager {
      * teammate schedules identically no matter how it was fired.
      */
     private maybeSchedulePlacement;
+    /** Human label of a teammate's agent for the placement fail-loud message. */
+    private placementAgentLabel;
+    /**
+     * Pre-flight the team pool at `teams start` (RUSH-2002): probe the pool and
+     * confirm each distinct agent among the pending, unpinned, pooled teammates
+     * has at least one viable device. Returns the first {@link NoViableDeviceError}
+     * so the command can fail loud BEFORE launching a wave, rather than silently
+     * leaving teammates stranded pending. A poolless team (no `--devices`) or a
+     * probe that could not gather positive evidence returns null — fail-loud fires
+     * only on proof that no device can run the agent, never on a probe miss.
+     */
+    preflightPlacement(taskName: string): Promise<NoViableDeviceError | null>;
     /**
      * One-ssh-per-host batched liveness/exit pre-pass for a team's remote teammates.
      * The supervisor calls this each wave BEFORE listByTask() so the per-teammate

package/dist/lib/teams/agents.js

@@ -34,7 +34,8 @@ import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 import { pullRemoteLogDelta, REMOTE_MIRROR_MAX_BYTES } from '../hosts/progress.js';
 import { createRemoteWorktree, ensureRemoteRepo } from './remoteWorktree.js';
 import { getTeam } from './registry.js';
-import { resolvePlacement, cappedDevices } from './scheduler.js';
+import { resolvePlacement, classifyExclusions, NoViableDeviceError } from './scheduler.js';
+import { probePoolSignals } from './placement-probe.js';
 import { readMaxConcurrentCaps } from '../device-config.js';
 import chalk from 'chalk';
 let lastMemoryWarnAt = 0;
@@ -197,7 +198,7 @@ export function buildTeammateSpawnEnv(envOverrides) {
  */
 export { captureProcessStartTime };
 /** Agent types the team runner supports. */
-const TEAM_AGENT_TYPES = ['codex', 'cursor', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid'];
+const TEAM_AGENT_TYPES = ['codex', 'cursor', 'claude', 'opencode', 'grok', 'antigravity', 'kimi', 'droid', 'warp'];
 // Suffix appended to all prompts to ensure agents provide a summary
 const PROMPT_SUFFIX = `
 
@@ -1756,7 +1757,7 @@ export class AgentManager {
      * (immediate add-launch) and startReady() (staged launch) so an unpinned pool
      * teammate schedules identically no matter how it was fired.
      */
-    async maybeSchedulePlacement(agent, taskName) {
+    async maybeSchedulePlacement(agent, taskName, opts = {}) {
         if (agent.hostName || agent.cloudProvider)
             return;
         const teamMeta = await getTeam(taskName);
@@ -1765,15 +1766,79 @@ export class AgentManager {
         const roster = await this.listByTask(taskName);
         const pool = teamMeta.devices ?? [];
         const maxConcurrent = pool.length > 1 ? readMaxConcurrentCaps(pool) : undefined;
-        if (maxConcurrent) {
-            for (const c of cappedDevices(pool, roster, maxConcurrent)) {
-                console.error(chalk.dim(`[placement] '${c.device}' excluded from auto-pick — at its agents.max-concurrent cap (${c.running}/${c.cap} running)`));
+        // On the start path (opts.probe), gather live signals so the pick is health-,
+        // harness-, and load-aware (RUSH-2002); the add path stays the cap-only
+        // roster count so `teams add` never blocks on an SSH fan-out. Cached per
+        // (pool, agent), so a wave placing many teammates probes the pool once.
+        const signals = opts.probe && pool.length > 0
+            ? await probePoolSignals(pool, agent.agentType, { now: Date.now() })
+            : undefined;
+        const placeOpts = {
+            maxConcurrent,
+            signals,
+            agentLabel: this.placementAgentLabel(agent),
+        };
+        if (signals) {
+            for (const e of classifyExclusions(pool, roster, placeOpts).excluded) {
+                const why = e.reason === 'capped'
+                    ? `at its agents.max-concurrent cap (${e.detail} running)`
+                    : e.reason === 'not-installed'
+                        ? `does not have ${this.placementAgentLabel(agent)} installed`
+                        : e.reason;
+                console.error(chalk.dim(`[placement] '${e.device}' excluded from auto-pick — ${why}`));
             }
         }
-        const { device } = resolvePlacement(teamMeta, null, roster, { maxConcurrent });
+        const { device } = resolvePlacement(teamMeta, null, roster, placeOpts);
         if (device)
             await this.resolveScheduledPlacement(agent, device, taskName);
     }
+    /** Human label of a teammate's agent for the placement fail-loud message. */
+    placementAgentLabel(agent) {
+        return agent.version ? `${agent.agentType}@${agent.version}` : String(agent.agentType);
+    }
+    /**
+     * Pre-flight the team pool at `teams start` (RUSH-2002): probe the pool and
+     * confirm each distinct agent among the pending, unpinned, pooled teammates
+     * has at least one viable device. Returns the first {@link NoViableDeviceError}
+     * so the command can fail loud BEFORE launching a wave, rather than silently
+     * leaving teammates stranded pending. A poolless team (no `--devices`) or a
+     * probe that could not gather positive evidence returns null — fail-loud fires
+     * only on proof that no device can run the agent, never on a probe miss.
+     */
+    async preflightPlacement(taskName) {
+        await this.initialize();
+        const teamMeta = await getTeam(taskName);
+        const pool = teamMeta?.devices ?? [];
+        if (!teamMeta || pool.length === 0)
+            return null;
+        const roster = await this.listByTask(taskName);
+        const pending = roster.filter((a) => a.status === AgentStatus.PENDING && !a.hostName && !a.cloudProvider);
+        if (pending.length === 0)
+            return null;
+        const maxConcurrent = pool.length > 1 ? readMaxConcurrentCaps(pool) : undefined;
+        // One representative teammate per distinct agent type — the signal + gate is
+        // per harness, not per teammate.
+        const byAgent = new Map();
+        for (const a of pending)
+            if (!byAgent.has(a.agentType))
+                byAgent.set(a.agentType, a);
+        for (const [, rep] of byAgent) {
+            const signals = await probePoolSignals(pool, rep.agentType, { now: Date.now() });
+            try {
+                resolvePlacement(teamMeta, null, roster, {
+                    maxConcurrent,
+                    signals,
+                    agentLabel: this.placementAgentLabel(rep),
+                });
+            }
+            catch (err) {
+                if (err instanceof NoViableDeviceError)
+                    return err;
+                throw err;
+            }
+        }
+        return null;
+    }
     /**
      * One-ssh-per-host batched liveness/exit pre-pass for a team's remote teammates.
      * The supervisor calls this each wave BEFORE listByTask() so the per-teammate
@@ -1866,9 +1931,12 @@ export class AgentManager {
             // immediate-add and staged paths agree. A null pick keeps hostName null →
             // local spawn, unchanged. Cloud teammates never schedule.
             try {
-                await this.maybeSchedulePlacement(agent, taskName);
+                await this.maybeSchedulePlacement(agent, taskName, { probe: true });
             }
             catch (err) {
+                // A NoViableDeviceError means the pool cannot host this teammate right
+                // now — leave it PENDING (never a silent local fallback) and surface the
+                // reason; a transient device loss is retried next wave.
                 console.error(`Could not schedule ${agent.agentId} onto the team pool:`, err);
                 continue;
             }

package/dist/lib/teams/parsers.d.ts

@@ -1,5 +1,5 @@
 /** Supported agent CLI types for team spawning. */
-export type AgentType = 'codex' | 'gemini' | 'cursor' | 'claude' | 'opencode' | 'grok' | 'antigravity' | 'kimi' | 'droid';
+export type AgentType = 'codex' | 'gemini' | 'cursor' | 'claude' | 'opencode' | 'grok' | 'antigravity' | 'kimi' | 'droid' | 'warp';
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export declare function normalizeEvents(agentType: AgentType, raw: any): any[];
 /** Normalize a raw JSON event, returning only the first unified event (convenience wrapper). */

package/dist/lib/teams/placement-probe.d.ts

@@ -0,0 +1,21 @@
+import { type AgentType } from './agents.js';
+import type { DevicePlacementSignal } from './scheduler.js';
+/** Per-remote readiness probe budget — matches the health probe's short window
+ * (`agents view` on a warm box is sub-second; a wedged one degrades to unknown). */
+export declare const READY_PROBE_TIMEOUT_MS = 8000;
+/** How long a probed pool snapshot is reused within a `teams start` wave. Short
+ * enough that a device coming online / going overloaded is seen next wave, long
+ * enough that placing a wave of teammates does not re-fan-out per teammate. */
+export declare const SIGNAL_TTL_MS = 15000;
+/** Clear the probe cache — for tests and after a device-registry change. */
+export declare function clearPlacementSignalCache(): void;
+/**
+ * Probe every device in the team pool and return a name→signal map for the pure
+ * placement pick. Devices with no data at all are omitted (the pick then neither
+ * excludes nor prefers them). Never throws — a probe failure degrades to a
+ * missing/partial signal.
+ */
+export declare function probePoolSignals(pool: string[], agent: AgentType, opts?: {
+    force?: boolean;
+    now?: number;
+}): Promise<Map<string, DevicePlacementSignal>>;

package/dist/lib/teams/placement-probe.js

@@ -0,0 +1,135 @@
+/**
+ * Live pool probing for the teams placement scheduler (RUSH-2002).
+ *
+ * Gathers one {@link DevicePlacementSignal} per pool device so the pure pick in
+ * {@link ./scheduler} can filter unreachable / overloaded / not-installed
+ * devices and rank the rest. Two concerns, both best-effort:
+ *
+ *   - reachability + headroom + load  ← {@link probeFleetStats} (one parallel
+ *     SSH fan-out over the pool; the local box is measured directly).
+ *   - requested agent installed (+ signed in, locally)  ← a one-shot readiness
+ *     probe per remote device ({@link buildReadyProbeCommand} → `agents view`),
+ *     the local box via {@link checkCliAvailable}/{@link checkCliSignedIn}.
+ *
+ * The result is cached briefly per (pool, agent) so a `teams start` wave that
+ * places N teammates probes the pool ONCE, not N times — the roster-count part
+ * of the rank stays live (the pure pick recounts the roster each call), only the
+ * SSH-measured load/harness snapshot is reused within the TTL.
+ *
+ * All SSH here is via `execFile` (async, bounded) so the whole pool is probed in
+ * parallel; a slow or wedged box degrades to "no signal" instead of blocking the
+ * launch. Remote sign-in is deliberately left unknown — sign-in detection is
+ * unreliable over SSH (see {@link checkCliSignedIn}); it ranks the local box
+ * only, and the install gate (not sign-in) is what drives the fail-loud.
+ */
+import { execFile } from 'child_process';
+import { probeFleetStats, headroom } from '../devices/health.js';
+import { loadDevicesSync } from '../devices/registry.js';
+import { buildSshInvocation, writeAskpassShim } from '../devices/connect.js';
+import { buildReadyProbeCommand, parseReadyProbe, viewHasAgent } from '../hosts/ready.js';
+import { localMachineId } from '../session/origin-machine.js';
+import { normalizeHost } from '../machine-id.js';
+import { checkCliAvailable, checkCliSignedIn } from './agents.js';
+/** Per-remote readiness probe budget — matches the health probe's short window
+ * (`agents view` on a warm box is sub-second; a wedged one degrades to unknown). */
+export const READY_PROBE_TIMEOUT_MS = 8_000;
+/** How long a probed pool snapshot is reused within a `teams start` wave. Short
+ * enough that a device coming online / going overloaded is seen next wave, long
+ * enough that placing a wave of teammates does not re-fan-out per teammate. */
+export const SIGNAL_TTL_MS = 15_000;
+const cache = new Map();
+function cacheKey(pool, agent) {
+    return `${agent}::${[...pool].map(normalizeHost).sort().join(',')}`;
+}
+/** Clear the probe cache — for tests and after a device-registry change. */
+export function clearPlacementSignalCache() {
+    cache.clear();
+}
+/**
+ * Whether the requested agent is installed on a REMOTE device, via one SSH
+ * readiness probe. `undefined` when the probe could not answer (ssh/login
+ * failure) — reachability is then left to {@link probeFleetStats}; `false` when
+ * the box answered but agents-cli or the agent is absent (a genuine can't-run).
+ */
+function probeRemoteInstalled(device, agent) {
+    let args;
+    let env;
+    try {
+        const shim = writeAskpassShim();
+        const cmd = buildReadyProbeCommand(device.shell === 'powershell' ? 'windows' : undefined);
+        // agentOnly: a read-only probe must never force a foreground Touch ID sheet
+        // on a password-auth device (mirrors probeDeviceStats in devices/health).
+        ({ args, env } = buildSshInvocation(device, [cmd], shim, {}, { agentOnly: true }));
+    }
+    catch {
+        return Promise.resolve(undefined);
+    }
+    return new Promise((resolve) => {
+        execFile('ssh', args, { encoding: 'utf-8', env: { ...process.env, ...env }, timeout: READY_PROBE_TIMEOUT_MS }, (err, stdout) => {
+            if (err || !stdout)
+                return resolve(undefined);
+            const probe = parseReadyProbe(stdout);
+            if (!probe.reachable)
+                return resolve(undefined); // ssh/login issue → unknown
+            if (!probe.version)
+                return resolve(false); // agents-cli missing → cannot run
+            resolve(viewHasAgent(probe.view, agent));
+        });
+    });
+}
+/**
+ * Probe every device in the team pool and return a name→signal map for the pure
+ * placement pick. Devices with no data at all are omitted (the pick then neither
+ * excludes nor prefers them). Never throws — a probe failure degrades to a
+ * missing/partial signal.
+ */
+export async function probePoolSignals(pool, agent, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const key = cacheKey(pool, agent);
+    const cached = cache.get(key);
+    if (!opts.force && cached && now - cached.at < SIGNAL_TTL_MS)
+        return cached.signals;
+    const reg = loadDevicesSync();
+    const self = normalizeHost(localMachineId());
+    const lookup = (name) => reg[name] ?? reg[normalizeHost(name)];
+    const profiles = [];
+    const seen = new Set();
+    for (const name of pool) {
+        const d = lookup(name);
+        if (d && !seen.has(d.name)) {
+            profiles.push(d);
+            seen.add(d.name);
+        }
+    }
+    const selfProfile = profiles.find((d) => normalizeHost(d.name) === self);
+    const stats = await probeFleetStats(profiles, { selfName: selfProfile?.name });
+    const installed = new Map(await Promise.all(profiles.map(async (d) => {
+        const isSelf = normalizeHost(d.name) === self;
+        if (isSelf) {
+            const inst = checkCliAvailable(agent)[0];
+            const signedIn = inst ? await checkCliSignedIn(agent) : undefined;
+            return [d.name, { installed: inst, signedIn }];
+        }
+        // Remote sign-in stays unknown (see the module docblock); the install
+        // gate is what drives the fail-loud.
+        return [d.name, { installed: await probeRemoteInstalled(d, agent), signedIn: undefined }];
+    })));
+    const signals = new Map();
+    for (const name of pool) {
+        const d = lookup(name);
+        const s = d ? stats.get(d.name) : undefined;
+        const inst = d ? installed.get(d.name) : undefined;
+        if (!s && !inst)
+            continue; // fully unknown device — leave it out of the map
+        signals.set(name, {
+            reachable: s?.reachable,
+            headroom: s ? headroom(s) : undefined,
+            loadPercent: s?.loadPercent,
+            memPercent: s?.memPercent,
+            installed: inst?.installed,
+            signedIn: inst?.signedIn,
+        });
+    }
+    cache.set(key, { at: now, signals });
+    return signals;
+}