@phnx-labs/agents-cli 1.20.33 → 1.20.35

package/dist/commands/doctor.js

@@ -12,6 +12,8 @@ import { unifiedDiff, colorizeUnifiedDiff } from '../lib/diff-text.js';
 import { listCliStatus } from '../lib/cli-resources.js';
 import { setHelpSections } from '../lib/help.js';
 import { heal, healChangedAnything } from '../lib/heal.js';
+import { blocksLocalScripts, getEffectiveExecutionPolicy } from '../lib/platform/winpath.js';
+import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
 import * as fs from 'fs';
 const AGENT_NAMES = Object.fromEntries(ALL_AGENT_IDS.map((id) => [id, AGENTS[id].name]));
 // ─── overview mode (no target) ────────────────────────────────────────────────
@@ -28,7 +30,6 @@ function divergenceLines(report) {
         else if (p.status === 'diff')
             lines.push(`plugin ${p.name} — ${p.detail ?? 'mirror drifted'}`);
     }
-    const counts = [];
     for (const kind of ['commands', 'skills', 'hooks', 'rules', 'mcp', 'permissions', 'subagents']) {
         const rows = report.kinds[kind];
         const miss = rows.filter((r) => r.status === 'missing').length;
@@ -39,12 +40,44 @@ function divergenceLines(report) {
         if (dif)
             bits.push(`${dif} drifted`);
         if (bits.length)
-            counts.push(`${kind} ${bits.join('/')}`);
+            lines.push(`${kind.padEnd(11)} ${bits.join(' · ')}`);
     }
-    if (counts.length)
-        lines.push(counts.join(' · '));
     return lines;
 }
+function collapseWhitespace(s) {
+    return s.replace(/\s+/g, ' ').trim();
+}
+export function wrapLine(prefix, text, width = terminalWidth()) {
+    const words = collapseWhitespace(text).split(' ').filter(Boolean);
+    if (words.length === 0)
+        return [prefix.trimEnd()];
+    const continuation = ' '.repeat(stringWidth(prefix));
+    const lines = [];
+    let linePrefix = prefix;
+    let line = prefix;
+    let hasWord = false;
+    for (const word of words) {
+        const room = Math.max(1, width - stringWidth(linePrefix));
+        const piece = stringWidth(word) > room ? truncateToWidth(word, room) : word;
+        const candidate = hasWord ? `${line} ${piece}` : `${line}${piece}`;
+        if (hasWord && stringWidth(candidate) > width) {
+            lines.push(line);
+            linePrefix = continuation;
+            line = continuation + piece;
+            hasWord = true;
+        }
+        else {
+            line = candidate;
+            hasWord = true;
+        }
+    }
+    lines.push(line);
+    return lines;
+}
+function printWrappedLine(prefix, text) {
+    for (const line of wrapLine(prefix, text))
+        console.log(chalk.gray(line));
+}
 function checkSyncStatus(cwd) {
     const rows = [];
     // Every installed version, not just the default — a stale NON-default version
@@ -129,7 +162,7 @@ function renderOverviewText(clis, syncRows, orphanRows, hostClis) {
         }
     }
     if (hidden.length > 0) {
-        console.log(chalk.gray(`  +${hidden.length} more supported (${hidden.join(', ')}) — \`agents add <name>\` to manage`));
+        printWrappedLine('  ', `+${hidden.length} more supported (${hidden.join(', ')}) — \`agents add <name>\` to manage`);
     }
     console.log();
     console.log(chalk.bold('Sync status (installed versions)'));
@@ -161,7 +194,7 @@ function renderOverviewText(clis, syncRows, orphanRows, hostClis) {
         // Version homes are reconciled only by management commands, so point at one
         // rather than promising an auto-sync that never happens.
         if (anyOutOfSync) {
-            console.log(chalk.gray('  Reconcile with `agents doctor <agent>@<version> --fix` or `agents sync <agent>@<version>` (not applied on launch).'));
+            printWrappedLine('  ', 'Reconcile with `agents doctor <agent>@<version> --fix` or `agents sync <agent>@<version>` (not applied on launch).');
         }
     }
     console.log();
@@ -198,16 +231,65 @@ function renderOverviewText(clis, syncRows, orphanRows, hostClis) {
             const label = manifest.name.padEnd(nameWidth);
             const src = chalk.gray(`[${manifest.source}]`);
             if (installed) {
-                console.log(`  ${chalk.green('ready')}  ${label}  ${src}  ${chalk.gray(manifest.description || '')}`);
+                const prefix = `  ${chalk.green('ready')}  ${label}  ${src}`;
+                const desc = manifest.description
+                    ? `  ${truncateToWidth(collapseWhitespace(manifest.description), Math.max(1, terminalWidth() - stringWidth(prefix) - 2))}`
+                    : '';
+                console.log(prefix + chalk.gray(desc));
             }
             else {
-                console.log(`  ${chalk.red('miss ')}  ${label}  ${src}  ${chalk.gray(`not installed — run \`agents cli install ${manifest.name}\``)}`);
+                const prefix = `  ${chalk.red('miss ')}  ${label}  ${src}`;
+                const msg = `not installed — run \`agents cli install ${manifest.name}\``;
+                const budget = Math.max(1, terminalWidth() - stringWidth(prefix) - 2);
+                console.log(prefix + chalk.gray(`  ${truncateToWidth(msg, budget)}`));
             }
         }
     }
     for (const err of hostClis.errors) {
         console.log(`  ${chalk.red('err  ')}  ${chalk.gray(err.file)}: ${chalk.gray(err.reason)}`);
     }
+    // On Windows a Restricted/AllSigned execution policy silently breaks the
+    // generated `agents.ps1` launcher — postinstall diagnoses it interactively,
+    // but a non-interactive install never sees that. Surface it here too.
+    renderExecPolicyAdvisory();
+}
+// ─── windows execution-policy advisory ─────────────────────────────────────────
+/**
+ * Windows-only advisory lines. When the effective PowerShell execution policy
+ * blocks unsigned local `.ps1` scripts (`Restricted`/`AllSigned`), the generated
+ * `agents.ps1` launcher fails in PowerShell even when it is on PATH. Surface the
+ * remediation; the `.cmd` companion still works, so this is a warning, not an
+ * error, and doctor never auto-changes the policy. Pure — returns `[]` on
+ * non-Windows or a permissive policy, so it is testable without invoking
+ * PowerShell.
+ */
+export function execPolicyWarningLines(platform, policy) {
+    if (platform !== 'win32')
+        return [];
+    if (!blocksLocalScripts(policy))
+        return [];
+    return [
+        `PowerShell execution policy is ${policy} — it blocks the generated agents.ps1 launcher.`,
+        'Fix: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned',
+        'The agents.cmd shim still works regardless of the policy.',
+    ];
+}
+function renderExecPolicyAdvisory() {
+    // Only probe the policy on Windows — getEffectiveExecutionPolicy() spawns
+    // powershell, which is a wasted (doomed) process on POSIX where the advisory
+    // never applies.
+    if (process.platform !== 'win32')
+        return;
+    const lines = execPolicyWarningLines(process.platform, getEffectiveExecutionPolicy());
+    if (lines.length === 0)
+        return;
+    console.log();
+    console.log(chalk.bold('Execution policy (Windows)'));
+    const [headline, ...rest] = lines;
+    console.log(`  ${chalk.yellow('warn ')}  ${headline}`);
+    for (const line of rest) {
+        console.log(chalk.gray(`           ${line}`));
+    }
 }
 function parseTargetArg(arg) {
     const at = arg.indexOf('@');
@@ -314,8 +396,12 @@ function renderKindSection(kind, rows, layers, options) {
     }
     for (const r of visible) {
         const src = sourceLabel(r, layers);
-        const detail = r.detail ? chalk.gray(`  ${r.detail}`) : '';
-        console.log(`    ${statusLabel(r.status)}  ${r.name.padEnd(28)} ${src}${detail}`);
+        const name = padToWidth(truncateToWidth(r.name, 28), 28);
+        const prefix = `    ${statusLabel(r.status)}  ${name} ${src}`;
+        const detail = r.detail
+            ? chalk.gray(`  ${truncateToWidth(collapseWhitespace(r.detail), Math.max(1, terminalWidth() - stringWidth(prefix) - 2))}`)
+            : '';
+        console.log(prefix + detail);
         if (options.showDiff && r.status === 'diff' && r.sourcePath && r.homePath) {
             const expected = readExpectedForDiff(kind, r);
             const actual = safeRead(r.homePath);
@@ -352,8 +438,10 @@ function readExpectedForDiff(kind, row) {
 function renderTargetText(report, options) {
     const label = `${AGENT_NAMES[report.agent] || report.agent}@${report.version}`;
     console.log(chalk.bold(label));
-    console.log(chalk.gray(`  home: ${report.home}`));
-    console.log(chalk.gray(`  cwd:  ${report.cwd}`));
+    const homePrefix = '  home: ';
+    const cwdPrefix = '  cwd:  ';
+    console.log(chalk.gray(homePrefix + truncateToWidth(report.home, Math.max(1, terminalWidth() - stringWidth(homePrefix)))));
+    console.log(chalk.gray(cwdPrefix + truncateToWidth(report.cwd, Math.max(1, terminalWidth() - stringWidth(cwdPrefix)))));
     const layerStr = [
         report.layers.project ? `project=${report.layers.project}` : null,
         `user=${report.layers.user}`,
@@ -362,7 +450,7 @@ function renderTargetText(report, options) {
             ? `extras=[${report.layers.extras.map((e) => e.alias).join(',')}]`
             : null,
     ].filter(Boolean).join(' ');
-    console.log(chalk.gray(`  layers: ${layerStr}`));
+    printWrappedLine('  layers: ', layerStr);
     // Staleness manifest verdict — single-line summary from the staleness
     // library, sitting alongside the detailed per-resource diff below.
     const manifest = loadManifest(report.agent, report.version);
@@ -403,7 +491,7 @@ function renderTargetText(report, options) {
     }
     else {
         console.log(`  Verdict: ${verdictParts.join(', ')}.`);
-        console.log(chalk.gray(`  Run \`agents doctor ${report.agent}@${report.version} --fix\` to heal, or \`agents prune cleanup\` to drop extras.`));
+        printWrappedLine('  ', `Run \`agents doctor ${report.agent}@${report.version} --fix\` to heal, or \`agents prune cleanup\` to drop extras.`);
     }
 }
 // ─── fix / heal mode ───────────────────────────────────────────────────────────
@@ -547,6 +635,12 @@ export function registerDoctorCommand(program) {
                 return;
             }
             renderOverviewText(clis, syncRows, orphanRows, hostClis);
+            // Point at the interactive reconcile when anything is out of sync — the
+            // report shouldn't be a dead end. `agents status` runs the unified
+            // home-reading engine and offers to sync (opt-in, never auto-fires here).
+            if (syncRows.some((r) => r.status !== 'fresh')) {
+                console.log(chalk.gray('\nRun `agents status` to review and sync what has drifted.'));
+            }
             return;
         }
         const parsed = parseTargetArg(target);

package/dist/commands/events.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `agents events` — read the structured audit/event log.
+ *
+ * The event log (`~/.agents/.cache/logs/events-YYYY-MM-DD.jsonl`) records every
+ * `agents <module> <cmd>` invocation plus richer typed events (secrets access,
+ * version installs, ...), each stamped with who ran it and from where (OS user,
+ * local vs SSH, remote client IP). This command reads it back — the audit trail
+ * for "who accessed a secret / created a team / started an agent, and from which
+ * host?".
+ *
+ * Filter by `--module` (top-level group, e.g. teams), `--command` (path prefix,
+ * e.g. "teams create"), `--event` (typed event), `--agent`, and `--since`.
+ * `--follow` tails today's log live.
+ */
+import type { Command } from 'commander';
+export declare function registerEventsCommand(program: Command): void;

package/dist/commands/events.js

@@ -0,0 +1,173 @@
+/**
+ * `agents events` — read the structured audit/event log.
+ *
+ * The event log (`~/.agents/.cache/logs/events-YYYY-MM-DD.jsonl`) records every
+ * `agents <module> <cmd>` invocation plus richer typed events (secrets access,
+ * version installs, ...), each stamped with who ran it and from where (OS user,
+ * local vs SSH, remote client IP). This command reads it back — the audit trail
+ * for "who accessed a secret / created a team / started an agent, and from which
+ * host?".
+ *
+ * Filter by `--module` (top-level group, e.g. teams), `--command` (path prefix,
+ * e.g. "teams create"), `--event` (typed event), `--agent`, and `--since`.
+ * `--follow` tails today's log live.
+ */
+import chalk from 'chalk';
+import * as fs from 'fs';
+import { query, LOGS_PATH } from '../lib/events.js';
+/** Parse `--since`: relative offsets (30s/5m/2h/7d/4w) or an ISO/absolute date. */
+function parseSince(s) {
+    const m = s.match(/^(\d+)([smhdw])$/);
+    if (m) {
+        const n = parseInt(m[1], 10);
+        const unitMs = {
+            s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000,
+        };
+        return new Date(Date.now() - n * unitMs[m[2]]);
+    }
+    const ms = Date.parse(s);
+    if (isNaN(ms))
+        throw new Error(`Invalid --since value: ${s} (use e.g. 2h, 7d, or an ISO date)`);
+    return new Date(ms);
+}
+/** How the run reached this host — 'local' or 'ssh 203.0.113.7'. */
+function originLabel(r) {
+    if (r.transport === 'ssh') {
+        return chalk.yellow(`ssh${r.sshClientIp ? ' ' + r.sshClientIp : ''}`);
+    }
+    return chalk.gray('local');
+}
+/** The most useful one-line detail for a record, by event family. */
+function detailFor(r) {
+    if (r.command)
+        return r.command;
+    const bits = [];
+    if (typeof r.team === 'string')
+        bits.push(`team=${r.team}`);
+    if (typeof r.bundle === 'string')
+        bits.push(`bundle=${r.bundle}`);
+    if (typeof r.skill === 'string')
+        bits.push(`skill=${r.skill}`);
+    if (typeof r.version === 'string')
+        bits.push(`v=${r.version}`);
+    if (typeof r.profile === 'string')
+        bits.push(`profile=${r.profile}`);
+    if (typeof r.error === 'string')
+        bits.push(chalk.red(r.error));
+    return bits.join(' ');
+}
+function renderRow(r) {
+    const time = chalk.gray(r.ts.slice(0, 19).replace('T', ' '));
+    const user = `${r.osUser ?? '?'}@${r.hostname}`;
+    const ev = r.event.startsWith('error') ? chalk.red(r.event) : chalk.cyan(r.event);
+    const agent = r.agent ? chalk.gray(` ${r.agent}`) : '';
+    return `${time}  ${originLabel(r).padEnd(24)} ${user.padEnd(22)} ${ev.padEnd(26)}${agent}  ${detailFor(r)}`;
+}
+export function registerEventsCommand(program) {
+    program
+        .command('events')
+        .description('Read the structured audit/event log (who ran what, from where)')
+        .option('--module <name>', 'Only events from this command group (e.g. teams, secrets)')
+        .option('--command <path>', 'Only this command path — prefix match (e.g. "teams create")')
+        .option('--event <type>', 'Only this typed event (repeatable, e.g. secrets.get)', collect, [])
+        .option('--agent <name>', 'Only events tagged with this agent')
+        .option('--since <time>', 'Only events newer than this (e.g. 2h, 7d, or ISO date)')
+        .option('--limit <n>', 'Max records to show (default 50)', '50')
+        .option('--json', 'Output raw records as JSON')
+        .option('-f, --follow', "Tail today's log live")
+        .addHelpText('after', `
+Examples:
+  agents events                          Recent activity across everything
+  agents events --module teams           Team lifecycle (create / add / disband)
+  agents events --module secrets         Every secret accessed or revealed
+  agents events --command "teams create" Just team creations
+  agents events --event secrets.get --since 7d --json
+  agents events -f                       Live tail`)
+        .action(async (options) => {
+        if (options.follow) {
+            await followLog();
+            return;
+        }
+        const limit = Math.max(1, parseInt(options.limit ?? '50', 10) || 50);
+        let startDate;
+        try {
+            startDate = options.since ? parseSince(options.since) : undefined;
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(2);
+        }
+        const records = query({
+            startDate,
+            eventTypes: options.event && options.event.length ? options.event : undefined,
+            agent: options.agent,
+            command: options.command,
+            module: options.module,
+            limit,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(records, null, 2));
+            return;
+        }
+        if (records.length === 0) {
+            console.log(chalk.gray('No matching events.'));
+            return;
+        }
+        // query() returns newest-first; print oldest-first so a tail reads naturally.
+        for (const r of records.slice().reverse())
+            console.log(renderRow(r));
+        console.log(chalk.gray(`\n${records.length} event(s). Log: ${LOGS_PATH}`));
+    });
+}
+/** commander repeatable-option collector. */
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+/** Tail today's event file, printing new lines as they land. */
+async function followLog() {
+    const today = new Date();
+    const file = `${LOGS_PATH}/events-${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}.jsonl`;
+    let offset = 0;
+    try {
+        offset = fs.statSync(file).size;
+    }
+    catch {
+        // File may not exist yet — start at 0 and pick it up on first write.
+    }
+    console.log(chalk.gray(`Tailing ${file} — Ctrl-C to stop`));
+    const drain = () => {
+        let size = 0;
+        try {
+            size = fs.statSync(file).size;
+        }
+        catch {
+            return;
+        }
+        if (size <= offset) {
+            if (size < offset)
+                offset = 0; // rotated/truncated
+            return;
+        }
+        const fd = fs.openSync(file, 'r');
+        try {
+            const buf = Buffer.alloc(size - offset);
+            fs.readSync(fd, buf, 0, buf.length, offset);
+            offset = size;
+            for (const line of buf.toString('utf-8').split('\n').filter(Boolean)) {
+                try {
+                    console.log(renderRow(JSON.parse(line)));
+                }
+                catch {
+                    // Skip malformed lines.
+                }
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    };
+    // Poll — simpler and more portable than fs.watch across platforms/editors.
+    await new Promise(() => {
+        setInterval(drain, 500);
+    });
+}

package/dist/commands/exec.js

@@ -294,7 +294,12 @@ export function registerRunCommand(program) {
                     console.log(chalk.green(`Dispatched to ${host.name}.`) + chalk.gray(' Track: agents hosts ps · Follow: agents hosts logs <id> -f'));
                     process.exit(0);
                 }
-                process.exit(exitCode === undefined || exitCode === -1 ? 1 : exitCode);
+                // -1 = the follow window closed but the run continues on the host (the
+                // reattach hint is already printed). That's a detach, not a failure —
+                // exit 0. Any real remote code passes through.
+                if (exitCode === -1)
+                    process.exit(0);
+                process.exit(exitCode ?? 1);
             }
             catch (err) {
                 console.error(chalk.red(err.message));

package/dist/commands/hosts.js

@@ -7,15 +7,16 @@
  * hosts. Dispatch itself is `agents run --host <name>` (see commands/exec.ts).
  */
 import chalk from 'chalk';
+import { terminalWidth, truncateToWidth, stringWidth } from '../lib/session/width.js';
 import { checkbox, confirm } from '@inquirer/prompts';
 import { assertValidSshTarget } from '../lib/ssh-exec.js';
 import { getProvider, listAllHosts, resolveHost } from '../lib/hosts/registry.js';
 import { sshTargetFor } from '../lib/hosts/types.js';
 import { listSshConfigHosts, listKnownHosts, isSshConfigHost } from '../lib/hosts/ssh-config.js';
 import { probeHost, remoteAgentsVersion, bootstrapAgentsCli, localCliVersion, } from '../lib/hosts/ready.js';
-import { listTasks, loadTask, localLogPath } from '../lib/hosts/tasks.js';
-import { followHostTask } from '../lib/hosts/progress.js';
-import * as fs from 'fs';
+import { listTasks } from '../lib/hosts/tasks.js';
+import { reconcileRunningTasks } from '../lib/hosts/reconcile.js';
+import { showHostTaskLog } from '../lib/hosts/logs.js';
 /** Parse `user@host` or `host` into its pieces. */
 function parseTarget(target) {
     const at = target.indexOf('@');
@@ -23,9 +24,12 @@ function parseTarget(target) {
         return { address: target };
     return { user: target.slice(0, at), address: target.slice(at + 1) };
 }
-/** Bootstrap/verify agents-cli on a freshly-enrolled host (best-effort, prompts). */
-async function maybeBootstrap(target, hostName) {
-    const probe = probeHost(target);
+/**
+ * Bootstrap/verify agents-cli on a freshly-enrolled host (best-effort, prompts).
+ * Callers that just probed the host pass the result through to avoid a second,
+ * redundant `uname` round-trip; otherwise we probe here.
+ */
+async function maybeBootstrap(target, hostName, probe = probeHost(target)) {
     if (!probe.reachable) {
         console.log(chalk.yellow(`  Not reachable over SSH yet — skipping bootstrap. Fix key auth, then: agents hosts check ${hostName}`));
         return;
@@ -75,7 +79,7 @@ async function doAdd(name, target, opts) {
             await registerHost({ name: c, provider: 'local', source, ...(source === 'inline' ? { address: c } : {}), os: probe.os, caps: opts.cap });
             console.log(chalk.green(`Enrolled ${c}`) + chalk.gray(` (${source}${probe.os ? `, ${probe.os}` : ''})`));
             if (opts.enroll !== false)
-                await maybeBootstrap(c, c);
+                await maybeBootstrap(c, c, probe);
         }
         return;
     }
@@ -107,7 +111,7 @@ async function doAdd(name, target, opts) {
     await registerHost(spec);
     console.log(chalk.green(`Enrolled ${name}`) + chalk.gray(` (${spec.source}${spec.os ? `, ${spec.os}` : ''}${spec.caps?.length ? `, caps: ${spec.caps.join(',')}` : ''})`));
     if (opts.enroll !== false)
-        await maybeBootstrap(sshTarget, name);
+        await maybeBootstrap(sshTarget, name, probe);
 }
 async function doList(json) {
     const hosts = await listAllHosts();
@@ -122,8 +126,11 @@ async function doList(json) {
     console.log(chalk.bold('NAME').padEnd(20) + chalk.bold('SOURCE').padEnd(13) + chalk.bold('TARGET').padEnd(28) + chalk.bold('CAPS'));
     for (const h of hosts) {
         const tgt = h.source === 'ssh-config' ? chalk.gray('(ssh-config)') : `${h.user ? h.user + '@' : ''}${h.address ?? ''}`;
+        // Cap TARGET at its column so a long user@host can't shove CAPS out of alignment.
+        const tgtW = stringWidth(tgt);
+        const tgtCol = tgtW > 28 ? truncateToWidth(tgt, 28) : tgt + ' '.repeat(28 - tgtW);
         const mark = h.enrolled ? '' : chalk.gray(' ·available');
-        console.log(h.name.padEnd(20) + h.source.padEnd(13) + tgt.padEnd(28) + (h.caps?.join(',') ?? '') + mark);
+        console.log(h.name.padEnd(20) + h.source.padEnd(13) + tgtCol + (h.caps?.join(',') ?? '') + mark);
     }
 }
 async function doCheck(name) {
@@ -155,7 +162,10 @@ async function doRemove(name) {
     console.log(chalk.green(`Removed ${name}`));
 }
 async function doPs(json) {
-    const tasks = listTasks();
+    // Heal any 'running' record whose local follower died (dropped connection,
+    // laptop sleep) against the remote `.exit` before listing, so `ps` never shows
+    // a finished run stuck at 'running'.
+    const tasks = reconcileRunningTasks(listTasks());
     if (json) {
         console.log(JSON.stringify(tasks, null, 2));
         return;
@@ -164,30 +174,24 @@ async function doPs(json) {
         console.log(chalk.gray('No host tasks yet. Dispatch one: agents run <agent> "<task>" --host <name>'));
         return;
     }
+    const cols = terminalWidth();
     console.log(chalk.bold('ID').padEnd(11) + chalk.bold('HOST').padEnd(16) + chalk.bold('AGENT').padEnd(10) + chalk.bold('STATUS').padEnd(11) + chalk.bold('PROMPT'));
     for (const t of tasks) {
         const status = t.status === 'completed' ? chalk.green(t.status) : t.status === 'failed' ? chalk.red(t.status) : chalk.yellow(t.status);
-        console.log(t.id.padEnd(11) + t.host.padEnd(16) + t.agent.padEnd(10) + status.padEnd(11) + t.prompt.slice(0, 50));
+        // Prompt fills the remaining width instead of a fixed 50-char byte slice (98-char rows).
+        const promptCol = truncateToWidth(t.prompt, Math.max(12, cols - (11 + 16 + 10 + 11)));
+        console.log(t.id.padEnd(11) + t.host.padEnd(16) + t.agent.padEnd(10) + status.padEnd(11) + promptCol);
     }
 }
 async function doLogs(id, follow) {
-    const task = loadTask(id);
-    if (!task) {
+    const res = await showHostTaskLog(id, follow);
+    if (!res.found) {
         console.log(chalk.red(`Unknown task "${id}".`));
         process.exitCode = 1;
         return;
     }
-    if (follow && task.status === 'running') {
-        const code = await followHostTask(task.target, { remoteLog: task.remoteLog, remoteExit: task.remoteExit, taskId: id, echo: true });
-        process.exitCode = code === -1 ? 1 : code;
-        return;
-    }
-    try {
-        process.stdout.write(fs.readFileSync(localLogPath(id), 'utf-8'));
-    }
-    catch {
-        console.log(chalk.gray('(no local log captured for this task)'));
-    }
+    if (res.exitCode !== undefined)
+        process.exitCode = res.exitCode;
 }
 /** Register the `agents hosts` command tree. */
 export function registerHostsCommand(program) {

package/dist/commands/import.js

@@ -263,7 +263,7 @@ When to use:
   pointing at the existing install — nothing is copied or moved (except the
   agent's config dir, which is moved into the version's home). Works for both
   npm-style packages (claude, codex, gemini, opencode, openclaw) and
-  installScript-based agents (grok, antigravity, cursor, kiro, goose, roo).
+  installScript-based agents (grok, antigravity, cursor, kiro, goose).
 `)
         .action(runImport);
 }

package/dist/commands/inspect.d.ts

@@ -18,6 +18,8 @@ import { type PluginResourceGroup } from '../lib/plugins.js';
 /** Resource kinds the inspect command can drill into. */
 declare const DRILLABLE_KINDS: readonly ["commands", "skills", "hooks", "mcp", "rules", "plugins", "workflows", "subagents"];
 type DrillableKind = typeof DRILLABLE_KINDS[number];
+/** Wrap a separator-joined value list under `prefix`, preserving a hanging indent. */
+export declare function wrapJoined(prefix: string, items: string[], sep: string, width: number): string[];
 interface ResourceItem {
     name: string;
     source: string;

package/dist/commands/inspect.js

@@ -31,6 +31,7 @@ import { discoverPlugins, discoverPluginsInDir, pluginResourceGroups } from '../
 import { PLUGIN_GROUP_COLORS } from './plugins.js';
 import { countSessionsInScope } from '../lib/session/discover.js';
 import { damerauLevenshtein } from '../lib/fuzzy.js';
+import { terminalWidth, truncateToWidth, stringWidth, stripAnsi } from '../lib/session/width.js';
 /** Resource kinds the inspect command can drill into. */
 const DRILLABLE_KINDS = [
     'commands',
@@ -68,6 +69,44 @@ const SINGULAR_DRILL_ALIASES = {
 const CAPABILITY_NAMES = [
     'hooks', 'mcp', 'skills', 'commands', 'subagents', 'plugins', 'workflows', 'rules', 'allowlist',
 ];
+/** Wrap a separator-joined value list under `prefix`, preserving a hanging indent. */
+export function wrapJoined(prefix, items, sep, width) {
+    if (items.length === 0)
+        return [];
+    const continuation = ' '.repeat(stringWidth(prefix));
+    const fitItem = (item, linePrefix) => {
+        const room = Math.max(1, width - stringWidth(linePrefix));
+        return stringWidth(item) > room ? truncateToWidth(item, room) : item;
+    };
+    const lines = [];
+    let linePrefix = prefix;
+    let line = prefix;
+    let hasItem = false;
+    for (const raw of items) {
+        const item = fitItem(raw, linePrefix);
+        const candidate = hasItem ? `${line}${sep}${item}` : `${line}${item}`;
+        if (hasItem && stringWidth(candidate) > width) {
+            lines.push(line);
+            linePrefix = continuation;
+            line = continuation + fitItem(raw, linePrefix);
+            hasItem = true;
+        }
+        else {
+            line = candidate;
+            hasItem = true;
+        }
+    }
+    if (hasItem)
+        lines.push(line);
+    return lines;
+}
+function printWrappedJoined(prefix, items, sep) {
+    for (const line of wrapJoined(prefix, items, sep, terminalWidth()))
+        console.log(line);
+}
+function truncateValueForPrefix(prefix, value) {
+    return truncateToWidth(stripAnsi(value), Math.max(1, terminalWidth() - stringWidth(prefix)));
+}
 // ─── Command registration ────────────────────────────────────────────────────
 export function registerInspectCommand(program) {
     const cmd = addHostOption(program.command('inspect <target>'))
@@ -425,7 +464,10 @@ function renderRepoSummary(repo, options) {
         console.log(`  ${'git'.padEnd(10)} ${git.branch}${dirty}${url}`);
         if (git.lastCommit) {
             const rel = git.lastCommit.relative ? `  ${chalk.gray(`(${git.lastCommit.relative})`)}` : '';
-            sub('last', `${chalk.cyan(git.lastCommit.sha)}  ${truncate(git.lastCommit.subject, 60)}${rel}`);
+            const prefix = `  ${''.padEnd(10)} ${chalk.gray('last'.padEnd(8))} `;
+            const sha = chalk.cyan(git.lastCommit.sha);
+            const subjectWidth = Math.max(8, terminalWidth() - stringWidth(prefix) - stringWidth(sha) - 2 - stringWidth(rel));
+            console.log(`${prefix}${sha}  ${truncateToWidth(git.lastCommit.subject, subjectWidth)}${rel}`);
         }
         if (git.ahead !== null && git.behind !== null && (git.ahead > 0 || git.behind > 0)) {
             sub('sync', `ahead ${git.ahead} ${chalk.gray('·')} behind ${git.behind}`);
@@ -440,10 +482,12 @@ function renderRepoSummary(repo, options) {
         console.log(`  ${'manifests'.padEnd(10)} ${manifests.join(', ')}`);
         if (manifest) {
             if (manifest.versions.length > 0) {
-                sub('versions', manifest.versions.map(v => `${v.agent} ${chalk.cyan(v.version)}`).join(chalk.gray(' · ')));
+                const prefix = `  ${''.padEnd(10)} ${chalk.gray('versions'.padEnd(8))} `;
+                printWrappedJoined(prefix, manifest.versions.map(v => `${v.agent} ${chalk.cyan(v.version)}`), chalk.gray(' · '));
             }
             if (manifest.strategies.length > 0) {
-                sub('run', manifest.strategies.map(s => `${s.agent}:${s.strategy}`).join(chalk.gray(' · ')));
+                const prefix = `  ${''.padEnd(10)} ${chalk.gray('run'.padEnd(8))} `;
+                printWrappedJoined(prefix, manifest.strategies.map(s => `${s.agent}:${s.strategy}`), chalk.gray(' · '));
             }
         }
     }
@@ -551,8 +595,10 @@ async function renderSummary(agent, version, versionHome, options) {
         ['alias', aliasPath],
         ['strategy', strategy],
     ];
-    for (const [k, v] of rows)
-        console.log(`  ${k.padEnd(10)} ${v}`);
+    for (const [k, v] of rows) {
+        const prefix = `  ${k.padEnd(10)} `;
+        console.log(prefix + truncateValueForPrefix(prefix, v));
+    }
     console.log('\n' + chalk.bold('Capabilities'));
     for (const cap of CAPABILITY_NAMES) {
         const res = capabilities[cap];
@@ -603,7 +649,8 @@ function renderItemList(header, jsonHead, kind, items, options) {
         const tag = chalk.gray(`[${item.source}]`.padEnd(10));
         console.log(`  ${tag} ${termLink(chalk.cyan(item.name), item.linkTarget)}`);
         if (item.description) {
-            console.log(`             ${chalk.gray(truncate(item.description, 90))}`);
+            const prefix = '             ';
+            console.log(prefix + chalk.gray(truncateToWidth(item.description, Math.max(1, terminalWidth() - stringWidth(prefix)))));
         }
         if (item.groups)
             printGroupRows(item.groups);
@@ -1171,7 +1218,7 @@ function readFirstProseLine(p) {
 }
 // ─── OSC-8 + path helpers ────────────────────────────────────────────────────
 function termLink(text, filePath) {
-    if (!filePath)
+    if (!filePath || !process.stdout.isTTY)
         return text;
     const url = `file://${filePath}`;
     return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;