@phnx-labs/agents-cli 1.20.91 → 1.20.93

package/dist/lib/session/bash-command.js

@@ -0,0 +1,364 @@
+import { split as shlexSplit } from 'shlex';
+const TOOL_REGISTRY = {
+    // VCS
+    git: { category: 'vcs', signal: 'mid', action: 'working in git' },
+    gh: { category: 'vcs', signal: 'mid', action: 'using GitHub CLI' },
+    // Build / test
+    bun: { category: 'build-test', signal: 'mid', action: 'running bun' },
+    npm: { category: 'build-test', signal: 'mid', action: 'running npm' },
+    pnpm: { category: 'build-test', signal: 'mid', action: 'running pnpm' },
+    yarn: { category: 'build-test', signal: 'mid', action: 'running yarn' },
+    vitest: { category: 'build-test', signal: 'mid', action: 'running vitest' },
+    jest: { category: 'build-test', signal: 'mid', action: 'running jest' },
+    mocha: { category: 'build-test', signal: 'mid', action: 'running mocha' },
+    pytest: { category: 'build-test', signal: 'mid', action: 'running pytest' },
+    cargo: { category: 'build-test', signal: 'mid', action: 'running cargo' },
+    go: { category: 'build-test', signal: 'mid', action: 'running go' },
+    tsc: { category: 'build-test', signal: 'mid', action: 'running tsc' },
+    tsx: { category: 'build-test', signal: 'mid', action: 'running tsx' },
+    node: { category: 'build-test', signal: 'low', action: 'running node' },
+    python: { category: 'build-test', signal: 'low', action: 'running python', aliases: ['python3'] },
+    make: { category: 'build-test', signal: 'mid', action: 'running make' },
+    // Install
+    brew: { category: 'install', signal: 'mid', action: 'installing with brew' },
+    pip: { category: 'install', signal: 'mid', action: 'installing with pip', aliases: ['pip3'] },
+    apt: { category: 'install', signal: 'mid', action: 'installing with apt' },
+    apk: { category: 'install', signal: 'mid', action: 'installing with apk' },
+    // Remote
+    ssh: { category: 'remote', signal: 'mid', action: 'using ssh' },
+    scp: { category: 'remote', signal: 'mid', action: 'using scp' },
+    rsync: { category: 'remote', signal: 'mid', action: 'using rsync' },
+    // HTTP
+    curl: { category: 'http', signal: 'mid', action: 'fetching with curl' },
+    wget: { category: 'http', signal: 'mid', action: 'fetching with wget' },
+    // Media
+    ffmpeg: { category: 'media', signal: 'high', action: 'using ffmpeg' },
+    ffprobe: { category: 'media', signal: 'mid', action: 'probing media' },
+    magick: { category: 'media', signal: 'mid', action: 'using ImageMagick' },
+    convert: { category: 'media', signal: 'mid', action: 'converting images' },
+    composite: { category: 'media', signal: 'mid', action: 'compositing images' },
+    montage: { category: 'media', signal: 'mid', action: 'montaging images' },
+    identify: { category: 'media', signal: 'mid', action: 'identifying images' },
+    // Upscaling
+    realesrgan: {
+        category: 'upscaling',
+        signal: 'high',
+        action: 'upscaling with realesrgan',
+        aliases: ['realesrgan-ncnn-vulkan'],
+    },
+    waifu2x: {
+        category: 'upscaling',
+        signal: 'high',
+        action: 'upscaling with waifu2x',
+        aliases: ['waifu2x-caffe', 'waifu2x-converter-cpp'],
+    },
+    swin2sr: { category: 'upscaling', signal: 'high', action: 'upscaling with swin2sr' },
+    resdet: { category: 'upscaling', signal: 'mid', action: 'detecting upscale' },
+    // Metadata
+    id3v2: { category: 'metadata', signal: 'mid', action: 'editing id3 tags' },
+    exiftool: { category: 'metadata', signal: 'mid', action: 'editing exif metadata' },
+    metaflac: { category: 'metadata', signal: 'mid', action: 'editing flac metadata' },
+    vorbiscomment: { category: 'metadata', signal: 'mid', action: 'editing vorbis comments' },
+    // Shell
+    rm: { category: 'shell', signal: 'low', action: 'removing files' },
+    mv: { category: 'shell', signal: 'low', action: 'moving files' },
+    cp: { category: 'shell', signal: 'low', action: 'copying files' },
+    mkdir: { category: 'shell', signal: 'low', action: 'making directories' },
+    touch: { category: 'shell', signal: 'low', action: 'touching files' },
+    echo: { category: 'shell', signal: 'low', action: 'echoing' },
+    printf: { category: 'shell', signal: 'low', action: 'printing' },
+    chmod: { category: 'shell', signal: 'low', action: 'changing permissions' },
+    ln: { category: 'shell', signal: 'low', action: 'linking files' },
+    awk: { category: 'shell', signal: 'low', action: 'running awk' },
+    sed: { category: 'shell', signal: 'low', action: 'running sed' },
+    tee: { category: 'shell', signal: 'low', action: 'teeing output' },
+    xargs: { category: 'shell', signal: 'low', action: 'running xargs' },
+    // Probes
+    ls: { category: 'probe', signal: 'low', action: 'listing files' },
+    cat: { category: 'probe', signal: 'low', action: 'reading files' },
+    head: { category: 'probe', signal: 'low', action: 'reading files' },
+    tail: { category: 'probe', signal: 'low', action: 'reading files' },
+    wc: { category: 'probe', signal: 'low', action: 'counting' },
+    stat: { category: 'probe', signal: 'low', action: 'statting files' },
+    file: { category: 'probe', signal: 'low', action: 'inspecting files' },
+    which: { category: 'probe', signal: 'low', action: 'locating binaries' },
+    tree: { category: 'probe', signal: 'low', action: 'listing files' },
+    pwd: { category: 'probe', signal: 'low', action: 'printing pwd' },
+    // Search
+    grep: { category: 'search', signal: 'low', action: 'searching' },
+    rg: { category: 'search', signal: 'low', action: 'searching with ripgrep' },
+    ag: { category: 'search', signal: 'low', action: 'searching with the silver searcher' },
+    fd: { category: 'search', signal: 'low', action: 'searching files' },
+    find: { category: 'search', signal: 'low', action: 'finding files' },
+    // Wait
+    sleep: { category: 'wait', signal: 'low', action: 'sleeping' },
+    wait: { category: 'wait', signal: 'low', action: 'waiting' },
+};
+/**
+ * Two-level tools (bucket key includes the subcommand) mapped to the flags that
+ * consume the *following* token as their value, per tool. The subcommand scan
+ * skips both a value flag and its argument, so `git -C /repo commit` → `commit`
+ * and `kubectl -n prod get` → `get`. Missing a value flag mis-reads the value as
+ * the subcommand; over-listing one only drops the subcommand (a safe tool-only
+ * bucket), so err toward listing. A tool with no such leading flags maps to an
+ * empty set. TWO_LEVEL_TOOLS is derived from these keys so the two never drift.
+ */
+const VALUE_FLAGS = {
+    git: new Set(['-C', '-c', '--git-dir', '--work-tree']),
+    gh: new Set(['-R', '--repo']),
+    bun: new Set(['--cwd']),
+    npm: new Set(['--prefix', '-w', '--workspace']),
+    pnpm: new Set(['--filter', '-C', '--dir']),
+    yarn: new Set(['--cwd']),
+    cargo: new Set(['--manifest-path']),
+    docker: new Set(['-H', '--host', '-c', '--context', '--config', '-l', '--log-level']),
+    kubectl: new Set(['-n', '--namespace', '--kubeconfig', '--context', '--cluster', '--user', '-s', '--server', '--as', '--token', '--cache-dir', '--request-timeout']),
+    rush: new Set(),
+    openclaw: new Set(),
+};
+/** Tools whose bucket key includes the second token (subcommand). */
+const TWO_LEVEL_TOOLS = new Set(Object.keys(VALUE_FLAGS));
+/** Remote wrappers whose bucket key carries an `ssh→` prefix on the inner command. */
+const REMOTE_WRAPPERS = new Set(['ssh', 'scp', 'rsync']);
+const ALIAS_MAP = new Map();
+for (const [name, info] of Object.entries(TOOL_REGISTRY)) {
+    ALIAS_MAP.set(name, name);
+    for (const alias of info.aliases ?? []) {
+        ALIAS_MAP.set(alias, name);
+    }
+}
+export function unwrapCommand(cmd) {
+    const s = cmd.trim();
+    // ssh host command
+    const ssh = s.match(/^ssh\s+\S+\s+["']?(.+?)["']?\s*(?:\|.*)?$/);
+    if (ssh)
+        return unwrapCommand(ssh[1]);
+    // VAR=value prefix (value may be a single- or double-quoted string with spaces)
+    const env = s.match(/^([A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)+(.+)$/);
+    if (env)
+        return unwrapCommand(env[2]);
+    // sudo / time prefix (value-taking flags like `-u user` consume their argument)
+    const prefix = s.match(/^(?:sudo|time)(?:\s+(?:-[uUgGhpCrtDR]\s+\S+|-\S+))*\s+(.+)$/);
+    if (prefix)
+        return unwrapCommand(prefix[1]);
+    // cd foo && command
+    const cd = s.match(/^cd\s+\S+\s*&&\s*(.+)$/);
+    if (cd)
+        return unwrapCommand(cd[1]);
+    // npx / bunx
+    const npx = s.match(/^(?:npx|bunx)\s+(?:-\S+\s+)*(.+)$/);
+    if (npx)
+        return unwrapCommand(npx[1]);
+    return s;
+}
+function splitOnOperators(cmd) {
+    const parts = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    let i = 0;
+    while (i < cmd.length) {
+        const ch = cmd[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            i += 1;
+            continue;
+        }
+        if (ch === '\\') {
+            current += ch;
+            escaped = true;
+            i += 1;
+            continue;
+        }
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            current += ch;
+            quote = ch;
+            i += 1;
+            continue;
+        }
+        if (cmd.slice(i, i + 2) === '&&' || cmd.slice(i, i + 2) === '||') {
+            if (current.trim())
+                parts.push(current.trim());
+            current = '';
+            i += 2;
+            continue;
+        }
+        if (ch === '|' || ch === ';') {
+            if (current.trim())
+                parts.push(current.trim());
+            current = '';
+            i += 1;
+            continue;
+        }
+        current += ch;
+        i += 1;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+/**
+ * Split a possibly-compound Bash command into simple commands, then tokenize each
+ * with shlex. Returns an empty array for empty input.
+ */
+export function tokenizeBash(cmd) {
+    const unwrapped = unwrapCommand(cmd);
+    const segments = splitOnOperators(unwrapped);
+    const out = [];
+    for (const seg of segments) {
+        try {
+            const tokens = shlexSplit(seg);
+            if (tokens.length)
+                out.push(tokens);
+        }
+        catch {
+            // If shlex can't parse, fall back to whitespace split.
+            const tokens = seg.split(/\s+/).filter(Boolean);
+            if (tokens.length)
+                out.push(tokens);
+        }
+    }
+    return out;
+}
+/**
+ * First non-flag token after the executable — its subcommand. Skips leading
+ * flags, and skips the argument of a value-taking flag for that tool (see
+ * VALUE_FLAGS) so e.g. `git -C /repo commit` resolves to `commit`, not `-C`, and
+ * `kubectl -n prod get` resolves to `get`, not `prod`.
+ */
+function scanSubcommand(tokens, tool) {
+    const valueFlags = VALUE_FLAGS[tool];
+    let i = 1;
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (t.startsWith('-')) {
+            i += valueFlags?.has(t) ? 2 : 1;
+            continue;
+        }
+        return t.toLowerCase();
+    }
+    return '';
+}
+/**
+ * Classify the first simple command in a Bash string. Returns coarse metadata
+ * (tool name, category, subcommand, human action) used for summaries and
+ * activity logging. Unknown executables fall back to `other`.
+ */
+export function classifyBashCommand(command) {
+    const simpleCommands = tokenizeBash(command);
+    if (!simpleCommands.length) {
+        return { tool: 'other', category: 'other', subcommand: '', action: 'running command', summary: '', signal: 'low' };
+    }
+    const tokens = simpleCommands[0];
+    if (!tokens.length) {
+        return { tool: 'other', category: 'other', subcommand: '', action: 'running command', summary: '', signal: 'low' };
+    }
+    const first = tokens[0];
+    const baseRaw = first.replace(/^[./]+/, '').toLowerCase();
+    const base = baseRaw.endsWith('.exe') ? baseRaw.slice(0, -4) : baseRaw;
+    const canonical = ALIAS_MAP.get(base);
+    const info = canonical ? TOOL_REGISTRY[canonical] : undefined;
+    if (!info) {
+        // Unknown executable. A known two-level tool that isn't in the registry
+        // (docker/kubectl/rush/openclaw) still surfaces its subcommand so bucketing
+        // stays useful; the category stays honestly 'other'.
+        const subcommand = TWO_LEVEL_TOOLS.has(base) ? scanSubcommand(tokens, base) : '';
+        const summary = subcommand ? `${base} ${subcommand}` : base;
+        return { tool: base, category: 'other', subcommand, action: 'running command', summary, signal: 'low' };
+    }
+    const subcommand = canonical && TWO_LEVEL_TOOLS.has(canonical) ? scanSubcommand(tokens, canonical) : '';
+    const safeCanonical = canonical || base;
+    const summary = subcommand ? `${safeCanonical} ${subcommand}` : safeCanonical;
+    return {
+        tool: safeCanonical,
+        category: info.category,
+        subcommand,
+        action: info.action,
+        summary,
+        signal: info.signal,
+    };
+}
+/**
+ * Stable bucket key for grouping similar Bash commands in summaries. Commands run
+ * through a remote wrapper (ssh/scp/rsync) get an `ssh→` prefix on the inner key,
+ * so `ssh host "git push"` buckets as `ssh→git push`, distinct from a local push.
+ */
+export function bucketKey(command) {
+    const info = classifyBashCommand(command);
+    const base = !info.tool
+        ? 'other'
+        : info.subcommand && TWO_LEVEL_TOOLS.has(info.tool)
+            ? `${info.tool} ${info.subcommand}`
+            : info.tool;
+    const first = command.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
+    return REMOTE_WRAPPERS.has(first) ? `ssh→${base}` : base;
+}
+/**
+ * Detect high-signal Bash-driven milestones (video renders, upscales, metadata
+ * edits, git commits/pushes/worktrees, PR opens). Returns null for routine
+ * commands.
+ */
+export function detectBashMilestone(command) {
+    const info = classifyBashCommand(command);
+    const lower = (command || '').toLowerCase();
+    if (info.category === 'upscaling') {
+        return { event: 'image.upscaled', detail: info.action };
+    }
+    if (info.tool === 'ffmpeg') {
+        const hasOutput = /\s+\S+\.\w{2,5}\s*$/.test(command || '');
+        if (hasOutput || lower.includes('-c:v') || lower.includes('-codec') || lower.includes('libx264')) {
+            return { event: 'video.rendered', detail: 'ffmpeg render' };
+        }
+        return { event: 'video.converted', detail: 'ffmpeg' };
+    }
+    if (info.category === 'metadata') {
+        return { event: 'metadata.edited', detail: info.action };
+    }
+    if (info.tool === 'git') {
+        if (info.subcommand === 'commit')
+            return { event: 'commit.created', detail: 'git commit' };
+        if (info.subcommand === 'push')
+            return { event: 'pushed', detail: 'git push' };
+        if (info.subcommand === 'worktree') {
+            if (lower.includes('worktree add'))
+                return { event: 'worktree.created', detail: 'git worktree add' };
+            if (lower.includes('worktree remove'))
+                return { event: 'worktree.removed', detail: 'git worktree remove' };
+        }
+    }
+    if (info.tool === 'gh' && info.subcommand === 'pr') {
+        if (lower.includes('pr create'))
+            return { event: 'pr.opened', detail: 'gh pr create' };
+        if (lower.includes('pr merge'))
+            return { event: 'pr.merged', detail: 'gh pr merge' };
+    }
+    return null;
+}
+/**
+ * Human-readable category label for renderers.
+ */
+export function categoryLabel(category) {
+    switch (category) {
+        case 'vcs': return 'Version control';
+        case 'build-test': return 'Build / test';
+        case 'install': return 'Install';
+        case 'remote': return 'Remote';
+        case 'http': return 'HTTP';
+        case 'media': return 'Media';
+        case 'upscaling': return 'Upscaling';
+        case 'metadata': return 'Metadata';
+        case 'probe': return 'Probes';
+        case 'search': return 'Search';
+        case 'shell': return 'Shell';
+        case 'wait': return 'Wait';
+        default: return 'Other';
+    }
+}

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

@@ -42,6 +42,12 @@ export declare function toolHistogram(toolCounts: Record<string, number>, top?:
     tool: string;
     count: number;
 }>;
+/**
+ * Aggregate recognized external tools invoked via Bash across a session.
+ * Unknown one-off commands are bucketed as `other` so the ranking surface
+ * (e.g. `agents activity --tools`) only surfaces repeatable tools.
+ */
+export declare function bashToolCounts(events: SessionEvent[]): Record<string, number>;
 export interface TestResult {
     runner: string;
     passed?: number;

package/dist/lib/session/digest.js

@@ -7,6 +7,7 @@
  * last test/build result. Consumed by the single-session view and the picker
  * preview. No I/O — fully unit-testable.
  */
+import { bucketKey, classifyBashCommand } from './bash-command.js';
 // Tool vocab mirrors parse.ts / render.ts so classification matches what those
 // modules already recognize across Claude/Codex/others.
 const READ_TOOLS = new Set(['Read', 'read_file', 'view_file', 'cat_file', 'get_file']);
@@ -127,6 +128,24 @@ export function toolHistogram(toolCounts, top = 8) {
         .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
         .slice(0, top);
 }
+/**
+ * Aggregate recognized external tools invoked via Bash across a session.
+ * Unknown one-off commands are bucketed as `other` so the ranking surface
+ * (e.g. `agents activity --tools`) only surfaces repeatable tools.
+ */
+export function bashToolCounts(events) {
+    const counts = {};
+    for (const e of events) {
+        if (e.type !== 'tool_use' || e._local)
+            continue;
+        if (e.tool !== 'Bash' || !e.command)
+            continue;
+        const info = classifyBashCommand(e.command);
+        const key = info.category === 'other' ? 'other' : bucketKey(e.command);
+        counts[key] = (counts[key] || 0) + 1;
+    }
+    return counts;
+}
 /**
  * Recognized test/build runners → the label we show.
  *

package/dist/lib/session/relative-time.d.ts

@@ -5,6 +5,29 @@
  * `remote.ts`, so a back-import would cycle.
  */
 export declare function formatRelativeTime(isoTimestamp: string): string;
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export declare function formatCompactAge(isoTimestamp: string): string;
+/** The two time fields a session listing shows for one row. */
+export interface SessionAgeParts {
+    /**
+     * Compact age of the session's creation, set only when the session ran long
+     * enough (>= a minute) for it to say something `last` does not.
+     */
+    created?: string;
+    /** Last-activity label — the long relative form the listing sorts by. */
+    last: string;
+}
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export declare function sessionAgeParts(createdIso: string, lastActivityIso?: string): SessionAgeParts;
 /**
  * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
  * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and

package/dist/lib/session/relative-time.js

@@ -4,6 +4,19 @@
  * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
  * `remote.ts`, so a back-import would cycle.
  */
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/**
+ * Calendar label for a timestamp older than the relative window. A 2-digit year
+ * is appended outside the current year so "Jun 28" is never ambiguous across
+ * years (e.g. "Jun 28 '25").
+ */
+function calendarLabel(thenMs, nowMs) {
+    const d = new Date(thenMs);
+    const label = `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+    return d.getFullYear() === new Date(nowMs).getFullYear()
+        ? label
+        : `${label} '${String(d.getFullYear()).slice(-2)}`;
+}
 export function formatRelativeTime(isoTimestamp) {
     const now = Date.now();
     const then = new Date(isoTimestamp).getTime();
@@ -21,14 +34,53 @@ export function formatRelativeTime(isoTimestamp) {
         return `${diffHrs} hour${diffHrs === 1 ? '' : 's'} ago`;
     if (diffDays < 7)
         return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
-    // Older: show the date. Append a 2-digit year for anything outside the current
-    // year so "Jun 28" is never ambiguous across years (e.g. "Jun 28 '25").
-    const d = new Date(then);
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    const label = `${months[d.getMonth()]} ${d.getDate()}`;
-    return d.getFullYear() === new Date(now).getFullYear()
-        ? label
-        : `${label} '${String(d.getFullYear()).slice(-2)}`;
+    // Older: show the date.
+    return calendarLabel(then, now);
+}
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export function formatCompactAge(isoTimestamp) {
+    const now = Date.now();
+    const then = new Date(isoTimestamp).getTime();
+    if (isNaN(then))
+        return isoTimestamp;
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60_000);
+    const diffHrs = Math.floor(diffMs / 3_600_000);
+    const diffDays = Math.floor(diffMs / 86_400_000);
+    if (diffMin < 1)
+        return 'now';
+    if (diffMin < 60)
+        return `${diffMin}m`;
+    if (diffHrs < 24)
+        return `${diffHrs}h`;
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    return calendarLabel(then, now);
+}
+/**
+ * Shortest creation→last-activity gap worth rendering as two fields. Below it
+ * both halves name the same minute, so the row would carry a duplicate instead
+ * of information.
+ */
+const SPAN_MIN_MS = 60_000;
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export function sessionAgeParts(createdIso, lastActivityIso) {
+    const lastIso = lastActivityIso ?? createdIso;
+    const last = formatRelativeTime(lastIso);
+    const createdMs = new Date(createdIso).getTime();
+    const lastMs = new Date(lastIso).getTime();
+    if (isNaN(createdMs) || isNaN(lastMs) || lastMs - createdMs < SPAN_MIN_MS)
+        return { last };
+    return { created: formatCompactAge(createdIso), last };
 }
 /**
  * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch

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

@@ -25,5 +25,9 @@ export interface RemoteActiveResult {
  * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
  * online devices from `ag devices`, excluding this machine and any without an
  * address. Results from all peers run in parallel and are flattened.
+ * `opts.quiet` suppresses the per-device stderr line for callers that report
+ * skipped peers once, compactly, themselves.
  */
-export declare function gatherRemoteActive(hosts?: string[]): Promise<RemoteActiveResult>;
+export declare function gatherRemoteActive(hosts?: string[], opts?: {
+    quiet?: boolean;
+}): Promise<RemoteActiveResult>;

package/dist/lib/session/remote-active.js

@@ -56,13 +56,16 @@ export function parseRemoteActive(stdout, machine) {
  * (from `--host`), fan out to exactly those. Otherwise sweep the registered,
  * online devices from `ag devices`, excluding this machine and any without an
  * address. Results from all peers run in parallel and are flattened.
+ * `opts.quiet` suppresses the per-device stderr line for callers that report
+ * skipped peers once, compactly, themselves.
  */
-export async function gatherRemoteActive(hosts) {
+export async function gatherRemoteActive(hosts, opts) {
     const result = await gatherRemoteAgentsJson({
         args: ['sessions', '--active', '--json'],
         noFanoutEnv: NO_FANOUT_ENV,
         hosts,
         parse: parseRemoteActive,
+        quiet: opts?.quiet,
     });
     return { sessions: result.items, deviceCount: result.deviceCount };
 }

package/dist/lib/session/remote-list.js

@@ -18,7 +18,7 @@ import chalk from 'chalk';
 import { SSH_OPTS, controlOpts, assertValidSshTarget, shellQuote } from '../ssh-exec.js';
 import { sshTargetFor } from '../devices/connect.js';
 import { resolveExplicitTargets } from '../devices/resolve-target.js';
-import { loadDevices, isControlDevice } from '../devices/registry.js';
+import { loadDevices, isControlDevice, isDialableDevice } from '../devices/registry.js';
 import { remoteShellFor, buildWindowsAgentsCommand } from '../hosts/remote-cmd.js';
 import { machineId, normalizeHost } from './sync/config.js';
 import { NO_FANOUT_ENV } from './remote-active.js';
@@ -163,7 +163,10 @@ export async function gatherRemoteList(forwardedArgs, hosts) {
             return { sessions: [], deviceCount: 0, unreachable: ['device registry'] };
         }
         for (const d of Object.values(reg)) {
-            if (d.tailscale?.online !== true)
+            // Live SSH-probe verdict first, cached tailscale snapshot only as a
+            // fallback — see isDialableDevice. A manually-registered device has no
+            // tailscale peer entry, so gating on `online` alone hid its sessions.
+            if (!isDialableDevice(d))
                 continue;
             if (normalizeHost(d.name) === self)
                 continue;

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

@@ -7,6 +7,7 @@
  * transcript. Filtering by role and turn slicing is handled here as well.
  */
 import type { SessionEvent, SessionMeta } from './types.js';
+import { unwrapCommand, bucketKey } from './bash-command.js';
 /**
  * Return absPath relative to cwd; fall back to ~/… then absolute.
  */
@@ -28,18 +29,11 @@ export declare function linkPath(absPath: string, label: string): string;
  * issue, …) when the terminal supports it. Degrades to the plain label otherwise.
  */
 export declare function linkUrl(url: string, label: string): string;
-/**
- * Unwrap wrapper prefixes to find the actual executable.
- */
-export declare function unwrapCommand(cmd: string): string;
 /**
  * Normalize a command so trivial flag/pipe variations collapse to the same key.
  */
 export declare function normalizeForDedup(cmd: string): string;
-/**
- * Return the bucket key for a command (used for grouping within a category).
- */
-export declare function bucketKey(cmd: string): string;
+export { unwrapCommand, bucketKey };
 interface CmdRun {
     normalized: string;
     raw: string;
@@ -132,4 +126,3 @@ export declare function renderConversationMarkdown(events: SessionEvent[], opts?
 export declare function renderJson(events: SessionEvent[], meta?: SessionMeta, opts?: {
     redact?: boolean;
 }): string;
-export {};