@phnx-labs/agents-cli 1.20.43 → 1.20.45

package/dist/commands/secrets.js

@@ -12,7 +12,9 @@ import * as fs from 'fs';
 import { SSH_TARGET_RE, assertValidSshTarget, sshExec } from '../lib/ssh-exec.js';
 import { quoteWin32ExecArg, composeWin32CommandLine } from '../lib/platform/index.js';
 import { ensureDaemonStarted } from '../lib/daemon.js';
-import { parseHostsOption, remoteResolveEnv, remoteSecretsRaw, resolveSshTarget, } from '../lib/secrets/remote.js';
+import { parseHostsOption, remoteResolveEnv, remoteSecretsRaw, remoteSecretsStream, resolveSshTarget, } from '../lib/secrets/remote.js';
+import { remoteShellFor, buildWindowsStdinImportCommand } from '../lib/hosts/remote-cmd.js';
+import { resolveRemoteOsSync } from '../lib/hosts/remote-os.js';
 import { bundleExists, bundleItemStore, bundlePolicy, deleteBundle, describeBundle, keychainItemsForBundle, keychainRef, listBundles, migrateLegacyBundles, parseDotenv, readAndResolveBundleEnv, readBundle, renameBundle, rotateBundleSecret, sanitizeProcessEnv, validateBundleName, validateEnvKey, validateExpiresFutureDated, validateSecretType, writeBundle, } from '../lib/secrets/bundles.js';
 import { getKeychainToken, getKeychainTokens, hasKeychainToken, secretsKeychainItem, setKeychainToken, } from '../lib/secrets/index.js';
 import { assertOpAvailable, createPasswordItem, deleteItemByTitle, extractSecrets, itemExistsByTitle, listItems, listVaults, } from '../lib/onepassword.js';
@@ -139,6 +141,29 @@ function readStdinSync() {
     }
     return Buffer.concat(chunks).toString('utf-8').trim();
 }
+/**
+ * Read the raw `.env` text for `import --from <path|->`. A `-` reads the .env
+ * from stdin (the SSH push path: `export --host` pipes the resolved dotenv over
+ * ssh stdin, which has no `/dev/stdin` on a Windows remote); any other value is
+ * a filesystem path.
+ */
+export function readImportDotenv(from) {
+    return from === '-' ? readStdinSync() : fs.readFileSync(from, 'utf-8');
+}
+/**
+ * Build the remote `agents secrets unlock` argv for `unlock --host`. `--all`
+ * forwards verbatim; otherwise the explicit bundle names. A `--ttl` is passed
+ * through as-is so the REMOTE parses its own duration (its platform rules, its
+ * defaults). Shared with the command action so the wiring is unit-testable
+ * without a live SSH session.
+ */
+export function buildRemoteUnlockArgs(names, opts) {
+    return [
+        'unlock',
+        ...(opts.all ? ['--all'] : names),
+        ...(opts.ttl ? ['--ttl', opts.ttl] : []),
+    ];
+}
 // SSH target validation is defined canonically in src/lib/ssh-exec.ts and
 // re-exported here for back-compat with existing importers of these symbols.
 export { SSH_TARGET_RE, assertValidSshTarget };
@@ -1162,7 +1187,7 @@ Examples:
     cmd
         .command('import [bundle]')
         .description('Import keys from a .env file or a 1Password vault into a bundle. The bundle is created if it does not exist. Values are stored in the bundle\'s backend (keychain by default).')
-        .option('--from <path>', 'Path to a .env file')
+        .option('--from <path>', 'Path to a .env file (use - to read the .env from stdin)')
         .option('--from-1password', 'Import secrets from a 1Password vault (requires the op CLI)')
         .option('--vault <name>', '1Password vault name (used with --from-1password)')
         .option('--all-plaintext', 'Store every imported value as a literal in the bundle metadata (skip keychain item creation)')
@@ -1227,7 +1252,7 @@ Examples:
                 console.log(chalk.green(`Imported ${added} key(s) from 1Password vault '${vault}'${skipped ? `, skipped ${skipped} (already set, pass --force)` : ''}.`));
             }
             else {
-                const raw = fs.readFileSync(opts.from, 'utf-8');
+                const raw = readImportDotenv(opts.from);
                 const pairs = parseDotenv(raw);
                 for (const [key, value] of Object.entries(pairs)) {
                     if (!opts.force && key in bundle.vars) {
@@ -1294,34 +1319,47 @@ Examples:
                 const { env } = readAndResolveBundleEnv(resolvedBundleName, { caller: `ssh export` });
                 const dotenv = bundleEnvToDotenv(env);
                 const keyCount = Object.keys(env).length;
-                // Drive the remote's own `agents secrets` CLI so values land in its
-                // chosen backend. `bash -lc` so the login PATH resolves `agents`; the
-                // .env (and, for file, the passphrase) flow over ssh stdin and are
-                // never parsed by a remote shell.
-                const force = opts.force ? ' --force' : '';
-                const backendFlag = remoteBackend === 'file' ? ' --backend file' : '';
-                let remoteAgents;
-                let input;
-                if (remoteBackend === 'file') {
-                    // import --backend file auto-creates the file-backed bundle; no
-                    // separate `create` needed.
-                    remoteAgents =
-                        `IFS= read -r AGENTS_SECRETS_PASSPHRASE; export AGENTS_SECRETS_PASSPHRASE; ` +
-                            `agents secrets import ${shellQuote(resolvedBundleName)} --from /dev/stdin${backendFlag}${force}`;
-                    input = `${remotePassphrase}\n${dotenv}`;
-                }
-                else {
-                    remoteAgents =
-                        `agents secrets create ${shellQuote(resolvedBundleName)} >/dev/null 2>&1 || true; ` +
-                            `agents secrets import ${shellQuote(resolvedBundleName)} --from /dev/stdin${force}`;
-                    input = dotenv;
-                }
-                const remoteCmd = `bash -lc ${shellQuote(remoteAgents)}`;
+                // Drive the remote's own `agents secrets import --from -` so the values
+                // land in its chosen backend, reading the .env off ssh stdin (never
+                // parsed by a remote shell — `--from -` replaces the POSIX-only
+                // `/dev/stdin`). The keychain path is built OS-aware via
+                // `remoteSecretsRaw` (bash -lc on POSIX, PowerShell on Windows), so it
+                // works on macOS, Linux AND Windows targets. `import` auto-creates the
+                // bundle, so no separate `create` (the old `|| true` was a POSIXism
+                // that broke on PowerShell: `'true' is not recognized`).
                 let failures = 0;
                 for (const host of hosts) {
-                    // Routed through the shared ssh engine: full hardened options
-                    // (BatchMode, ConnectTimeout, keepalive) + control-socket reuse.
-                    const res = sshExec(host, remoteCmd, { input });
+                    let res;
+                    if (remoteBackend === 'file') {
+                        // File backend forwards AGENTS_SECRETS_PASSPHRASE as the FIRST stdin
+                        // line (consumed by `read`, so it never lands in argv / `ps` /
+                        // remote history), then the .env. That `read`/`export` prologue is
+                        // POSIX shell — refuse a Windows target cleanly rather than emit
+                        // broken PowerShell.
+                        if (remoteShellFor(resolveRemoteOsSync(host.split('@').pop() ?? host)) === 'powershell') {
+                            failures++;
+                            console.error(chalk.red(`${host}: file backend export to a Windows target is not yet supported.`));
+                            continue;
+                        }
+                        const remoteAgents = `IFS= read -r AGENTS_SECRETS_PASSPHRASE; export AGENTS_SECRETS_PASSPHRASE; ` +
+                            `agents secrets import ${shellQuote(resolvedBundleName)} --from - --backend file${opts.force ? ' --force' : ''}`;
+                        res = sshExec(host, `bash -lc ${shellQuote(remoteAgents)}`, { input: `${remotePassphrase}\n${dotenv}` });
+                    }
+                    else if (remoteShellFor(resolveRemoteOsSync(host.split('@').pop() ?? host)) === 'powershell') {
+                        // Keychain on a Windows target: the `agents.ps1` shim doesn't
+                        // forward ssh-piped stdin to node, so `--from -` would hang.
+                        // Bridge the piped .env through PowerShell into a temp file and
+                        // import `--from <file>` (deleted afterwards). Same hardened ssh
+                        // engine, .env still only ever crosses the wire over ssh stdin.
+                        res = sshExec(host, buildWindowsStdinImportCommand(resolvedBundleName, { force: opts.force }), { input: dotenv });
+                    }
+                    else {
+                        // Keychain on a POSIX target: OS-aware wrapping + hardened ssh
+                        // engine (BatchMode, ConnectTimeout, keepalive, control-socket
+                        // reuse) via the same path the READ inverse (`remoteResolveEnv`)
+                        // uses. `--from -` reads the .env off ssh stdin.
+                        res = remoteSecretsRaw(host, ['import', resolvedBundleName, '--from', '-', ...(opts.force ? ['--force'] : [])], { input: dotenv });
+                    }
                     if (res.code === null) {
                         failures++;
                         console.error(chalk.red(`${host}: ${res.stderr.trim() || (res.timedOut ? 'ssh timed out' : 'ssh failed')}`));
@@ -1554,10 +1592,47 @@ Examples:
     });
     cmd
         .command('unlock [names...]')
-        .description('Hold a bundle in the secrets-agent after one Touch ID, so concurrent runs read it without re-prompting (macOS).')
+        .description('Hold a bundle in the secrets-agent after one Touch ID, so concurrent runs read it without re-prompting (macOS). With --host, unlock FILE-backed bundle(s) on a remote (the passphrase prompt surfaces over the SSH TTY); keychain/biometry bundles are GUI-only and can\'t be remote-unlocked.')
         .option('--ttl <duration>', 'How long to hold it (e.g. 30m, 8h, 3d). Default 7d.')
         .option('--all', 'Unlock every configured bundle')
+        .option('--host <target>', 'Unlock the bundle(s) on this remote machine over SSH instead of locally (file-backed bundles only — the remote\'s passphrase prompt surfaces on your terminal over a -tt session). Single-valued (NOT variadic) so it never swallows the bundle name: `unlock <name> --host <machine>`.')
         .action(async (names, opts) => {
+        // Single-valued (not variadic): a variadic --host greedily consumes the
+        // positional bundle name (`unlock --host mac wztest` -> host=[mac,wztest],
+        // names=[]). Unlock targets one remote at a time anyway.
+        const hosts = opts.host ? [opts.host] : [];
+        if (hosts.length > 0) {
+            // Remote unlock: the REMOTE enforces its own platform rules, so the
+            // local darwin-only guard below does NOT apply. Only file-backed
+            // bundles are remote-unlockable — their passphrase prompt surfaces over
+            // the -tt SSH TTY; a keychain/biometry bundle would trigger a local GUI
+            // Touch-ID sheet that can't cross SSH.
+            if (!opts.all && (!names || names.length === 0)) {
+                console.error(chalk.red('Specify one or more bundle names, or --all.'));
+                process.exit(1);
+            }
+            const unlockArgs = buildRemoteUnlockArgs(names, opts);
+            let failures = 0;
+            for (const h of hosts) {
+                const target = await resolveSshTarget(h);
+                // FOREGROUND stream (stdio inherited), NOT the piped remoteSecretsRaw:
+                // the remote's passphrase prompt only surfaces if the remote process
+                // sees a real TTY, which requires our local terminal to pass straight
+                // through. The remote's prompt + output stream to this terminal; we get
+                // back only the exit code.
+                const code = remoteSecretsStream(target, unlockArgs);
+                if (code === 0) {
+                    console.log(chalk.green(`${h}: unlocked`));
+                }
+                else {
+                    failures++;
+                    console.error(chalk.red(`${h}: unlock failed (exit ${code})`));
+                }
+            }
+            if (failures > 0)
+                process.exit(1);
+            return;
+        }
         if (process.platform !== 'darwin') {
             console.error(chalk.red('secrets-agent is macOS-only (no biometry prompt to deduplicate elsewhere).'));
             process.exit(1);

package/dist/commands/sessions.d.ts

@@ -1,5 +1,5 @@
 import type { Command } from 'commander';
-import type { SessionAgentId, SessionMeta } from '../lib/session/types.js';
+import type { SessionAgentId, SessionMeta, ViewMode } from '../lib/session/types.js';
 import { type ActiveSession } from '../lib/session/active.js';
 import { type PickedSession } from './sessions-picker.js';
 /**
@@ -149,11 +149,12 @@ export declare function buildOverviewGroups(pool: SessionMeta[], perProjectCap:
     projectCount: number;
 };
 /**
- * Render a session's full transcript to stdout — the non-follow view behind
- * `agents logs <sessionId>`. Reuses the same markdown renderer as
- * `agents sessions <id> --markdown`.
+ * Render a resolved session to stdout — the non-follow view behind
+ * `agents logs <sessionId>`. Defaults to the concise `summary` digest (same as
+ * `agents sessions <id>`); pass `'markdown'` for the full transcript
+ * (`agents logs <id> --full`). Reuses the shared `renderSession` renderer.
  */
-export declare function renderSessionLog(session: SessionMeta): Promise<void>;
+export declare function renderSessionLog(session: SessionMeta, mode?: ViewMode): Promise<void>;
 /** Column-visibility flags for the picker row, computed once over the whole pool. */
 export interface PickerColumns {
     /** Render the machine column (only when the pool spans more than one machine). */

package/dist/commands/sessions.js

@@ -425,7 +425,14 @@ export function groupActiveSessions(sessions) {
  * to the same id form); else the local machine. Never keys off `ActiveSession.host`
  * — that is the terminal *app* (code/tmux), not the computer.
  */
+/** Synthetic top-level group key for provider-sandboxed cloud tasks. */
+const CLOUD_MACHINE_KEY = 'cloud';
 function machineKeyFor(s, localMachine) {
+    // Cloud tasks run in a provider sandbox, not on the machine they're attributed
+    // to for reply routing (s.machine = the querier). Surface them as their own
+    // top-level "cloud" group instead of nested under the local device.
+    if (s.context === 'cloud')
+        return CLOUD_MACHINE_KEY;
     if (s.machine)
         return s.machine;
     if (s.provenance?.host)
@@ -449,6 +456,11 @@ export function groupSessionsByMachine(sessions, localMachine) {
             return -1;
         if (b === localMachine)
             return 1;
+        // The synthetic "cloud" category sorts after all real machines.
+        if (a === CLOUD_MACHINE_KEY)
+            return 1;
+        if (b === CLOUD_MACHINE_KEY)
+            return -1;
         const ac = byMachine.get(a).length, bc = byMachine.get(b).length;
         if (ac !== bc)
             return bc - ac;
@@ -575,38 +587,48 @@ function groupTally(sessions) {
     return parts.join(' · ');
 }
 /** Print one machine's workspace tree, indented under its machine header. */
-function renderWorkspaceLayout(layout, base) {
+function renderWorkspaceLayout(layout, base, machineKey) {
     let first = true;
     for (const ws of layout.workspaces) {
         if (!first)
             console.log();
         first = false;
-        const header = ws.key === '__cloud__'
-            ? chalk.magenta.bold('cloud')
-            : ws.key === '__unknown__'
-                ? chalk.gray.bold('unknown')
-                : chalk.cyan.bold(shortCwd(ws.key));
-        const wsSessions = [...ws.windows.flatMap(w => w.sessions), ...ws.flat];
-        const tally = groupTally(wsSessions);
-        console.log(`${base}${header} ${chalk.gray(`(${ws.total})`)}${tally ? chalk.gray(`  ${tally}`) : ''}`);
+        // Under the top-level "cloud" machine group the __cloud__ workspace header is
+        // redundant ("▸ cloud" then "cloud") — render its rows flat under the machine
+        // header instead. Row indent collapses by one level to match.
+        const redundantCloud = ws.key === '__cloud__' && machineKey === CLOUD_MACHINE_KEY;
+        const rowBase = redundantCloud ? base : base + '  ';
+        if (!redundantCloud) {
+            const header = ws.key === '__cloud__'
+                ? chalk.magenta.bold('cloud')
+                : ws.key === '__unknown__'
+                    ? chalk.gray.bold('unknown')
+                    : chalk.cyan.bold(shortCwd(ws.key));
+            const wsSessions = [...ws.windows.flatMap(w => w.sessions), ...ws.flat];
+            const tally = groupTally(wsSessions);
+            console.log(`${base}${header} ${chalk.gray(`(${ws.total})`)}${tally ? chalk.gray(`  ${tally}`) : ''}`);
+        }
         for (const win of ws.windows) {
             // Host is per-process, but every terminal in the same IDE window shares
             // an ancestor — take the first non-empty host as the window's label.
             const host = win.sessions.find((s) => s.host)?.host ?? 'terminal';
             const winHeader = `${chalk.gray(host)} ${chalk.gray('·')} ${chalk.gray(shortWindowLabel(win.windowId))} ${chalk.gray(`(${win.sessions.length})`)}`;
-            console.log(base + '  ' + winHeader);
+            console.log(rowBase + winHeader);
             for (const s of win.sessions)
-                printActiveRow(s, base + '    ');
+                printActiveRow(s, rowBase + '  ');
         }
         for (const s of ws.flat)
-            printActiveRow(s, base + '  ');
+            printActiveRow(s, rowBase);
     }
 }
 /** Machine header: `▸ <name> ← this machine` for the local box (cyan), matching
  * the `ag devices list` treatment; a plain `▸ <name>` for remotes. */
 function printMachineHeader(mg) {
-    const marker = mg.isLocal ? chalk.cyan('▸ ') : chalk.gray('▸ ');
-    const name = mg.isLocal ? chalk.bold.cyan(mg.machine) : chalk.bold(mg.machine);
+    // The synthetic "cloud" group isn't a device — tint it magenta (matching the
+    // cloud row/label styling) so it reads as a category, not a machine.
+    const isCloud = mg.machine === CLOUD_MACHINE_KEY;
+    const marker = mg.isLocal ? chalk.cyan('▸ ') : isCloud ? chalk.magenta('▸ ') : chalk.gray('▸ ');
+    const name = mg.isLocal ? chalk.bold.cyan(mg.machine) : isCloud ? chalk.bold.magenta(mg.machine) : chalk.bold(mg.machine);
     const here = mg.isLocal ? chalk.cyan('  ← this machine') : '';
     console.log(`${marker}${name} ${chalk.gray(`(${mg.total})`)}${here}`);
 }
@@ -740,11 +762,16 @@ async function renderActiveSessions(asJson, waitingOnly = false, opts = {}) {
             console.log();
         firstMachine = false;
         printMachineHeader(mg);
-        renderWorkspaceLayout(mg.layout, '  ');
+        renderWorkspaceLayout(mg.layout, '  ', mg.machine);
     }
     const parts = groupTally(sessions).split(' · ').filter(Boolean);
-    const machineWord = grouped.machines.length === 1 ? 'machine' : 'machines';
-    console.log(chalk.gray(`\n${sessions.length} active (${parts.join(', ')}) across ${grouped.machines.length} ${machineWord}.`));
+    // The synthetic "cloud" group is a category, not a machine — exclude it from the
+    // machine count and note it separately so the tally stays truthful.
+    const realMachines = grouped.machines.filter((m) => m.machine !== CLOUD_MACHINE_KEY).length;
+    const hasCloud = grouped.machines.some((m) => m.machine === CLOUD_MACHINE_KEY);
+    const machineWord = realMachines === 1 ? 'machine' : 'machines';
+    const cloudNote = hasCloud ? ' + cloud' : '';
+    console.log(chalk.gray(`\n${sessions.length} active (${parts.join(', ')}) across ${realMachines} ${machineWord}${cloudNote}.`));
     // Tip only when nothing else could be included and the user didn't opt out.
     if (!opts.local && !opts.hosts?.length && remoteDeviceCount === 0)
         printCrossMachineTip();
@@ -1258,12 +1285,13 @@ function resolveViewMode(options, filters) {
     return 'summary';
 }
 /**
- * Render a session's full transcript to stdout — the non-follow view behind
- * `agents logs <sessionId>`. Reuses the same markdown renderer as
- * `agents sessions <id> --markdown`.
+ * Render a resolved session to stdout — the non-follow view behind
+ * `agents logs <sessionId>`. Defaults to the concise `summary` digest (same as
+ * `agents sessions <id>`); pass `'markdown'` for the full transcript
+ * (`agents logs <id> --full`). Reuses the shared `renderSession` renderer.
  */
-export async function renderSessionLog(session) {
-    await renderSession(session, 'markdown', {});
+export async function renderSessionLog(session, mode = 'summary') {
+    await renderSession(session, mode, {});
 }
 async function renderSession(session, mode, filters, options = {}) {
     // OpenCode stores sessions in SQLite; filePath is "db_path#session_id"

package/dist/commands/teams.js

@@ -11,11 +11,13 @@ import { handleSpawn, handleStatus, handleStop, handleTasks, toTaskStatusSummary
 import { createTeam, ensureTeam, getTeam, loadTeams, removeTeam, teamExists, } from '../lib/teams/registry.js';
 import { setHelpSections } from '../lib/help.js';
 import { createWorktree, isGitRepo, hasUncommittedChanges, removeWorktree, } from '../lib/teams/worktree.js';
-import { isVersionInstalled, resolveVersionAlias, resolveVersionAliasLoose } from '../lib/versions.js';
+import { isVersionInstalled, resolveVersion, resolveVersionAlias, resolveVersionAliasLoose, verifyInstalledBinaryLaunches } from '../lib/versions.js';
 import { AGENTS, warnAgentDeprecated } from '../lib/agents.js';
 import { discoverSessions, parseTimeFilter, resolveSessionById } from '../lib/session/discover.js';
+import { renderSessionLog } from './sessions.js';
 import { buildPreview as buildSessionPreview } from './sessions-picker.js';
 import { parseExecEnv } from '../lib/exec.js';
+import { checkRunAccountReadiness } from '../lib/rotate.js';
 import { teamPicker, printTeamTable } from './teams-picker.js';
 import { itemPicker } from '../lib/picker.js';
 import { profileExists, readProfile } from '../lib/profiles.js';
@@ -191,6 +193,51 @@ export function wireCloudDispatcher(mgr) {
  * teammate whose CLI may not be signed in. Warn-only — never blocks `start`.
  * Local teammates only; cloud teammates authenticate through their provider.
  */
+/**
+ * Advisory line for a version-pinned teammate whose account can't serve a run
+ * right now. A pinned target (`agents run <agent>@<version>`) bypasses account
+ * rotation — the pin IS the target — so unlike a bare teammate it can't route
+ * around a throttled/expired account; it will launch and likely 429 at once.
+ */
+function throttleWarningLine(agent, version, r) {
+    const who = `${AGENT_NAMES[agent]} ${version}`;
+    const acct = r.email ? ` (${r.email})` : '';
+    const reason = r.reason === 'out_of_credits' ? 'is out of credits'
+        : r.reason === 'signed_out' ? 'is not signed in'
+            : 'is rate-limited right now';
+    return (chalk.yellow(`⚠ ${who}${acct} ${reason}.`) +
+        chalk.gray(`\n  A pinned version skips account rotation, so it will launch on this account and may immediately hit its limit.` +
+            `\n  Use a bare \`${agent}\` teammate to let the team pick a healthy account, or pass --force to silence this.`));
+}
+/**
+ * Advisory: for each staged VERSION-PINNED teammate, warn if its account is
+ * rate-limited / out of credits / signed out right now — reusing the router's
+ * own eligibility signal (`checkRunAccountReadiness`) so the warning matches
+ * what the spawn would actually do. Bare teammates (rotation handles them) and
+ * profile/cloud teammates (account not locally checkable) are skipped. Warns,
+ * never blocks. Deduped by agent@version so N teammates on one account warn once.
+ */
+async function warnThrottledTeammates(mgr, team) {
+    let pending;
+    try {
+        pending = (await mgr.listByTask(team)).filter((a) => a.status === 'pending' && !a.cloudProvider && !a.profileName && a.version);
+    }
+    catch {
+        return; // team not loadable yet — nothing to warn about
+    }
+    const seen = new Set();
+    for (const a of pending) {
+        const agent = a.agentType;
+        const version = a.version;
+        const key = `${agent}@${version}`;
+        if (seen.has(key) || !AGENT_NAMES[agent])
+            continue;
+        seen.add(key);
+        const readiness = await checkRunAccountReadiness(agent, version);
+        if (!readiness.ready)
+            console.error(throttleWarningLine(agent, version, readiness));
+    }
+}
 async function warnUnsignedTeammates(mgr, team) {
     let pending;
     try {
@@ -966,7 +1013,7 @@ export function registerTeamsCommands(program) {
         .option('--cloud <provider>', `Dispatch to cloud backend instead of local CLI: ${VALID_CLOUD_PROVIDERS.join('|')}`)
         .option('--repo <owner/repo>', 'GitHub repository (required for --cloud rush)')
         .option('--branch <name>', 'Target git branch for cloud dispatch')
-        .option('--force', "Skip the advisory 'may not be signed in' warning (detection is unreliable)")
+        .option('--force', "Skip the advisory 'may not be signed in' / 'account throttled' warnings")
         .option('--json', 'Output machine-readable JSON')
         .action(async (team, teammate, task, opts) => {
         if (!VALID_MODES.includes(opts.mode)) {
@@ -1006,6 +1053,16 @@ export function registerTeamsCommands(program) {
             console.error(chalk.yellow(`⚠ ${AGENT_NAMES[agent]} may not be signed in (detection is unreliable). Adding anyway.`) +
                 chalk.gray(`\n  If it fails to start, run \`${AGENTS[agent].cliCommand}\` to log in, or pass --force to silence this.`));
         }
+        // Advisory throttle check — only for a version-pinned teammate, which
+        // bypasses account rotation and so can't route around a rate-limited /
+        // out-of-credits / signed-out account (see throttleWarningLine). Skip bare
+        // targets (rotation handles them), profiles (auth-injected account isn't
+        // the version-home one we can read), and cloud dispatch. Warn, never block.
+        if (!opts.force && !cloudProviderId && !profileName && version) {
+            const readiness = await checkRunAccountReadiness(agent, version);
+            if (!readiness.ready)
+                console.error(throttleWarningLine(agent, version, readiness));
+        }
         if (opts.name !== undefined) {
             if (!opts.name || !/^[A-Za-z0-9_-]+$/.test(opts.name)) {
                 die(`Invalid teammate name '${opts.name}'. Use letters, numbers, '-', or '_'.`);
@@ -1275,7 +1332,7 @@ export function registerTeamsCommands(program) {
         .option('--watch', 'Keep running: poll every --interval seconds, fire new waves, exit when the DAG drains.')
         .option('--interval <seconds>', 'Seconds between waves in --watch mode (default 8)', '8')
         .option('--max-waves <n>', 'Safety cap on waves in --watch mode (default 1000)', '1000')
-        .option('--force', "Skip the advisory 'may not be signed in' warning for staged teammates (detection is unreliable)")
+        .option('--force', "Skip the advisory 'may not be signed in' / 'account throttled' warnings for staged teammates")
         .action(async (team, opts) => {
         const mgr = mkManager();
         wireCloudDispatcher(mgr);
@@ -1285,8 +1342,10 @@ export function registerTeamsCommands(program) {
                 return;
             team = picked;
         }
-        if (!opts.force && !isJsonMode(opts))
+        if (!opts.force && !isJsonMode(opts)) {
             await warnUnsignedTeammates(mgr, team);
+            await warnThrottledTeammates(mgr, team);
+        }
         if (!opts.watch) {
             await runOneWave(mgr, team, Boolean(opts.json));
             return;
@@ -1651,8 +1710,9 @@ export function registerTeamsCommands(program) {
     teams
         .command('logs [teammate]')
         .alias('log')
-        .description("Read a teammate's raw log output. Accepts positional name, --teammate <name>, UUID, or UUID prefix.")
-        .option('-n, --tail <n>', 'Show only the last N lines instead of the full log')
+        .description("Show a teammate's concise session summary. --full (or -n <lines>) for the raw stdout. Accepts positional name, --teammate <name>, UUID, or UUID prefix.")
+        .option('-n, --tail <n>', 'Show the last N lines of raw stdout instead of the concise summary')
+        .option('-m, --full', 'Show the full raw stdout log instead of the concise summary')
         .option('--team <team>', 'Disambiguate when the same name appears in multiple teams')
         .option('--teammate <name>', 'Teammate name (alias for the positional arg; useful for scripts)')
         .action(async (ref, opts) => {
@@ -1682,14 +1742,28 @@ export function registerTeamsCommands(program) {
             }
             agentId = resolved.agentId;
         }
+        // Concise by default: a teammate's agentId IS its agent session id (passed
+        // as --session-id at launch), so render the same summary digest as
+        // `agents sessions <id>`. --full / -n <lines> opt into the raw stdout.log.
+        if (!opts.full && !opts.tail) {
+            const all = await discoverSessions({ all: true, limit: 5000 });
+            const matches = resolveSessionById(all, agentId);
+            if (matches.length > 0) {
+                await renderSessionLog(matches[0], 'summary');
+                return;
+            }
+            // No resolvable session (e.g. a non-Claude teammate) — fall through to a
+            // bounded tail of raw stdout rather than dumping the whole file.
+        }
         const logPath = path.join(base, agentId, 'stdout.log');
         try {
             const content = await fs.readFile(logPath, 'utf-8');
-            if (!opts.tail) {
+            if (opts.full) {
                 process.stdout.write(content);
                 return;
             }
-            const n = Math.max(1, parseInt(opts.tail, 10) || 50);
+            // Default tail size keeps an un-resolvable teammate's glance bounded too.
+            const n = opts.tail ? Math.max(1, parseInt(opts.tail, 10) || 50) : 40;
             const lines = content.split('\n');
             process.stdout.write(lines.slice(-n).join('\n'));
         }
@@ -1705,6 +1779,28 @@ export function registerTeamsCommands(program) {
         .option('--json', 'Output machine-readable JSON')
         .action(async (opts) => {
         const info = checkAllClis();
+        // Deep integrity probe. `checkAllClis` reports presence (shim + stub guard),
+        // but a GUTTED native binary (JS wrapper present, platform binary missing —
+        // the codex/kimi optional-dep partial-extract failure) still passes that. So
+        // actually launch the resolved default version and, if it won't run, flip the
+        // agent to not-installed with a repair hint — otherwise doctor says "ready"
+        // and the teammate ENOENTs at spawn. Parallel; win32 is treated as healthy by
+        // verifyInstalledBinaryLaunches.
+        await Promise.all(Object.entries(info).map(async ([name, entry]) => {
+            if (!entry.installed)
+                return;
+            const agent = name;
+            const version = resolveVersion(agent);
+            if (!version)
+                return;
+            const health = await verifyInstalledBinaryLaunches(agent, version);
+            if (!health.ok) {
+                entry.installed = false;
+                entry.path = null;
+                entry.error = `${AGENTS[agent]?.cliCommand ?? name}@${version} is installed but its binary won't launch`
+                    + `${health.detail ? ` (${health.detail})` : ''}. Repair: agents add ${agent}@${version}`;
+            }
+        }));
         // Advisory enrichment only. Sign-in detection is UNRELIABLE, so it never
         // changes the authoritative installed/ready column — it annotates. And an
         // agent that is actually running in a team is treated as signed in

package/dist/lib/daemon.js

@@ -19,6 +19,7 @@ import { detectOverdueJobs, notifyOverdue } from './overdue.js';
 import { BrowserService } from './browser/service.js';
 import { BrowserIPCServer } from './browser/ipc.js';
 import { readAndResolveBundleEnv } from './secrets/bundles.js';
+import { redactSecrets } from './redact.js';
 const PID_FILE = 'daemon.pid';
 const LOCK_FILE = 'daemon.lock';
 const LOG_FILE = 'logs.jsonl';
@@ -207,15 +208,6 @@ export function reapStrayDaemons(keepPid = process.pid) {
     }
     return { reaped, details };
 }
-/** Redact values that look like tokens or credentials in a log message. */
-function redactSecrets(message) {
-    let safe = message;
-    safe = safe.replace(/eyJ[A-Za-z0-9_-]{20,}/g, '[REDACTED_TOKEN]');
-    safe = safe.replace(/Bearer\s+\S+/gi, 'Bearer [REDACTED]');
-    safe = safe.replace(/(sk-[a-zA-Z0-9]{20,})/g, '[REDACTED_KEY]');
-    safe = safe.replace(/(ANTHROPIC_API_KEY|OPENAI_API_KEY|API_KEY|SECRET|TOKEN|PASSWORD)=\S+/gi, '$1=[REDACTED]');
-    return safe;
-}
 function rotateLogsIfNeeded(logPath) {
     try {
         const stat = fs.statSync(logPath);
@@ -428,6 +420,37 @@ export async function runDaemon() {
     };
     const deviceProbeInterval = setInterval(() => { void runDeviceProbe(); }, 3 * 60_000);
     const deviceProbeKickoff = setTimeout(() => { void runDeviceProbe(); }, 15_000);
+    // tmux hook reconcile: retrofit the guarded `pane-died` hook onto managed
+    // `agents run` sessions a pre-fix binary left with the old unconditional hook
+    // (which detached the whole client — kicking the user out of the view — when
+    // they exited a split they'd opened). Non-destructive: set-hook only, never a
+    // kill or detach. A per-session schema marker makes steady-state a no-op, so
+    // this stays cheap at ~every 5 min, plus once ~20s after startup so a
+    // just-upgraded daemon heals still-running sessions without waiting for them to
+    // cycle or the shared server to be recycled.
+    let reconcilingTmux = false;
+    const runTmuxReconcile = async () => {
+        if (reconcilingTmux)
+            return;
+        reconcilingTmux = true;
+        try {
+            const { isTmuxInstalled } = await import('./tmux/binary.js');
+            if (!isTmuxInstalled())
+                return;
+            const { reconcileSessionHooks } = await import('./tmux/session.js');
+            const r = await reconcileSessionHooks();
+            if (r.reconciled > 0)
+                log('INFO', `tmux: retrofitted pane-died hook on ${r.reconciled} session(s)`);
+        }
+        catch (err) {
+            log('ERROR', `tmux reconcile failed: ${err.message}`);
+        }
+        finally {
+            reconcilingTmux = false;
+        }
+    };
+    const tmuxReconcileInterval = setInterval(() => { void runTmuxReconcile(); }, 5 * 60_000);
+    const tmuxReconcileKickoff = setTimeout(() => { void runTmuxReconcile(); }, 20_000);
     const handleReload = () => {
         log('INFO', 'Reloading jobs (SIGHUP)');
         scheduler.reloadAll();
@@ -447,6 +470,8 @@ export async function runDaemon() {
         clearTimeout(healKickoff);
         clearInterval(deviceProbeInterval);
         clearTimeout(deviceProbeKickoff);
+        clearInterval(tmuxReconcileInterval);
+        clearTimeout(tmuxReconcileKickoff);
         removeDaemonPid();
         process.exit(0);
     };

package/dist/lib/exec.d.ts

@@ -272,6 +272,14 @@ export declare function shouldWrapInTmux(ctx: TmuxWrapContext): boolean;
  * (`BASH_FUNC_*%%`) can't make `env` choke.
  */
 export declare function buildTmuxAgentCommand(executable: string, args: string[], env: NodeJS.ProcessEnv): string;
+/**
+ * Trim a raw `tmux capture-pane` dump to its last `maxLines` non-empty lines
+ * (right-stripping each). Used by runInTmux to recap a fast-failed agent's
+ * output into the caller's shell so a launch crash (e.g. a gutted install that
+ * dies with ENOENT the instant it spawns) isn't swallowed by the bare
+ * `[detached]` the pane-died hook otherwise leaves behind.
+ */
+export declare function formatPaneTail(raw: string, maxLines?: number): string;
 /** Exit code spawnAgent resolves with when a run is killed for crossing a budget cap. */
 export declare const BUDGET_KILL_EXIT_CODE = 7;
 /**