@phnx-labs/agents-cli 1.22.8 → 1.22.9

package/dist/lib/daemon.js

@@ -888,14 +888,14 @@ export async function runDaemon() {
     };
     const fleetCacheInterval = setInterval(() => { void runFleetCacheWarm(); }, 3 * 60_000);
     const fleetCacheKickoff = setTimeout(() => { void runFleetCacheWarm(); }, 60_000);
-    // Adaptive usage refresh: keep the usage cache the `agents run` router reads
+    // Usage refresh: keep the usage cache the `agents run` router reads
     // (RUSH-2061, readOnly hot path) fresh, WITHOUT the hot path ever fetching.
-    // This host is the sole writer for its own local accounts. The tick wakes at
-    // the 90s floor, but per-account cadence gates the actual live fetches: an
-    // account racing toward its 5h cap is polled sooner (down to 90s), an idle one
-    // rarely (up to 15min), capped at ~6 provider calls/account/hour and skipped
-    // entirely while its provider is under a 429 backoff. Overlap-guarded like the
-    // probes above; a box signed into no networked-usage account is a clean no-op.
+    // This host is the sole writer for its own local accounts. The tick wakes
+    // every 60s (USAGE_REFRESH_TICK_MS) to consider due accounts; each account
+    // is scheduled at a fixed 5-minute cadence (REFRESH_INTERVAL_MS), capped at
+    // ~12 provider calls/account/hour, skipped under 429 backoff, and fetched
+    // with fileOnly credentials so a background tick never pops macOS Touch ID.
+    // Overlap-guarded: a slow pass cannot stack concurrent refresh loops.
     let refreshingUsage = false;
     const runUsageRefreshTick = async () => {
         if (refreshingUsage)
@@ -910,9 +910,9 @@ export async function runDaemon() {
                 writeUsageCache: writeClaudeUsageCache,
                 backoffUntil: usageRateLimitedUntil,
             });
-            if (r.refreshed > 0 || r.failed > 0) {
-                log('INFO', `usage refresh: ${r.refreshed} refreshed, ${r.failed} failed, ${r.skippedNotDue} not-due, ${r.skippedBackoff} backed-off, ${r.skippedCap} capped`);
-            }
+            // Always log a compact summary so "is refresh working?" is greppable even
+            // when every account was not-due (proves the tick ran).
+            log('INFO', `usage refresh: ${r.refreshed} refreshed, ${r.failed} failed, ${r.skippedNotDue} not-due, ${r.skippedBackoff} backed-off, ${r.skippedCap} capped`);
         }
         catch (err) {
             log('ERROR', `usage refresh failed: ${err.message}`);
@@ -921,7 +921,8 @@ export async function runDaemon() {
             refreshingUsage = false;
         }
     };
-    const usageRefreshInterval = setInterval(() => { void runUsageRefreshTick(); }, 90_000);
+    // 60s wake matches USAGE_REFRESH_TICK_MS in usage-refresh.ts (keep in sync).
+    const usageRefreshInterval = setInterval(() => { void runUsageRefreshTick(); }, 60_000);
     const usageRefreshKickoff = setTimeout(() => { void runUsageRefreshTick(); }, 30_000);
     // RUSH-1817: the startup host decision above is one-shot. If a standalone
     // broker answered agentPing() at daemon start, the daemon declined to host —

package/dist/lib/devices/resolve-target.d.ts

@@ -1,4 +1,4 @@
-import { splitUserHost } from '../hosts/registry.js';
+import { splitUserHost, type MatchHostOptions } from '../hosts/registry.js';
 import { type DeviceProfile } from './registry.js';
 export { splitUserHost };
 /** A dialable peer: the ssh target, the machine id used to tag its rows, a
@@ -21,9 +21,10 @@ export interface ResolvedExplicitTargetSet {
  * `user@host` / IP / FQDN literal yields a synthesized key-auth profile. A bare
  * unregistered alias (no `@`/dot) — or an ssh_config-only alias, which `agents
  * ssh` has never dialed — returns undefined so the caller reports "Unknown
- * device" rather than dialing a literal.
+ * device" rather than dialing a literal. `token` may also be the `auto`
+ * affinity sentinel (RUSH-2185); `opts.resolveAuto` overrides the pick (tests).
  */
-export declare function resolveDeviceTarget(token: string): Promise<DeviceProfile | undefined>;
+export declare function resolveDeviceTarget(token: string, opts?: Pick<MatchHostOptions, 'resolveAuto'>): Promise<DeviceProfile | undefined>;
 /**
  * Resolve an explicit `--host`/`--device` list to dialable targets. A token that
  * fails the injection guard or names nothing reachable is skipped with a stderr

package/dist/lib/devices/resolve-target.js

@@ -71,10 +71,11 @@ async function toResolvedTarget(token) {
  * `user@host` / IP / FQDN literal yields a synthesized key-auth profile. A bare
  * unregistered alias (no `@`/dot) — or an ssh_config-only alias, which `agents
  * ssh` has never dialed — returns undefined so the caller reports "Unknown
- * device" rather than dialing a literal.
+ * device" rather than dialing a literal. `token` may also be the `auto`
+ * affinity sentinel (RUSH-2185); `opts.resolveAuto` overrides the pick (tests).
  */
-export async function resolveDeviceTarget(token) {
-    const host = await matchHost(token, { allowBareLiteral: true });
+export async function resolveDeviceTarget(token, opts = {}) {
+    const host = await matchHost(token, { allowBareLiteral: true, ...opts });
     if (!host)
         return undefined;
     if (host.device) {

package/dist/lib/hosts/passthrough.js

@@ -24,6 +24,7 @@ import { dispatchAgentsCommand, withActorEnv } from './dispatch.js';
 import { stripRoutingFlags, buildRemoteAgentsInvocation, HOST_ROUTING_SPECS, } from './remote-cmd.js';
 import { resolveRemoteOsSync } from './remote-os.js';
 import { machineId } from '../session/sync/config.js';
+import { isDeviceAuto, resolveDeviceAffinity } from '../smart-launch.js';
 import { loadDevices } from '../devices/registry.js';
 import { isSelfHost } from '../devices/self-host.js';
 import { fanOutDevices, planFleetTargets, runLocalCommand, runOnDevice, } from '../devices/fleet.js';
@@ -396,7 +397,7 @@ export async function maybeRunOnHost(command, allArgs, opts) {
     const deviceFlag = flagValue(allArgs, 'device');
     const hostsFlag = flagValue(allArgs, 'hosts');
     const devicesFlag = flagValue(allArgs, 'devices');
-    const hostName = hostFlag ?? deviceFlag;
+    let hostName = hostFlag ?? deviceFlag;
     const fleetAll = isFleetAllSentinel(hostFlag, deviceFlag, hostsFlag, devicesFlag);
     // Proceed when any routing flag is present, including the plural fleet flags
     // that may carry the `all` sentinel.
@@ -460,6 +461,22 @@ export async function maybeRunOnHost(command, allArgs, opts) {
     // flags and bare flags were already handled.
     if (!hostName)
         return false;
+    // `auto` is the same affinity sentinel `agents run --device auto` resolves
+    // (RUSH-2185) — pick the concrete target up front via resolveDeviceAffinity so
+    // the isSelfHost check right below (which compares a literal name, not "auto")
+    // still catches a local pick and runs the command locally rather than
+    // resolving to a real Host and self-SSHing (or, if this box isn't itself a
+    // registered device, dialing a literal, nonexistent host named "auto").
+    if (isDeviceAuto(hostName)) {
+        const plan = resolveDeviceAffinity({});
+        if (!plan.host) {
+            const stripped = stripRoutingFlags(allArgs, STRIP_SPECS);
+            process.argv = [process.argv[0], process.argv[1], ...stripped];
+            return false;
+        }
+        process.stderr.write(chalk.gray(`[agents] device=auto → ${plan.host}\n`));
+        hostName = plan.host;
+    }
     // Running against your own machine is just a local run — skip the SSH round-trip.
     // Match EVERY identity the box answers to (short id, loopback, tailscale
     // dnsName), not just machineId() — a `--host <self-dnsName>` used to slip past a

package/dist/lib/hosts/registry.d.ts

@@ -19,6 +19,7 @@
 import type { Host, HostProvider, HostProviderId } from './types.js';
 import { DeviceOffloadUnsupportedError } from './types.js';
 import { type DeviceProfile } from '../devices/registry.js';
+import { type DeviceAffinityPlan } from '../smart-launch.js';
 export { DeviceOffloadUnsupportedError };
 export declare function getProvider(id: HostProviderId): HostProvider;
 export declare function getAllProviders(): HostProvider[];
@@ -52,6 +53,9 @@ export interface MatchHostOptions {
      * "Unknown device" verdict reachable).
      */
     allowBareLiteral?: boolean;
+    /** Override the affinity pick for the `auto` sentinel (tests). Defaults to
+     * `resolveDeviceAffinity({})` — the same engine `agents run --device auto` uses. */
+    resolveAuto?: () => DeviceAffinityPlan;
 }
 /**
  * The one place a `--host` / `--device` token becomes a resolved host. Reads the

package/dist/lib/hosts/registry.js

@@ -25,6 +25,8 @@ import { readMeta } from '../state.js';
 import { isSshConfigHost } from './ssh-config.js';
 import { resolveRemoteOsSync } from './remote-os.js';
 import { loadDevices, isControlDevice } from '../devices/registry.js';
+import { isDeviceAuto, resolveDeviceAffinity } from '../smart-launch.js';
+import { localMachineId } from '../session/origin-machine.js';
 // Re-export so existing importers (tests, commands) keep their path; the class
 // itself lives in types.ts so providers can throw it without a circular import.
 export { DeviceOffloadUnsupportedError };
@@ -146,6 +148,20 @@ function literalHost(token, host, user) {
  * into a dispatch verdict.
  */
 export async function matchHost(name, opts = {}) {
+    // `auto` is the same affinity sentinel `agents run --device auto` resolves
+    // (isDeviceAuto / resolveDeviceAffinity in ../smart-launch.js) — shared here so
+    // every caller through this one core (ssh, teams, dispatch/passthrough) picks a
+    // device the SAME way `run` does instead of rejecting it as "Unknown device
+    // 'auto'" (RUSH-2185). A `null` plan.host means the affinity engine picked this
+    // very machine; resolve that as the local device/host entry (if any) rather than
+    // returning nothing — callers that already special-case "target is this
+    // machine" (teams add/create, the passthrough self-host check) then treat it as
+    // local exactly as they would if the user had typed the local name.
+    if (isDeviceAuto(name)) {
+        const plan = (opts.resolveAuto ?? (() => resolveDeviceAffinity({})))();
+        const picked = plan.host ?? normalizeHost(localMachineId());
+        return matchHost(picked, opts);
+    }
     try {
         assertValidSshTarget(name);
     }

package/dist/lib/hosts/remote-cmd.js

@@ -113,6 +113,7 @@ export const RUN_OPTION_FORWARDING = {
     lease: 'local-only',
     box: 'local-only',
     keepBox: 'local-only',
+    fresh: 'local-only', // skips the warm-pool reuse for --lease; the lease path is always local
     reuse: 'local-only', // reuse-picker choice for --lease; the lease path is always local
     bare: 'local-only', // skips the local setup-copy push; lease-only concern
     tailscale: 'local-only', // --tailscale/--no-tailscale gate the lease net mode; never forwarded

package/dist/lib/observe-aliases.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Observe-umbrella aliases (Phase 3 surface consolidation).
+ *
+ * Thin name → real command expansion. No store merge — feed / sessions / events
+ * remain the stores; these are doors that point at the right reader.
+ *
+ *   inbox    → feed                  (needs-you default)
+ *   timeline → feed --filter updates (agent progress stream)
+ *   roster   → sessions --active     (live agent roster)
+ *
+ * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
+ * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
+ */
+export type ObserveAlias = 'inbox' | 'timeline' | 'roster';
+export declare const OBSERVE_ALIASES: readonly ObserveAlias[];
+export interface ObserveExpandResult {
+    /** argv for the real command (no program name): e.g. ['feed', '--filter', 'updates'] */
+    argv: string[];
+    /** One-line note for stderr (optional); empty when silent. */
+    note: string;
+}
+/** True when `rest` already carries a `--filter` / `--filter=…` flag. */
+export declare function hasFilterFlag(rest: readonly string[]): boolean;
+/** True when `rest` already carries `--active`. */
+export declare function hasActiveFlag(rest: readonly string[]): boolean;
+/**
+ * Expand an observe alias + remaining user args into the real command argv.
+ * Returns null when `alias` is not an observe alias.
+ */
+export declare function expandObserveAlias(alias: string, rest?: readonly string[]): ObserveExpandResult | null;

package/dist/lib/observe-aliases.js

@@ -0,0 +1,56 @@
+/**
+ * Observe-umbrella aliases (Phase 3 surface consolidation).
+ *
+ * Thin name → real command expansion. No store merge — feed / sessions / events
+ * remain the stores; these are doors that point at the right reader.
+ *
+ *   inbox    → feed                  (needs-you default)
+ *   timeline → feed --filter updates (agent progress stream)
+ *   roster   → sessions --active     (live agent roster)
+ *
+ * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
+ * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
+ */
+export const OBSERVE_ALIASES = ['inbox', 'timeline', 'roster'];
+/** True when `rest` already carries a `--filter` / `--filter=…` flag. */
+export function hasFilterFlag(rest) {
+    return rest.some((a) => a === '--filter' || a.startsWith('--filter='));
+}
+/** True when `rest` already carries `--active`. */
+export function hasActiveFlag(rest) {
+    return rest.some((a) => a === '--active');
+}
+/**
+ * Expand an observe alias + remaining user args into the real command argv.
+ * Returns null when `alias` is not an observe alias.
+ */
+export function expandObserveAlias(alias, rest = []) {
+    const tail = [...rest];
+    switch (alias) {
+        case 'inbox':
+            return {
+                argv: ['feed', ...tail],
+                note: 'agents inbox → agents feed (needs-you inbox)',
+            };
+        case 'timeline': {
+            const argv = hasFilterFlag(tail)
+                ? ['feed', ...tail]
+                : ['feed', '--filter', 'updates', ...tail];
+            return {
+                argv,
+                note: 'agents timeline → agents feed --filter updates',
+            };
+        }
+        case 'roster': {
+            const argv = hasActiveFlag(tail)
+                ? ['sessions', ...tail]
+                : ['sessions', '--active', ...tail];
+            return {
+                argv,
+                note: 'agents roster → agents sessions --active',
+            };
+        }
+        default:
+            return null;
+    }
+}

package/dist/lib/redact.js

@@ -2,6 +2,10 @@
  * Shared redaction helpers for text that may be exported or logged.
  */
 const SECRET_PATTERNS = [
+    // Local home paths identify operators and disclose internal filesystem layout.
+    // Keep the useful path suffix while masking the machine-specific home prefix.
+    [/(^|[\s,"'`(=:])\/(?:home|Users)\/[^/\s,"'`]+/g, '$1[HOME]'],
+    [/(^|[\s,"'`(=])[A-Z]:\\Users\\[^\\\s,"'`]+/gi, '$1[HOME]'],
     [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED_AWS_KEY]'],
     // GitHub: classic PATs (ghp_), OAuth (gho_), app/refresh/server tokens
     // (ghs_/ghr_), and fine-grained PATs (github_pat_). All share the 36-char

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

@@ -31,7 +31,11 @@ export declare function safeReadSessionFile(filePath: string, maxBytes?: number)
 /**
  * Auto-detect agent type from file path and parse the session.
  */
-export declare function parseSession(filePath: string, agent?: SessionAgentId): SessionEvent[];
+export interface ParseSessionOptions {
+    /** Keep normalized tool results compact by default; renderers can request full output. */
+    maxToolOutputChars?: number;
+}
+export declare function parseSession(filePath: string, agent?: SessionAgentId, opts?: ParseSessionOptions): SessionEvent[];
 /** Infer the agent type from a session file path using known directory conventions. */
 export declare function detectAgent(filePath: string): SessionAgentId | null;
 /**

package/dist/lib/session/parse.js

@@ -112,10 +112,12 @@ export function safeReadSessionFile(filePath, maxBytes = SESSION_FILE_MAX_BYTES)
     }
     return fs.readFileSync(filePath, 'utf-8');
 }
-/**
- * Auto-detect agent type from file path and parse the session.
- */
-export function parseSession(filePath, agent) {
+function truncateNormalizedToolOutput(output, maxChars) {
+    if (!Number.isFinite(maxChars) || output.length <= maxChars)
+        return output;
+    return `${output.slice(0, maxChars)}\n\n[Output truncated: ${output.length - maxChars} characters omitted.]`;
+}
+export function parseSession(filePath, agent, opts = {}) {
     const detected = agent || detectAgent(filePath);
     if (!detected) {
         throw new Error(`Cannot detect agent type from path: ${filePath}`);
@@ -166,7 +168,11 @@ export function parseSession(filePath, agent) {
     // from `!`-prefix runs, `<system-reminder>`, etc.) as `_synthetic` so turn
     // slicing and `--include user` count only genuine user intent — one place,
     // every harness, instead of per-consumer regex.
+    const maxToolOutputChars = opts.maxToolOutputChars ?? 500;
     for (const e of events) {
+        if (e.type === 'tool_result' && e.output) {
+            e.output = truncateNormalizedToolOutput(e.output, maxToolOutputChars);
+        }
         sanitizeEvent(e);
         if (e.type === 'message' && e.role === 'user' && isSyntheticUserMessage(e.content)) {
             e._synthetic = true;
@@ -496,7 +502,11 @@ export function parseClaudeContent(content) {
                                 exitCode: structured.exitCode,
                                 statusCode: structured.statusCode,
                                 errorCode: structured.errorCode,
-                                output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                                // Not truncated here: `parseSession` caps every event's `output`
+                                // centrally via `maxToolOutputChars` (default 500, the same
+                                // bound this site used to hardcode), so the render path can ask
+                                // for the full text with `Infinity`.
+                                output,
                             });
                         }
                         if (toolId)
@@ -686,7 +696,7 @@ export function parseCodexContent(content) {
                     exitCode: result.exitCode,
                     statusCode: result.statusCode,
                     errorCode: result.errorCode,
-                    output: result.text.length > 500 ? result.text.slice(0, 497) + '...' : result.text,
+                    output: result.text,
                 });
                 if (callId)
                     callMap.delete(callId);
@@ -741,7 +751,7 @@ export function parseCodexContent(content) {
                     exitCode: result.exitCode,
                     statusCode: result.statusCode,
                     errorCode: result.errorCode,
-                    output: result.text.length > 500 ? result.text.slice(0, 497) + '...' : result.text,
+                    output: result.text,
                 });
                 if (callId)
                     callMap.delete(callId);
@@ -865,7 +875,7 @@ export function parseGemini(filePath) {
                             tool: toolName,
                             callId: typeof tc.id === 'string' ? tc.id : undefined,
                             success: tc.status === 'success',
-                            output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                            output,
                         });
                     }
                 }
@@ -1242,7 +1252,7 @@ export function parseGrok(filePath) {
                 callId,
                 success: structuredError ? false : structuredSuccess ? true : undefined,
                 outcome: structuredError ? 'error' : structuredSuccess ? 'ok' : 'unknown',
-                output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                output: output,
             });
             if (callId)
                 toolCallMap.delete(callId);
@@ -1360,7 +1370,7 @@ export function parseOpenCode(filePath) {
                             tool: toolName,
                             callId,
                             success: state.status === 'completed',
-                            output: outputStr.length > 500 ? outputStr.slice(0, 497) + '...' : outputStr,
+                            output: outputStr,
                         });
                     }
                     break;
@@ -1470,7 +1480,7 @@ export function parseRush(filePath) {
                 tool: info?.tool ?? (typeof raw.name === 'string' ? raw.name : 'unknown'),
                 callId,
                 success,
-                output: outputStr.length > 500 ? outputStr.slice(0, 497) + '...' : outputStr,
+                output: outputStr,
             });
             if (callId)
                 toolCallMap.delete(callId);
@@ -1680,7 +1690,7 @@ export function parseKimi(filePath) {
                     callId,
                     success: structuredError ? false : structuredSuccess ? true : undefined,
                     outcome: structuredError ? 'error' : structuredSuccess ? 'ok' : 'unknown',
-                    output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                    output: output,
                 });
                 if (callId) {
                     toolCallMap.delete(callId);
@@ -1825,7 +1835,7 @@ function parseAnthropicMessageJsonl(filePath, agent) {
                 else {
                     events.push({
                         type: 'tool_result', agent, timestamp, tool: toolInfo?.tool, callId: toolId, success: true,
-                        output: output.length > 500 ? output.slice(0, 497) + '...' : output,
+                        output: output,
                     });
                 }
                 if (toolId)

package/dist/lib/session/prompt.js

@@ -46,6 +46,11 @@ const SYNTHETIC_USER_MESSAGE_PATTERNS = [
     /^\s*<\/?user-prompt-submit-hook>/i,
     /^\s*<\/?persisted-output>/i,
     /^\s*<permissions instructions>/i,
+    /^\s*<(?:apps|plugins|skills)_instructions>/i,
+    /^\s*<(?:multi_agent_mode|environment_context)>/i,
+    /^\s*## (?:In-flight in this repo|Host & Fleet)/i,
+    /^\s*Your current session id is\b/i,
+    /^\s*Linear context skipped:/i,
     /^\s*<collaboration_mode>/i,
     /^\s*Caveat: The messages below were generated by the user while running/i,
     /^\s*\[Request interrupted/i,

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

@@ -108,6 +108,9 @@ export declare function filterEvents(events: SessionEvent[], opts: FilterOptions
  */
 export interface RenderConversationMarkdownOptions {
     redact?: boolean;
+    knownSecrets?: readonly string[];
+    reasoning?: 'omit' | 'fold' | 'include';
+    maxToolOutputChars?: number;
 }
 export declare function renderConversationMarkdown(events: SessionEvent[], opts?: RenderConversationMarkdownOptions): string;
 /**

package/dist/lib/session/render.js

@@ -923,10 +923,23 @@ export function filterEvents(events, opts) {
     const sliced = applyTurnSlice(events, opts);
     return applyRoleFilter(sliced, opts);
 }
+function markdownFence(content, language = '') {
+    const fence = content.includes('```') ? '````' : '```';
+    return `${fence}${language}\n${content}\n${fence}`;
+}
+function truncateToolOutput(content, maxChars) {
+    if (content.length <= maxChars)
+        return content;
+    return `${content.slice(0, maxChars)}\n\n[Output truncated: ${content.length - maxChars} characters omitted.]`;
+}
 export function renderConversationMarkdown(events, opts = {}) {
     const parts = [];
     const shouldRedact = opts.redact !== false;
-    const sanitize = (text) => shouldRedact ? redactSecrets(text) : text;
+    const sanitize = (text) => shouldRedact ? redactSecrets(text, opts.knownSecrets) : text;
+    // Preserve the long-standing `sessions <id> --markdown` full-fidelity default.
+    // The shareable `sessions render` surface passes `omit` explicitly.
+    const reasoning = opts.reasoning ?? 'include';
+    const maxToolOutputChars = opts.maxToolOutputChars ?? 4000;
     for (const event of events) {
         if (event.type === 'message') {
             if (event.role === 'user') {
@@ -937,27 +950,37 @@ export function renderConversationMarkdown(events, opts = {}) {
             }
         }
         else if (event.type === 'thinking') {
-            if (event.content)
-                parts.push(`### Thinking\n\n${sanitize(event.content)}`);
+            if (event.content && reasoning === 'include') {
+                parts.push(`### Reasoning\n\n${sanitize(event.content)}`);
+            }
+            else if (event.content && reasoning === 'fold') {
+                parts.push(`<details>\n<summary>Reasoning</summary>\n\n${sanitize(event.content)}\n\n</details>`);
+            }
         }
         else if (event.type === 'tool_use') {
             const tool = event.tool || 'unknown';
             if (event.command) {
-                parts.push(`### Tool: ${tool}\n\n\`\`\`bash\n${sanitize(event.command)}\n\`\`\``);
+                const args = event.args && Object.keys(event.args).length > 0
+                    ? `\n\nArguments:\n\n${markdownFence(sanitize(JSON.stringify(event.args, null, 2)), 'json')}`
+                    : '';
+                parts.push(`### Tool: ${tool}\n\n${markdownFence(sanitize(event.command), 'bash')}${args}`);
+            }
+            else if (event.args && Object.keys(event.args).length > 0) {
+                parts.push(`### Tool: ${tool}\n\nArguments:\n\n${markdownFence(sanitize(JSON.stringify(event.args, null, 2)), 'json')}`);
             }
             else if (event.path) {
-                parts.push(`### Tool: ${tool}\n\n\`${shortenPathTrace(event.path)}\``);
+                parts.push(`### Tool: ${tool}\n\n\`${sanitize(shortenPathTrace(event.path))}\``);
             }
             else {
                 const summary = summarizeToolUse(tool, event.args);
-                parts.push(`### Tool: ${tool}\n\n${summary}`);
+                parts.push(`### Tool: ${tool}\n\n${sanitize(summary)}`);
             }
         }
         else if (event.type === 'tool_result') {
-            if (event.content) {
-                const truncated = event.content.length > 2000 ? event.content.slice(0, 2000) + '\n…' : event.content;
-                const body = sanitize(truncated);
-                parts.push(`### Tool Result\n\n\`\`\`\n${body}\n\`\`\``);
+            const output = event.content || event.output;
+            if (output) {
+                const body = sanitize(truncateToolOutput(output, maxToolOutputChars));
+                parts.push(`### Tool Result${event.tool ? `: ${event.tool}` : ''}\n\n${markdownFence(body)}`);
             }
         }
         else if (event.type === 'error') {

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

@@ -89,7 +89,16 @@ export const loadFunnel = async () => (await import('../../commands/funnel.js'))
  * inherit the root's custom help formatter rather than getting the per-command
  * recursive pass. Keeping that ordering preserves their `--help` output exactly.
  */
-export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'message', 'serve']);
+// `roster` is an observe-umbrella alias of `sessions --active` — same module,
+// same SQLite stack, same post-help registration order as sessions.
+export const LAZY_COMMAND_NAMES = new Set([
+    'sessions',
+    'roster',
+    'teams',
+    'cloud',
+    'message',
+    'serve',
+]);
 /**
  * User-typed top-level command name -> ordered list of module loaders to run.
  *
@@ -194,12 +203,17 @@ export const COMMAND_LOADERS = {
     setup: [loadSetup],
     uninstall: [loadUninstall],
     sessions: [loadSessions],
+    // Observe-umbrella alias of sessions --active (same lazy module).
+    roster: [loadSessions],
     teams: [loadTeams],
     cloud: [loadCloud],
     message: [loadMessage],
     send: [loadSend],
     notify: [loadSend],
     feed: [loadFeed],
+    // Observe-umbrella aliases of feed / feed --filter updates.
+    inbox: [loadFeed],
+    timeline: [loadFeed],
     mailboxes: [loadMailboxes],
     mailbox: [loadMailboxes],
     serve: [loadServe],

package/dist/lib/usage-refresh.d.ts

@@ -1,16 +1,23 @@
 import { type UsageHeadroom, type UsageSnapshot, type UsageInfo } from './usage.js';
 import type { AgentId } from './types.js';
-/** Floor on the adaptive interval: an account seconds from its cap still isn't
- * polled faster than this. */
+/**
+ * Default schedule between successful (or attempted) live usage fetches for one
+ * account. Floor and ceiling of the delay helper are pinned to this so the
+ * daemon does not poll faster than 5 minutes even under high burn, and does not
+ * let an idle account rot longer than 5 minutes between attempts.
+ */
+export declare const REFRESH_INTERVAL_MS: number;
+/** @deprecated alias — use {@link REFRESH_INTERVAL_MS}. Kept for test imports. */
 export declare const REFRESH_MIN_MS: number;
-/** Ceiling on the adaptive interval: an idle account is still re-checked at
- * least this often so a cache never silently rots. */
+/** @deprecated alias — use {@link REFRESH_INTERVAL_MS}. Kept for test imports. */
 export declare const REFRESH_MAX_MS: number;
-/** Schedule the next refresh at `minutesToLimit / K` — poll well before the cap,
- * not exactly at it. */
+/** Burn-rate divisor retained for the pure delay helper / tests; with min=max
+ * the divisor does not change the scheduled interval. */
 export declare const REFRESH_BURN_DIVISOR = 4;
-/** At most this many live fetches per account per rolling hour. */
-export declare const HOURLY_CALL_CAP = 6;
+/** At most this many live fetches per account per rolling hour (5m cadence ⇒ 12). */
+export declare const HOURLY_CALL_CAP = 12;
+/** How often the daemon wakes to *consider* a refresh pass (due accounts only). */
+export declare const USAGE_REFRESH_TICK_MS: number;
 /**
  * One account's refresh state + published headroom. `sessionUsedPercent` /
  * `capturedAt` are the prior sample the NEXT tick projects the burn rate from;
@@ -38,9 +45,10 @@ export declare function readHeadroomEntry(usageKey: string): HeadroomEntry | nul
 /** Merge entries into the cache (best-effort; preserves other accounts' rows). */
 export declare function writeHeadroomEntries(entries: Record<string, HeadroomEntry>): void;
 /**
- * The adaptive interval until the next refresh, clamped to [MIN, MAX]. A
- * shorter `minutesToLimit` (closer to the cap) polls sooner; `null` (unknown /
- * idle / not burning) waits the full ceiling.
+ * Interval until the next refresh attempt, clamped to [minMs, maxMs].
+ * Defaults pin both ends to {@link REFRESH_INTERVAL_MS} (5 minutes) so the
+ * live daemon path is a fixed schedule. Tests may pass a wider range to
+ * exercise burn-aware scheduling without changing production cadence.
  */
 export declare function computeNextRefreshDelayMs(minutesToLimit: number | null, opts?: {
     minMs?: number;