@phnx-labs/agents-cli 1.20.43 → 1.20.45

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## 1.20.45
+
+- **NEW: `agents run <agent> --host <name>` without a prompt forwards your TTY over SSH and runs the agent interactively on the remote host.** Previously `--host` runs required a prompt and were always headless (`agents run <agent> "<task>" --host <name>`). Now, omitting the prompt takes the interactive path: when local stdin is a TTY, the local CLI SSHes with `-tt`, runs `agents run <agent>` on the host, and lets the remote machine's `agents` start its normal tmux wrapper. The tmux session lives on the remote box, so detaching (`Ctrl-b d`) ends the SSH connection but keeps the agent running; you can reattach from the host or resume by session id. Session ids for Claude are still minted up front so `agents sessions` can surface and resolve the remote run. `--no-follow` is rejected for interactive host runs (it is meaningless for an attached TTY), and `--mode`, `--model`, `--name`, passthrough args after `--`, and `--raw`/`--no-tmux` are forwarded to the remote invocation. Source: `apps/cli/src/commands/exec.ts`, `apps/cli/src/lib/hosts/dispatch.ts`, `apps/cli/src/lib/hosts/session-index.ts`, `apps/cli/docs/hosts.md`.
+
+- **`agents secrets export --host` now works against Windows targets, and a new `agents secrets unlock --host` unlocks a bundle on a remote machine.** The export push was POSIX-only (`bash -lc`, `--from /dev/stdin`, `create … || true`, `IFS= read`), so a Windows remote died with `'true' is not recognized … cannot find the path specified`. Two changes fix it: `agents secrets import` now accepts **`--from -`** (read the `.env` from stdin, replacing the POSIX-only `/dev/stdin`), and the push is **platform-aware** — `bash -lc` on POSIX, `powershell -EncodedCommand` on Windows, with the target's OS taken from the device registry. Because the npm `agents.ps1` shim does **not** forward ssh-piped stdin to the underlying node process (a raw `--from -` read hangs), the Windows keychain push bridges the piped `.env` through PowerShell into a temp file and imports `--from <file>` (deleted afterwards). File-backend export to a Windows target is refused cleanly rather than emitting broken PowerShell. Verified end-to-end: `agents secrets export linear.app --host win-mini` imported all 13 keys. Separately, **`agents secrets unlock --host <machine> <bundle>`** runs the unlock ON the remote over `ssh -tt`, so a **file-backed** bundle's passphrase prompt surfaces on your terminal — the "unlock the Mac from the road with its password" path; keychain/biometry bundles are GUI-only (a local Touch-ID/passcode sheet can't cross SSH) and can't be remote-unlocked. `unlock`'s `--host` is single-valued so it never swallows the positional bundle name. Source: `apps/cli/src/commands/secrets.ts`, `apps/cli/src/lib/hosts/remote-cmd.ts`.
+- **A session now has ONE name, not two. `--name` seeds the session label instead of a parallel column.** Shipping `agents run --name` (1.20.43) as a separate immutable `name` column created two look-alike fields — an unshown, frozen `name` and the shown, searchable `label` — that both resolved `agents sessions <ref>` and forced tie-break bookkeeping nobody could keep straight. They unify into one field. `--name` is now the universal way to *seed* the `label` at launch — the same field an agent-generated title (Claude's `/rename`) later refines and `agents sessions` displays and searches — and it works consistently across interactive, headless, `--host`, and teams teammate runs (a teammate's friendly name now seeds its session label; before, teammate sessions had no name at all). Priority is a plain fallback chain resolved at scan time, no stored winner: an agent-generated title wins, else the `--name` seed, else the listing falls back to `topic`. So a Claude run's `--name` shows until Claude titles it (your seed, then refined); a non-Claude run keeps its `--name` as the label (it has no auto-title). The seeded name is now fuzzy-searchable in FTS (the old `name` column was not). `agents hosts logs <name>` is unchanged — it resolves against the host-task sidecar, not the session column. Schema v10 folds any existing `name` into `label` (where the label was empty), mirrors it into the FTS row, then drops the `name` column; the run-name sidecars re-seed every scan (`seedLabelsFromNames`), so no rescan is needed. Reworks the 1.20.43 `--name` design (partly reverts its separate-column approach). Source: `apps/cli/src/lib/session/{db,discover,run-names,types}.ts`, `apps/cli/src/lib/hosts/session-index.ts`, `apps/cli/src/lib/teams/agents.ts`, `apps/cli/src/commands/exec.ts`, `apps/cli/docs/{05-sessions,hosts}.md`.
+- **NEW: `agents teams add`/`start` warns when a *version-pinned* teammate is on a throttled or signed-out account.** The 1.20.43 `balanced`-default fix keeps *bare* teammates off rate-limited accounts (they route through bare `agents run`, which rotates), but a **version-pinned** (`claude@2.1.112`) or **profile** teammate spawns `agents run <agent>@<version>` / `agents run <profile>`, and a pin/profile deliberately *bypasses* rotation — so it would launch straight onto a maxed account and 429 on the first request, with no mid-run failover either (that only arms when a non-pinned strategy actually rotated). `agents teams add` (at add time) and `agents teams start` (per staged teammate, deduped by `agent@version`) now pre-check a **version-pinned** teammate's account and print an advisory when it's rate-limited, out of credits, or not signed in — reusing the router's *exact* eligibility gate (`checkRunAccountReadiness` → `hasUsageAvailable`, the same session-inclusive signal the `agents view` badge uses), so the warning can never disagree with what the spawn would actually do. It **warns, never blocks** (mirroring the existing "may not be signed in" advisory); `--force` silences it. Scoped to version-pinned teammates on purpose: bare teammates are already handled by rotation, and a profile injects its own auth (a different account than the version home carries) that isn't locally checkable — so no unreliable profile warning is emitted. Source: `apps/cli/src/lib/rotate.ts` (`readinessFromCandidate`, `checkRunAccountReadiness`, `rotate.test.ts`), `apps/cli/src/commands/teams.ts`.
+
+## 1.20.44
+- **Every `logs` command is concise by default; the token-heavy raw dump is now opt-in behind `--full`.** Agents that spin up agents on other machines or add teammates were pulling whole transcripts just to glance at status — `agents logs <session>` printed the full markdown transcript, and `agents hosts logs` / `agents teams logs` / `agents routines logs` each `cat`'d their entire captured stdout, because each subsystem had hand-rolled its own "cat the log" verb over its own storage. All four now default to a bounded, concise view, with `-m/--full` for the raw log: `agents logs <session>` renders the same summary digest as `agents sessions <id>` (a real session shrank 92% — 29.9 KB → 2.6 KB); `agents routines logs <name>` shows a status header + the extracted report (a real run shrank 99.5% — 386 KB → 1.8 KB), falling back to a bounded stdout tail when no report was extracted; `agents teams logs <teammate>` renders the teammate's session summary (its agentId **is** the session id), with `-n <lines>` / `--full` for raw stdout; `agents hosts logs <id>` shows a bounded tail of the captured stdout (`tailLines`, with a "… N earlier lines hidden — pass --full" note) instead of the whole log. `renderSessionLog` now takes a mode and defaults to `'summary'`; `agents sessions <id>` was already summary-by-default and is unchanged. Regression-tested: `tailLines` truncation/elision math (`hosts/logs.test.ts`) and `formatRunDuration` human-time formatting (`routines-logs.test.ts`). Source: `apps/cli/src/commands/{logs,sessions,hosts,teams,routines}.ts`, `apps/cli/src/lib/hosts/logs.ts`. Scoped follow-up (not in this PR): host-task and sandboxed-routine runs write their real transcript on the remote / in an overlay HOME, so `logs` can't yet resolve them to the full `renderSummary` — making those runs discoverable is a separate change; until then the bounded tail / extracted report is the safe concise default.
+- **The daemon now self-heals the `pane-died` hook on already-running `agents run` sessions.** The v1.20.42 fix that stops exiting a split from kicking you out of tmux is installed once, at session creation — so sessions already alive under the long-lived shared tmux server keep the old, unconditional `detach-client` hook until they exit or the server is recycled. On a machine that's never "between sessions," that meant hand-repairing live sessions. The daemon now runs `reconcileSessionHooks()` ~20s after startup and every ~5 min: it walks the managed `ag-` sessions on the shared socket and retrofits the `#{hook_pane}`-guarded hook onto any whose hook predates the current schema. It is strictly **non-destructive — `set-hook` only, never a `kill-pane` or `detach-client`** — so it is safe to run against sessions you're attached to; a per-session `@ag_hook_schema` marker makes steady-state a no-op. The hook string is now built in one place (`agentPaneDiedHook`) shared by the spawn-wrap and the reconcile so they can't drift. Source: `apps/cli/src/lib/tmux/session.ts`, `apps/cli/src/lib/daemon.ts`, `apps/cli/src/lib/exec.ts`.
+- **NEW: `agents run` self-heals a gutted install instead of crashing with `ENOENT`.** The recurring failure: an npm agent whose native binary ships as an optional per-arch dependency (codex → `@openai/codex-<platform>`) can have that tarball extract **partially** — the platform package's `package.json` lands, its `vendor/<triple>/…/codex` binary does not (an interrupted or concurrently-raced `agents add` into the same version dir). The CLI's wrapper `require.resolve`s the platform package, finds the `package.json`, and sails straight past its own "missing optional dependency" guard into a `spawn(binaryPath)` that dies with a raw `ENOENT`. `agents run` now probes the version it's about to launch and, if the binary can't run, **repairs it in place** (a *clean* reinstall — the partial `node_modules` is wiped first, because npm treats the present-but-gutted platform package as already installed and would otherwise skip re-fetching it), then falls back to another installed version that launches (re-pinning it as the default so the shim path heals too), then to installing `latest` — only erroring if nothing can be made runnable. `installVersion` gained a `{ clean }` option for the wipe-then-reinstall. Source: `apps/cli/src/lib/versions.ts` (`ensureAgentRunnable`), `apps/cli/src/commands/exec.ts`.
+- **Fix: a broken agent install no longer launches into a silent `[detached]` — the real crash is surfaced.** When an interactive `ag run <agent>` wrapped the agent in tmux and the agent died the instant it spawned (e.g. a gutted install crashing with `spawn … ENOENT`, a bad flag, a startup crash), the `pane-died` hook detached the client before you could read anything — you got a bare `[detached (from session …)]` with zero indication of why. `runInTmux` now recaps the dead pane's last output (read from scrollback via `capture-pane -S -200`, since the pane's visible screen is just the "Pane is dead" banner) plus the exit code to stderr, and points you at `--no-tmux`. Fast failures (dead before attach) always recap; a post-attach nonzero exit recaps too (a clean exit or a manual detach stays quiet). Source: `apps/cli/src/lib/exec.ts`, `apps/cli/src/lib/tmux/session.test.ts`.
+- **NEW: `--no-tmux` / `--disable-tmux` on `agents run`.** The interactive tmux wrapper (which gives `%pane` addressing + re-attach) already had an opt-out, but it was hidden behind the opaquely-named `--raw`. `--no-tmux` (and its alias `--disable-tmux`) spawn the agent directly with full stdio inherited — the fastest way to see an agent's real startup output when a launch is failing. Same effect as `--raw` and `AGENTS_NO_TMUX=1`. Source: `apps/cli/src/commands/exec.ts`.
+- **Fix: `agents add <agent>@<version>` no longer records a gutted install as healthy (root cause of the ENOENT crash + a broken default pin).** npm packages that ship their native binary via an optional per-arch dependency (e.g. codex → `@openai/codex-<platform>`) can land the JS wrapper at `node_modules/.bin/<cli>` while the real platform binary is missing (interrupted install, omitted optional dep, `--ignore-scripts`). `getBinaryPath()` only checked the wrapper, so the broken version read as installed, got pinned as the default, and got picked to run — then died with ENOENT. `installVersion` now probes `<binary> --version` (under the version's isolated HOME) after install and **fails the install** if the binary can't launch, so a broken version is never silently pinned. The check is deliberately narrow — only the missing-binary signature (`ENOENT`/"no such file"/"command not found") fails it; a plain nonzero exit or a timeout is treated as healthy, so a well-behaved agent that dislikes `--version` is never false-failed. Source: `apps/cli/src/lib/versions.ts`, `apps/cli/src/lib/versions-integrity.test.ts`.
+- **Security fix: the routines daemon log no longer leaks GitHub / AWS / npm tokens.** `daemon.ts` carried its own private `redactSecrets` (used by every `log()` write to `logs.jsonl`) that predated and diverged from the canonical `redact.ts` — it caught `sk-`, `eyJ…`, `Bearer …`, and a narrow `NAME=value` list, but **not** `ghp_` (GitHub PAT), `AKIA…` (AWS access key), or `npm_` (npm token), so any of those appearing in a daemon message (a git push URL, a bundle-env dump, an error string) was written to the log in the clear. The private copy is deleted; `log()` now routes through the canonical `redactSecrets` in `redact.ts`, which covers all of those classes with a stronger quote-aware `NAME=value` pattern. The one pattern the daemon copy had and the canonical lacked — `Bearer <token>` — is added to `redact.ts`, so the shared redactor (also used by session-transcript export in `session/render.ts`) is now a strict superset. New `redact.test.ts` pins every token class as a regression guard. Source: `apps/cli/src/lib/daemon.ts`, `apps/cli/src/lib/redact.ts`, `apps/cli/src/lib/redact.test.ts`.
+- **Fix: `agents teams doctor` tells the truth, a version fallback never spawns an unspawnable literal, and shims survive a vanished dispatcher (completing this release's self-heal series).** Three gaps remained after the `agents run` self-heal above. (1) **`agents teams doctor` lied** — it reported `installed: true` whenever a *shim file* existed, never checking the real binary, so a stub or gutted-native install (the exact codex/kimi failure) showed "ready" and then `ENOENT`'d at spawn. `checkCliAvailable` now verifies the resolved default version is actually installed, and doctor additionally **launch-probes** each installed agent (`verifyInstalledBinaryLaunches`) and flips a gutted-native one to not-installed with a repair hint. (2) **A version fallback spawned an unspawnable literal** — when a specific version was requested (`agents run kimi@0.19.2`, the path every version-pinned teammate takes) and no versioned shim existed on disk, the launch left the bare `<agent>@<version>` name as `argv[0]`, which is not on PATH, so it died with `spawn kimi@0.19.2 ENOENT`; it now resolves the version's real binary (`getBinaryPath`) instead, falling back to the literal only when no binary exists at all. (3) **A shim couldn't survive its dispatcher vanishing** — when the baked `AGENTS_BIN` (often a dev build under `~/.local/agents-cli-dev`) was removed, moved, or went stale, the shim exited 127 and bricked *every* managed launch; it now **self-recovers** to whatever `agents` resolves to on PATH before erroring (`SHIM_SCHEMA_VERSION` → 25). Also drops a stale, npm-unrecoverable `codex 0.116.0` pin from the repo's own `agents.yaml` so codex resolves to the machine default instead of self-healing on every run. Source: `apps/cli/src/lib/{exec,shims}.ts`, `apps/cli/src/lib/teams/agents.ts`, `apps/cli/src/commands/teams.ts`, `agents.yaml`.
+
 ## 1.20.43
 
 - **NEW: `agents run --name <slug>` — a durable, human/agent-friendly handle for any run.** An agent that dispatches another agent had no cheap status handle: the host-task id was never even printed (the `--no-follow` tip showed a literal `<id>` placeholder), and only Claude's session id is known up front (pre-minted `--session-id`) — every other agent's id is discovered later by scanning transcripts, so callers fell back to `agents logs`, which dumps the raw, token-heavy transcript. `--name` is chosen at launch, agent-agnostic, and stored on the structures that already back these views: a first-class `name` column on `sessions.db` (schema v9, additive, no rescan) parallel to `label` — `agents sessions <ref>` resolves against **both** name and label; the HostTask sidecar (forwarded to the remote run, so `agents hosts ps` gains a NAME column and `agents hosts logs <name>` resolves by name); and a run-name sidecar (`~/.agents/.cache/run-names/`) that joins a local run's name onto the index by id every scan via `syncNames` — the same idempotent pattern as `/rename` label sync. The `name` column is deliberately left out of the upsert `ON CONFLICT … SET` clause, so a discovery rescan can never null an existing name (regression-tested in `db.names.test.ts`). Omitting `--name` is a strict no-op: `name` stays unset and every id-based path is unchanged. The `--no-follow` dispatch tip now prints the real handle and steers to the compact `agents sessions` digest over the raw log. Source: `apps/cli/src/commands/exec.ts`, `apps/cli/src/lib/session/{db,run-names,discover}.ts`, `apps/cli/src/lib/hosts/{dispatch,tasks}.ts`.

package/README.md

@@ -243,7 +243,8 @@ agents hosts check gpu-box              # reachable? which agents-cli version?
 
 # Run there instead of locally
 agents run claude --host gpu-box "profile this build"   # follows live by default
-agents logs --host gpu-box              # pick a dispatched run and view its log
+agents logs --host gpu-box              # pick a dispatched run — concise summary by default
+agents logs <id> --full                 # the full raw transcript / stdout (token-heavy)
 agents logs <id> -f                     # re-attach to a running one and follow
 agents view claude --host gpu-box       # inspect the remote install
 agents sync --host gpu-box              # make the remote machine current
@@ -274,7 +275,7 @@ agents teams start auth-feature     # Fires teammates whose deps are done
 agents teams status auth-feature    # Who's working, what they changed, what they said
 ```
 
-Teammates run detached -- close your terminal, they keep working. Check in with `teams status`, read full output with `teams logs <name>`, clean up with `teams disband`.
+Teammates run detached -- close your terminal, they keep working. Check in with `teams status`, glance at a teammate's summary with `teams logs <name>` (add `--full` for the raw output), clean up with `teams disband`.
 
 Team state is observable via `agents teams list --json` / `agents teams status --json` (compact by default; add `--verbose` for the full per-teammate shape). External tools join it with `sessions --json` (teammates get `isTeamOrigin: true`) and `cloud list --json` (for `--cloud` teammates) to build a unified fleet view. See [docs/06-observability.md](docs/06-observability.md).
 
@@ -534,7 +535,7 @@ agents routines add daily-digest \
 
 agents routines list                   # All jobs + next run times
 agents routines run daily-digest       # Test it now, ignore the schedule
-agents routines logs daily-digest      # Check last execution
+agents routines logs daily-digest      # Last execution — status + report (add --full for raw stdout)
 ```
 
 Jobs run sandboxed -- agents only see directories and tools you explicitly allow.

package/dist/commands/exec.js

@@ -218,9 +218,11 @@ export function registerRunCommand(program) {
         .option('-i, --interactive', 'Force interactive mode even when a prompt is provided. Mutually exclusive with --headless.')
         .option('--resume [id]', 'Resume a previous conversation. Accepts a full or partial session id (prefix-matched against the index); omit the id to pick from recent sessions interactively. Resumes under the version that started the session. claude/codex resume natively; other agents replay via a /continue first message. Pair with a prompt to continue headlessly.')
         .option('--session-id <id>', 'Force a NEW conversation to use this exact session UUID (Claude only). This CREATES a session — to resume an existing one, use --resume.')
-        .option('--name <slug>', 'Give the run a durable name — a stable handle you can check on later with `agents sessions <name>` (and `agents hosts logs <name>` for --host runs), instead of an opaque id. Optional; omitting it keeps today\'s id-only behavior.')
+        .option('--name <slug>', 'Name the run — seeds the session label so it shows up as `<name>` in `agents sessions` and resolves by it (and `agents hosts logs <name>` for --host runs) instead of an opaque id. An agent-generated title later refines the label; your name shows until then. Optional.')
         .option('--verbose', 'Show detailed execution logs')
         .option('--raw', 'Interactive runs on macOS/Linux launch inside a shared tmux session (for %pane addressing + re-attach). Pass --raw to spawn the agent directly instead. Also disabled by AGENTS_NO_TMUX=1.')
+        .option('--no-tmux', 'Spawn the agent directly instead of wrapping it in the shared tmux session. Same effect as --raw / AGENTS_NO_TMUX=1. Use this to see the agent\'s full startup output when a launch is failing.')
+        .option('--disable-tmux', 'Alias for --no-tmux.')
         .option('--timeout <duration>', 'Kill the agent after this duration (e.g., 30m, 1h, 2h30m)')
         .option('--fallback <agents>', 'Comma-separated agents to try on rate-limit failure. Each entry accepts an optional @version pin (e.g., codex@0.116.0,gemini). The primary runs first; if it exits with a rate-limit error, the next agent picks up via /continue handoff.')
         .option('-b, --balanced', 'Shortcut for --strategy balanced. Ignored when @version is pinned.')
@@ -357,13 +359,9 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
             const hostName = hostGiven[0];
-            if (prompt === undefined) {
-                console.error(chalk.red('A prompt is required for host runs: agents run <agent> "<task>" --host <name>'));
-                process.exit(1);
-            }
             const { resolveHost, resolveHostByCap } = await import('../lib/hosts/registry.js');
-            const { dispatchToHost } = await import('../lib/hosts/dispatch.js');
-            const { registerHostSession } = await import('../lib/hosts/session-index.js');
+            const { dispatchToHost, runInteractiveOnHost } = await import('../lib/hosts/dispatch.js');
+            const { registerHostSession, registerInteractiveHostSession } = await import('../lib/hosts/session-index.js');
             // A password-auth device throws DeviceOffloadUnsupportedError here; it's
             // printed cleanly by the top-level catch in index.ts (covers every
             // resolveHost caller), so it never falls through to capability routing.
@@ -394,10 +392,57 @@ export function registerRunCommand(program) {
                 // which can't run over a detached remote dispatch — only forward a
                 // concrete id.
                 const resumeId = typeof options.resume === 'string' ? options.resume : undefined;
-                // Mirror the local path (lib/exec.ts): only Claude accepts a forced
-                // `--session-id`. Generating it here lets us register the run in the
-                // local index and makes it resumable by that id. On resume the remote
-                // session keeps its existing id — don't mint a new one.
+                // Decide whether this host run is interactive. No prompt always means
+                // interactive (matching local resolveInteractive); --interactive forces
+                // interactive even when a prompt is provided; --headless forces headless
+                // and therefore requires a prompt.
+                if (options.interactive && options.headless) {
+                    console.error(chalk.red('--interactive and --headless are mutually exclusive. Pass one, or neither (mode is inferred from prompt presence).'));
+                    process.exit(1);
+                }
+                const interactiveHost = options.interactive === true || (prompt === undefined && options.headless !== true);
+                if (interactiveHost) {
+                    // Interactive host run: forward the local TTY over SSH and let the
+                    // remote agent start its normal interactive UI (tmux on the host).
+                    if (options.follow === false) {
+                        console.error(chalk.red('--no-follow is not compatible with interactive host runs. Interactive runs are attached by definition.'));
+                        process.exit(1);
+                    }
+                    // Mirror the local path (lib/exec.ts): only Claude accepts a forced
+                    // `--session-id`. Generating it here lets us register the run in the
+                    // local index and makes it resumable by id. On resume the remote
+                    // session keeps its existing id — don't mint a new one.
+                    const hostSessionId = runAgent === 'claude' && !resumeId ? randomUUID() : undefined;
+                    if (hostSessionId) {
+                        registerInteractiveHostSession({
+                            cwd: process.cwd(),
+                            host: host.name,
+                            agent: runAgent,
+                            sessionId: hostSessionId,
+                            name: options.name,
+                        });
+                    }
+                    const exitCode = await runInteractiveOnHost(host, {
+                        agent: runAgent,
+                        prompt,
+                        mode: options.mode,
+                        model: options.model,
+                        remoteCwd: options.remoteCwd,
+                        sessionId: hostSessionId,
+                        name: options.name,
+                        resume: resumeId,
+                        passthroughArgs,
+                        raw: options.raw || options.tmux === false || options.disableTmux === true,
+                        forceInteractive: options.interactive,
+                    });
+                    process.exit(exitCode);
+                }
+                // Headless host run: launch detached, tail the remote log, and follow
+                // until the remote process exits.
+                if (prompt === undefined) {
+                    console.error(chalk.red('A prompt is required for headless host runs: agents run <agent> "<task>" --host <name>'));
+                    process.exit(1);
+                }
                 const hostSessionId = runAgent === 'claude' && !resumeId ? randomUUID() : undefined;
                 const { task, exitCode } = await dispatchToHost(host, {
                     agent: runAgent,
@@ -525,7 +570,7 @@ export function registerRunCommand(program) {
             });
             process.exit(resumeExit);
         }
-        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, defaultModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports },] = await Promise.all([
+        const [{ buildExecCommand, parseExecEnv, execAgent, runWithFallback, normalizeMode, resolveMode, defaultModeFor, headlessPlanStallCommand, nativeResume, resolveInteractive }, { ALL_AGENT_IDS }, { profileExists, resolveProfileForRun }, { readAndResolveBundleEnv, describeBundle, assertRemoteBundleFlagsUnsupported }, { splitBundleRef, resolveSshTarget, remoteResolveEnv }, { getConfiguredRunStrategy, normalizeRunStrategy, resolveRunVersion, rotationFailoverChain, shouldArmRotationFailover, RUN_STRATEGIES }, { getGlobalDefault, getVersionHomePath, resolveVersion, resolveVersionAlias, ensureAgentRunnable }, { buildDiscoveredPlugin, loadPluginManifest, syncPluginToVersion }, { parseWorkflowFrontmatter, resolveWorkflowRef, resolveAllowedSubagents, pruneStaleWorkflowSubagents }, { resolveRunDefaults }, { getMcpServersByName, buildWorkflowMcpConfig }, { supports },] = await Promise.all([
             import('../lib/exec.js'),
             import('../lib/agents.js'),
             import('../lib/profiles.js'),
@@ -933,6 +978,29 @@ export function registerRunCommand(program) {
                 }
             }
         }
+        // Self-heal the launch target. A gutted install (JS wrapper present,
+        // native binary missing — a partial/raced npm extraction of the optional
+        // per-arch dependency) would otherwise spawn and die with a raw ENOENT
+        // inside the agent's own wrapper. Repair it in place (or fall back to a
+        // runnable version, re-pinning it) BEFORE we build the launch command.
+        // Skipped for headless resume-native/acp/loop paths only if it errored;
+        // here it runs for every normal dispatch. Best-effort log to stderr.
+        {
+            const launchTarget = version ?? resolveVersion(agent, cwd) ?? undefined;
+            if (launchTarget) {
+                const healed = await ensureAgentRunnable(agent, launchTarget, options.quiet ? undefined : (m) => process.stderr.write(chalk.yellow(`[agents] ${m}\n`)));
+                if (healed === null) {
+                    console.error(chalk.red(`agents: ${agent}@${launchTarget} is not runnable and could not be repaired. Try: agents add ${agent}@latest`));
+                    process.exit(1);
+                }
+                // Always adopt the healed version explicitly. In the version-undefined
+                // path a fallback re-pins the GLOBAL default, but `resolveVersion`
+                // prefers a PROJECT pin — so leaving `version` undefined would let the
+                // shim re-resolve the still-broken project pin and crash anyway. Pinning
+                // the runnable version here is a no-op when nothing changed.
+                version = healed;
+            }
+        }
         const defaultVersion = version ?? resolveVersion(agent, cwd);
         const runDefaults = fromProfile
             ? { sources: {} }
@@ -1074,7 +1142,10 @@ export function registerRunCommand(program) {
             name: options.name,
             resume: resumeNative,
             verbose: options.verbose,
-            raw: options.raw,
+            // --raw, --no-tmux (commander negation → options.tmux === false), and
+            // --disable-tmux all bypass the interactive tmux wrapper. AGENTS_NO_TMUX=1
+            // does the same via the env check in exec.ts.
+            raw: options.raw || options.tmux === false || options.disableTmux === true,
             timeout: options.timeout,
             env,
             toolsRestrict: workflowToolsRestrict,

package/dist/commands/hosts.js

@@ -188,11 +188,11 @@ async function doPs(json) {
         console.log(t.id.padEnd(11) + nameCol + t.host.padEnd(16) + t.agent.padEnd(10) + status.padEnd(11) + promptCol);
     }
 }
-async function doLogs(ref, follow) {
+async function doLogs(ref, follow, full) {
     // Resolve the ref as a task id first, then fall back to a `--name` handle so
     // `agents hosts logs <name>` works, not just the opaque id.
     const id = loadTask(ref) ? ref : (findTaskByName(ref)?.id ?? findTaskBySessionId(ref)?.id ?? ref);
-    const res = await showHostTaskLog(id, follow);
+    const res = await showHostTaskLog(id, follow, full);
     if (!res.found) {
         console.log(chalk.red(`Unknown task "${ref}".`));
         process.exitCode = 1;
@@ -235,7 +235,8 @@ export function registerHostsCommand(program) {
         .action((opts) => doPs(!!opts.json));
     hosts
         .command('logs <id>')
-        .description('Show a host task log; -f to follow a running one.')
+        .description('Show a host task’s concise summary; --full for the raw log, -f to follow a running one.')
         .option('-f, --follow', 'Follow live output')
-        .action((id, opts) => doLogs(id, !!opts.follow));
+        .option('-m, --full', 'Show the full raw combined-stdout log instead of the concise summary')
+        .action((id, opts) => doLogs(id, !!opts.follow, !!opts.full));
 }

package/dist/commands/logs.d.ts

@@ -5,6 +5,10 @@
  *  - host-dispatch tasks (`agents run --host`) → combined-stdout log, offset-tailed
  *  - sessions (the local index) → transcript, tailed via the sessions tailer
  *
+ * Concise by default: a bare `agents logs <id>` prints the same summary digest as
+ * `agents sessions <id>` — cheap for an agent to glance at. The token-heavy full
+ * transcript / raw stdout is opt-in behind `--full` (alias `-m/--markdown`).
+ *
  * `[id]`/`--session` load directly (host task tried first, then session). With no
  * id, `--host`/`--agent`/`--version` filter a merged candidate list; one match is
  * shown, several open the fuzzy picker (or, non-TTY, print the list).

package/dist/commands/logs.js

@@ -5,6 +5,10 @@
  *  - host-dispatch tasks (`agents run --host`) → combined-stdout log, offset-tailed
  *  - sessions (the local index) → transcript, tailed via the sessions tailer
  *
+ * Concise by default: a bare `agents logs <id>` prints the same summary digest as
+ * `agents sessions <id>` — cheap for an agent to glance at. The token-heavy full
+ * transcript / raw stdout is opt-in behind `--full` (alias `-m/--markdown`).
+ *
  * `[id]`/`--session` load directly (host task tried first, then session). With no
  * id, `--host`/`--agent`/`--version` filter a merged candidate list; one match is
  * shown, several open the fuzzy picker (or, non-TTY, print the list).
@@ -33,8 +37,8 @@ function candidateLabel(c) {
     const title = s.label || s.topic || '';
     return `${chalk.gray('sess')} ${s.shortId.padEnd(9)} ${(s.agent + ver).padEnd(14)} ${chalk.gray(s.timestamp.slice(0, 16))}  ${title.slice(0, 40)}`;
 }
-/** Show a resolved session — follow (tail) or render its transcript. */
-async function showSession(session, follow) {
+/** Show a resolved session — follow (tail), concise summary, or (`full`) transcript. */
+async function showSession(session, follow, full) {
     if (follow) {
         if (!isTailable(session.agent)) {
             console.error(chalk.red(`Tailing is supported for claude and codex sessions only (got ${session.agent}).`));
@@ -43,20 +47,20 @@ async function showSession(session, follow) {
         await streamSessionTail(session, {});
         return;
     }
-    await renderSessionLog(session);
+    await renderSessionLog(session, full ? 'markdown' : 'summary');
 }
-async function showCandidate(c, follow) {
+async function showCandidate(c, follow, full) {
     if (c.kind === 'task') {
-        const res = await showHostTaskLog(c.task.id, follow);
+        const res = await showHostTaskLog(c.task.id, follow, full);
         if (res.exitCode !== undefined)
             process.exitCode = res.exitCode;
         return;
     }
-    await showSession(c.session, follow);
+    await showSession(c.session, follow, full);
 }
 /** Resolve an explicit id/--session: host task first, then a session. */
-async function showById(id, follow) {
-    const hostRes = await showHostTaskLog(id, follow);
+async function showById(id, follow, full) {
+    const hostRes = await showHostTaskLog(id, follow, full);
     if (hostRes.found) {
         if (hostRes.exitCode !== undefined)
             process.exitCode = hostRes.exitCode;
@@ -68,13 +72,14 @@ async function showById(id, follow) {
         console.error(chalk.red(`No run or session found matching "${id}".`));
         process.exit(1);
     }
-    await showSession(matches[0], follow);
+    await showSession(matches[0], follow, full);
 }
 async function runLogs(id, opts) {
     const follow = !!opts.follow;
+    const full = !!opts.full;
     const directId = opts.session ?? id;
     if (directId) {
-        await showById(directId, follow);
+        await showById(directId, follow, full);
         return;
     }
     const { agent, version } = parseAgentFilter(opts.agent);
@@ -99,7 +104,7 @@ async function runLogs(id, opts) {
         process.exit(1);
     }
     if (candidates.length === 1) {
-        await showCandidate(candidates[0], follow);
+        await showCandidate(candidates[0], follow, full);
         return;
     }
     // Multiple sessions matched → picker if interactive, else a list to pick from.
@@ -123,17 +128,18 @@ async function runLogs(id, opts) {
     });
     if (!picked)
         return;
-    await showCandidate(picked.item, follow);
+    await showCandidate(picked.item, follow, full);
 }
 /** Register the top-level `agents logs` command. */
 export function registerLogsCommand(program) {
     program
         .command('logs [id]')
-        .description('Show a run’s log — a host-dispatch task or a session. -f to follow a live one.')
+        .description('Show a run’s concise summary — a host-dispatch task or a session. --full for the raw transcript, -f to follow a live one.')
         .option('--host <name>', 'Scope to runs dispatched to a host')
         .option('-a, --agent <agent>', 'Filter by agent (e.g. claude, codex@0.116.0)')
         .option('--version <version>', 'Filter by agent version')
         .option('--session <id>', 'Select a session/run by id (same as the positional id)')
         .option('-f, --follow', 'Follow live output')
+        .option('-m, --full', 'Show the full raw transcript / stdout instead of the concise summary')
         .action((id, opts) => runLogs(id, opts));
 }

package/dist/commands/routines.d.ts

@@ -6,5 +6,11 @@
  * Also exposes scheduler lifecycle controls (start/stop/status/logs).
  */
 import type { Command } from 'commander';
+/**
+ * Human-friendly wall-clock a run took (e.g. "  · 3 min", "  · 45 sec"), or ""
+ * when it hasn't completed or timestamps are unparseable. Leading separator lets
+ * callers drop it straight into a status line.
+ */
+export declare function formatRunDuration(startedAt: string, completedAt: string | null): string;
 /** Register the `agents routines` command tree. */
 export declare function registerRoutinesCommands(program: Command): void;

package/dist/commands/routines.js

@@ -22,6 +22,27 @@ import { JobScheduler } from '../lib/scheduler.js';
 import { detectOverdueJobs } from '../lib/overdue.js';
 import { isInteractiveTerminal, requireInteractiveSelection } from './utils.js';
 import { setHelpSections } from '../lib/help.js';
+/**
+ * Human-friendly wall-clock a run took (e.g. "  · 3 min", "  · 45 sec"), or ""
+ * when it hasn't completed or timestamps are unparseable. Leading separator lets
+ * callers drop it straight into a status line.
+ */
+export function formatRunDuration(startedAt, completedAt) {
+    if (!completedAt)
+        return '';
+    const ms = Date.parse(completedAt) - Date.parse(startedAt);
+    if (!Number.isFinite(ms) || ms < 0)
+        return '';
+    const sec = Math.round(ms / 1000);
+    if (sec < 60)
+        return `  · ${sec} sec`;
+    const min = Math.round(sec / 60);
+    if (min < 60)
+        return `  · ${min} min`;
+    const hr = Math.floor(min / 60);
+    const rem = min % 60;
+    return rem ? `  · ${hr} hr ${rem} min` : `  · ${hr} hr`;
+}
 /**
  * Human label for what fires a job: its cron schedule, or its event trigger
  * for schedule-less (trigger-only) routines.
@@ -660,30 +681,67 @@ export function registerRoutinesCommands(program) {
     });
     routinesCmd
         .command('logs [name]')
-        .description('Read stdout from the most recent execution. Use --run to see a specific past run.')
+        .description('Show a run’s concise summary — status + extracted report. --full for the raw stdout stream; --run for a specific past run.')
         .option('-r, --run <runId>', 'Show logs from this run ID instead of the latest')
+        .option('-m, --full', 'Show the full raw stdout stream instead of the concise summary')
         .action(async (name, options) => {
         if (!name) {
             name = await pickJob('Select job to view logs', undefined, ['agents routines logs <name>', 'agents routines logs <name> --run <run-id>']) ?? undefined;
             if (!name)
                 return;
         }
-        let runId = options.run;
-        if (!runId) {
-            const latest = getLatestRun(name);
-            if (!latest) {
-                console.log(chalk.yellow(`No runs found for job '${name}'`));
+        // Resolve the run: an explicit --run row, else the latest.
+        const run = options.run
+            ? listRuns(name).find((r) => r.runId === options.run)
+            : getLatestRun(name);
+        if (!run) {
+            console.log(chalk.yellow(options.run ? `No run '${options.run}' for job '${name}'` : `No runs found for job '${name}'`));
+            return;
+        }
+        const runId = run.runId;
+        const logPath = path.join(getRunDir(name, runId), 'stdout.log');
+        // --full: the raw combined stdout stream (the old default).
+        if (options.full) {
+            if (!fs.existsSync(logPath)) {
+                console.log(chalk.yellow(`Log not found: ${logPath}`));
                 return;
             }
-            runId = latest.runId;
+            console.log(chalk.gray(`Run: ${runId}\n`));
+            console.log(fs.readFileSync(logPath, 'utf-8'));
+            return;
         }
-        const logPath = path.join(getRunDir(name, runId), 'stdout.log');
-        if (!fs.existsSync(logPath)) {
-            console.log(chalk.yellow(`Log not found: ${logPath}`));
+        // Concise by default: a status header + the extracted report (final
+        // assistant message). Routine runs are sandboxed (transcript in an overlay
+        // HOME, not the session index), so the captured report — not renderSummary —
+        // is the concise view. Falls back to a bounded stdout tail when no report
+        // was extracted (e.g. the run failed before finishing).
+        const statusColor = run.status === 'completed' ? chalk.green
+            : run.status === 'failed' || run.status === 'timeout' ? chalk.red
+                : chalk.yellow;
+        console.log(chalk.bold(name) + chalk.gray(`  run ${runId}`));
+        console.log(statusColor(run.status) +
+            chalk.gray(`  ${run.startedAt}`) +
+            chalk.gray(formatRunDuration(run.startedAt, run.completedAt)) +
+            (run.exitCode !== null && run.exitCode !== undefined ? chalk.gray(`  exit ${run.exitCode}`) : ''));
+        console.log(chalk.gray('─'.repeat(60)));
+        const reportPath = path.join(getRunDir(name, runId), 'report.md');
+        if (fs.existsSync(reportPath)) {
+            console.log(fs.readFileSync(reportPath, 'utf-8').trimEnd());
+            console.log(chalk.gray('\n(pass --full for the raw stdout stream)'));
             return;
         }
-        console.log(chalk.gray(`Run: ${runId}\n`));
-        console.log(fs.readFileSync(logPath, 'utf-8'));
+        // No report — show a bounded tail rather than dumping the whole stream.
+        if (fs.existsSync(logPath)) {
+            const lines = fs.readFileSync(logPath, 'utf-8').split('\n');
+            const tail = lines.slice(-40).join('\n').trimEnd();
+            console.log(chalk.gray('(no report extracted — showing the last lines of stdout)'));
+            if (tail)
+                console.log(tail);
+            console.log(chalk.gray('\n(pass --full for the raw stdout stream)'));
+        }
+        else {
+            console.log(chalk.gray('(no output captured for this run)'));
+        }
     });
     routinesCmd
         .command('report [name]')

package/dist/commands/secrets.d.ts

@@ -9,6 +9,24 @@ import { type Command } from 'commander';
 import { SSH_TARGET_RE, assertValidSshTarget } from '../lib/ssh-exec.js';
 import { quoteWin32ExecArg } from '../lib/platform/index.js';
 import { type SecretsBundle, type SecretsPolicy } from '../lib/secrets/bundles.js';
+/**
+ * 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 declare function readImportDotenv(from: string): string;
+/**
+ * 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 declare function buildRemoteUnlockArgs(names: string[], opts: {
+    all?: boolean;
+    ttl?: string;
+}): string[];
 export { SSH_TARGET_RE, assertValidSshTarget };
 /**
  * Build the child environment for `agents secrets exec`. Strips