@phnx-labs/agents-cli 1.22.113 → 1.22.114

package/dist/commands/routines.d.ts

@@ -8,7 +8,6 @@
 import type { Command } from 'commander';
 export { buildRoutineListJson } from '../lib/scheduling/routines.js';
 import type { JobConfig, RunMeta } from '../lib/scheduling/routines.js';
-import type { DeviceRegistry } from '../lib/devices/registry.js';
 /**
  * Human-friendly wall-clock a run took (e.g. "  · 3 min", "  · 45 sec"), or ""
  * when it hasn't completed or timestamps are unparseable. Leading separator lets
@@ -27,7 +26,7 @@ export declare function formatRunDuration(startedAt: string, completedAt: string
  * history stays readable via `agents routines runs <name>`, and the owning
  * device's status via `agents routines list --device <name>`.
  */
-export interface RoutineListGroup {
+interface RoutineListGroup {
     key: string;
     title: string;
     jobs: JobConfig[];
@@ -38,7 +37,6 @@ export interface RoutineListGroup {
      */
     local: boolean;
 }
-export declare function groupRoutineJobsByDevice(jobs: JobConfig[], registry: DeviceRegistry, self?: string): RoutineListGroup[];
 /**
  * Group routines by their `projects` metadata field.
  * Named projects come first (alphabetically), followed by All projects, Cross-project,

package/dist/commands/routines.js

@@ -116,7 +116,7 @@ function deviceLabel(job, width) {
         : raw;
     return { raw, display, dim: full.length === 0 || !jobRunsOnThisDevice(job) };
 }
-export function groupRoutineJobsByDevice(jobs, registry, self = machineId()) {
+function groupRoutineJobsByDevice(jobs, registry, self = machineId()) {
     const groups = new Map();
     const add = (key, title, job) => {
         const existing = groups.get(key);

package/dist/commands/run-account-picker.d.ts

@@ -1,6 +1,6 @@
 import type { AgentId } from '../lib/types.js';
 import { type RotateCandidate } from '../lib/accounting/rotate.js';
-export interface RunAccountChoice {
+interface RunAccountChoice {
     name: string;
     value: string;
     disabled?: string;
@@ -93,3 +93,4 @@ export declare function noVerifiedUsageDecision(input: {
 export declare function pickSignInLaunchVersion(agent: AgentId, recoverable: RotateCandidate[], quiet?: boolean): Promise<string | null>;
 /** Prompt for one safe installed account/version. A cancelled picker launches nothing. */
 export declare function pickRunAccountCandidate(agent: AgentId): Promise<RotateCandidate | null>;
+export {};

package/dist/commands/run-broadcast.d.ts

@@ -4,7 +4,7 @@
  *
  * Task definitions live under cli/bench/tasks/<id>/task.json.
  */
-export interface BroadcastOpts {
+interface BroadcastOpts {
     listTasks?: boolean;
     results?: string | true;
     task?: string;
@@ -19,3 +19,4 @@ export interface BroadcastOpts {
 }
 /** Handle --broadcast / --list-tasks / --results on `agents run`. Always completes the path. */
 export declare function handleBroadcast(opts: BroadcastOpts): Promise<void>;
+export {};

package/dist/commands/run-device-picker.d.ts

@@ -15,7 +15,7 @@ export interface RunDeviceRow {
     lastSeenAt?: string;
     hasAccount?: boolean;
 }
-export interface RunDeviceChoice {
+interface RunDeviceChoice {
     name: string;
     value: string;
     disabled?: boolean | string;
@@ -56,3 +56,4 @@ export declare function pickRunDevice(opts: {
     agent: AgentId;
     accountLabel?: string;
 }): Promise<string | null>;
+export {};

package/dist/commands/secrets-passthrough.d.ts

@@ -15,6 +15,20 @@
  * retired in-repo engine (`commands/secrets.ts` and its siblings), which stays
  * in the tree, unregistered, until every consumer has moved off it (tasks.md
  * item 7).
+ *
+ * `secrets` is listed in {@link import('../lib/hosts/passthrough.js').OWN_HOST_COMMANDS}
+ * so `--device` never routes through the generic SSH passthrough — the engine
+ * has no fleet registry of its own (PHNX-4090), so a `--device <name>` here is
+ * rewritten to `--host ssh://user@host` before exec, exactly like
+ * `agents computer`'s equivalent rewrite. An explicit `--host` on the command
+ * line is left untouched.
  */
 import type { Command } from 'commander';
+/**
+ * Rewrite a `--device <name>` (or `-D`) on the forwarded argv to
+ * `--host ssh://user@host`, the address grammar `secrets` speaks (PHNX-4090).
+ * A `--host` the caller already typed wins — `--device` is left in place so
+ * the standalone binary reports the same "both given" ambiguity it always has.
+ */
+export declare function rewriteDeviceToHost(argv: string[]): Promise<string[]>;
 export declare function registerSecretsCommands(program: Command): void;

package/dist/commands/secrets-passthrough.js

@@ -1,7 +1,26 @@
 import chalk from 'chalk';
 import { spawnSync } from 'node:child_process';
 import { buildServeEnv, invocation, resolveSecretsBin, SecretsClientError } from '../lib/secrets-client.js';
+import { flagValue } from '../lib/hosts/routing-flag.js';
+import { stripRoutingFlags } from '../lib/hosts/remote-cmd.js';
+import { resolveRemoteDevice } from '../lib/ssh-tunnel.js';
 const INSTALL_HINT = 'npm i -g @phnx-labs/secrets-cli';
+/**
+ * Rewrite a `--device <name>` (or `-D`) on the forwarded argv to
+ * `--host ssh://user@host`, the address grammar `secrets` speaks (PHNX-4090).
+ * A `--host` the caller already typed wins — `--device` is left in place so
+ * the standalone binary reports the same "both given" ambiguity it always has.
+ */
+export async function rewriteDeviceToHost(argv) {
+    if (flagValue(argv, 'host', 'H') !== undefined)
+        return argv;
+    const device = flagValue(argv, 'device', 'D');
+    if (device === undefined)
+        return argv;
+    const resolved = await resolveRemoteDevice(device, {});
+    const stripped = stripRoutingFlags(argv, [{ long: 'device', short: 'D', takesValue: true }]);
+    return [...stripped, '--host', `ssh://${resolved.target}`];
+}
 export function registerSecretsCommands(program) {
     program
         .command('secrets')
@@ -11,7 +30,7 @@ export function registerSecretsCommands(program) {
         // Hand `-h`/`--help` through too — the real subcommand help lives in the
         // installed `secrets` binary, not in this passthrough.
         .helpOption(false)
-        .action(() => {
+        .action(async () => {
         let bin;
         try {
             bin = resolveSecretsBin();
@@ -28,7 +47,7 @@ export function registerSecretsCommands(program) {
         // Everything after the literal `secrets` token on the real argv — the
         // subcommand + its own flags, verbatim, never re-parsed by commander.
         const secretsIndex = process.argv.indexOf('secrets');
-        const forwarded = secretsIndex >= 0 ? process.argv.slice(secretsIndex + 1) : [];
+        const forwarded = await rewriteDeviceToHost(secretsIndex >= 0 ? process.argv.slice(secretsIndex + 1) : []);
         const { command, prefix } = invocation(bin);
         const res = spawnSync(command, [...prefix, ...forwarded], {
             stdio: 'inherit',

package/dist/commands/sessions-backfill.d.ts

@@ -1,13 +1,13 @@
 import type { Command } from 'commander';
 import { type ToolIndexCoverage } from '../lib/session/tool-index.js';
 import { type SessionTitleRunner } from '../lib/session/title.js';
-export interface ToolBackfillMachineResult {
+interface ToolBackfillMachineResult {
     machine: string;
     indexedFiles: number;
     indexedCalls: number;
     coverage: ToolIndexCoverage;
 }
-export interface ToolBackfillEnvelope {
+interface ToolBackfillEnvelope {
     schemaVersion: 1;
     kind: 'tools-backfill';
     generatedAt: string;
@@ -29,39 +29,6 @@ interface ToolBackfillOptions {
 }
 export declare function backfillToolsLocal(options: ToolBackfillOptions, oneBatch?: boolean): Promise<ToolBackfillMachineResult>;
 export declare function runToolsBackfill(options: ToolBackfillOptions): Promise<ToolBackfillEnvelope>;
-interface ResourceBackfillOptions {
-    agent?: string;
-    project?: string;
-    since?: string;
-    until?: string;
-    teams?: boolean;
-    json?: boolean;
-}
-export interface ResourceBackfillEnvelope {
-    schemaVersion: 1;
-    kind: 'resources-backfill';
-    generatedAt: string;
-    machine: string;
-    /** Sessions considered (matched the filter, had a real transcript). */
-    scanned: number;
-    /** Sessions (re)parsed and written this run. */
-    updated: number;
-    /** Sessions already current at this extractor version, skipped. */
-    skipped: number;
-    /** Sessions whose transcript could not be stat'd or parsed. */
-    failed: number;
-    /** Total session_resource_usage rows written across updated sessions. */
-    resourceRows: number;
-}
-/**
- * Populate session_resource_usage for historical sessions on THIS machine.
- * Local-only by design: the resource signal is derived from each machine's own
- * transcripts, and the index is machine-local, so there is no cross-machine
- * merge to do — run it on each box (or over `agents ssh`). Ensures the session
- * index is complete first (discoverSessions), then re-derives usage gated by the
- * resource_scan_ledger so reruns skip completed transcripts.
- */
-export declare function runResourceBackfill(options: ResourceBackfillOptions): Promise<ResourceBackfillEnvelope>;
 interface TitleBackfillOptions {
     session?: string;
     limit?: string;

package/dist/commands/sessions-backfill.js

@@ -148,7 +148,7 @@ export async function runToolsBackfill(options) {
  * index is complete first (discoverSessions), then re-derives usage gated by the
  * resource_scan_ledger so reruns skip completed transcripts.
  */
-export async function runResourceBackfill(options) {
+async function runResourceBackfill(options) {
     const { agent, version } = parseAgent(options.agent);
     // Make sure every matching transcript is indexed before we re-derive usage.
     await discoverSessions({

package/dist/commands/sessions-bookmark.d.ts

@@ -7,14 +7,4 @@
  * UI. Both write the one store in `lib/session/bookmarks.ts`.
  */
 import type { Command } from 'commander';
-/**
- * Resolve one user-typed id (usually the 8-char short id the listing prints) to
- * a full session id. Ambiguity is an ERROR, not a silent first-match: bookmarking
- * the wrong session is invisible until the user wonders where their bookmark went.
- */
-export declare function resolveBookmarkTarget(idQuery: string): {
-    id: string;
-} | {
-    error: string;
-};
 export declare function registerSessionsBookmarkCommand(sessionsCmd: Command): void;

package/dist/commands/sessions-bookmark.js

@@ -16,7 +16,7 @@ import { isBookmarked, listBookmarks, setBookmark } from '../lib/session/bookmar
  * a full session id. Ambiguity is an ERROR, not a silent first-match: bookmarking
  * the wrong session is invisible until the user wonders where their bookmark went.
  */
-export function resolveBookmarkTarget(idQuery) {
+function resolveBookmarkTarget(idQuery) {
     const matches = findSessionsById(idQuery);
     // A COMPLETE id needs no index entry: the id is the key the store is built on,
     // and requiring a transcript row would refuse exactly the newest sessions — a

package/dist/commands/sessions-inject.d.ts

@@ -6,18 +6,17 @@
  *
  * Resolution: find the active session by id, then resolve its exact split through
  * the SAME canonical resolver the watchdog uses — `resolveInjectTargetForSession`
- * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium > pty. Sharing one
+ * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium. Sharing one
  * resolver keeps the manual unblock path and the watchdog in agreement on which
  * sessions are addressable (a prior duplicate resolver read only `provenance.reply`
  * and could not address a VSCodium/Cursor terminal the watchdog handled fine).
- * `--pane`/`--pty` target a backend directly when the handle is already known.
+ * `--pane` targets a backend directly when the handle is already known.
  */
 import type { Command } from 'commander';
 import { type ActiveSession } from '../lib/session/active.js';
 interface InjectOptions {
     pane?: string;
     socket?: string;
-    pty?: string;
     /**
      * The remote device. A single `--device box` arrives here as `['box']` because
      * the parent `sessions` command's variadic `-D, --device <target...>` shadows

package/dist/commands/sessions-inject.js

@@ -6,11 +6,11 @@
  *
  * Resolution: find the active session by id, then resolve its exact split through
  * the SAME canonical resolver the watchdog uses — `resolveInjectTargetForSession`
- * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium > pty. Sharing one
+ * (lib/terminal/resolve.ts), precedence tmux > iterm > vscodium. Sharing one
  * resolver keeps the manual unblock path and the watchdog in agreement on which
  * sessions are addressable (a prior duplicate resolver read only `provenance.reply`
  * and could not address a VSCodium/Cursor terminal the watchdog handled fine).
- * `--pane`/`--pty` target a backend directly when the handle is already known.
+ * `--pane` targets a backend directly when the handle is already known.
  */
 import chalk from 'chalk';
 import { getActiveSessions, shortIdFromName } from '../lib/session/active.js';
@@ -69,8 +69,6 @@ export function buildRemoteInjectArgv(sessionId, text, options) {
         argv.push('--combined');
     if (options.socket)
         argv.push('--socket', options.socket);
-    if (options.pty)
-        argv.push('--pty', options.pty);
     if (options.pane)
         argv.push('--pane', options.pane);
     if (options.json)
@@ -148,14 +146,11 @@ async function runInject(sessionId, text, options) {
             console.error(chalk.red(message));
         process.exit(1);
     }
-    // Direct-target shortcuts skip the session lookup — the watchdog often already
-    // holds the pane id or pty session it wants to type into. The pane's exact
-    // address is known, so it composes with --device (tmux send-keys over SSH).
+    // Direct-target shortcut skips the session lookup — the watchdog often already
+    // holds the pane id it wants to type into. The pane's exact address is known,
+    // so it composes with --device (tmux send-keys over SSH).
     let target = null;
-    if (options.pty) {
-        target = { backend: 'pty', id: options.pty };
-    }
-    else if (options.pane) {
+    if (options.pane) {
         target = { backend: 'tmux', pane: options.pane, socket: options.socket };
     }
     else if (device) {
@@ -200,7 +195,6 @@ export function registerSessionsInjectCommand(sessionsCmd) {
         .command('inject <sessionId> <text>')
         .description('Deliver text (+ Enter) into the terminal a running session lives in — nudge a stalled agent.')
         .option('--pane <id>', 'Target a tmux pane id directly (e.g. %3), skipping session lookup')
-        .option('--pty <id>', 'Target an agents-pty session id directly, skipping session lookup')
         .option('--socket <path>', 'tmux socket path (defaults to the session/shared socket)')
         .option('--device <target>', 'Deliver on a remote device over SSH. With a bare session id, the session is resolved ON that device; with --pane, the pane is addressed there directly.')
         .option('--no-enter', 'Send only the text, without a trailing Enter')
@@ -214,9 +208,6 @@ export function registerSessionsInjectCommand(sessionsCmd) {
       # Target a tmux pane directly (what a watchdog already holds)
       agents sessions inject _ "continue" --pane %3 --socket /tmp/agents/tmux.sock
 
-      # Type into an agents-pty session without submitting
-      agents sessions inject _ "ls" --pty $SID --no-enter
-
       # Nudge a live session on another box (resolved on the device)
       agents sessions inject 214edaae "continue" --device yosemite-s0
 
@@ -227,8 +218,8 @@ export function registerSessionsInjectCommand(sessionsCmd) {
       - Ink-TUI Enter semantics: by default the text and Enter are two separate
         writes, which is what Claude's Ink TUI needs. --combined fuses them.
       - A session is addressable by id when it resolves to a precise split —
-        tmux, iTerm, a VSCodium/Cursor/VS Code integrated terminal, or a pty
-        (resolveInjectTargetForSession). Use --pane/--pty for direct targeting.
+        tmux, iTerm, or a VSCodium/Cursor/VS Code integrated terminal
+        (resolveInjectTargetForSession). Use --pane for direct targeting.
       - The id may be the session id (short or full) OR the '<shortid>' suffix of
         a tmux target (ag-<agent>-<shortid>) — the only selector a live tmux
         session whose id column shows '-' exposes.

package/dist/commands/sessions-picker-factory.d.ts

@@ -1,11 +1,11 @@
 /** Flag subset both twins share for the interactive-routing gate. */
-export interface SessionsPickerGateOpts {
+interface SessionsPickerGateOpts {
     interactive?: boolean;
     json?: boolean;
     /** Present only on the browser twin; computer never sets it. */
     open?: string | boolean;
 }
-export interface SessionsPickerCommandSpec<TRow, TOpts extends SessionsPickerGateOpts> {
+interface SessionsPickerCommandSpec<TRow, TOpts extends SessionsPickerGateOpts> {
     /**
      * Browser requires `opts.open === undefined` so `--open` (bare or with a
      * selector) falls through to the flat printer. Computer has no `--open`.
@@ -23,19 +23,9 @@ export interface SessionsPickerCommandSpec<TRow, TOpts extends SessionsPickerGat
     enterHint: string;
     onOpen: (row: TRow) => void | Promise<void>;
 }
-export interface SessionsPickerCommand<TOpts extends SessionsPickerGateOpts> {
+interface SessionsPickerCommand<TOpts extends SessionsPickerGateOpts> {
     shouldOpen: (opts: TOpts, isTTY: boolean) => boolean;
     run: (opts: TOpts) => Promise<void>;
 }
-export declare function shouldOpenInteractiveSessions(opts: SessionsPickerGateOpts, isTTY: boolean, requireOpenUndefined?: boolean): boolean;
-export declare function browseSessionsUntilQuit<TRow>(spec: {
-    message: string;
-    rows: TRow[];
-    matches: (row: TRow, query: string) => boolean;
-    labelFor: (row: TRow) => string;
-    buildPreview: (row: TRow) => string;
-    emptyFilterMessage: string;
-    enterHint: string;
-    onOpen: (row: TRow) => void | Promise<void>;
-}): Promise<void>;
 export declare function createSessionsPickerCommand<TRow, TOpts extends SessionsPickerGateOpts>(spec: SessionsPickerCommandSpec<TRow, TOpts>): SessionsPickerCommand<TOpts>;
+export {};

package/dist/commands/sessions-picker-factory.js

@@ -8,13 +8,13 @@
  */
 import { itemPicker } from '../lib/picker.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-export function shouldOpenInteractiveSessions(opts, isTTY, requireOpenUndefined = false) {
+function shouldOpenInteractiveSessions(opts, isTTY, requireOpenUndefined = false) {
     return (opts.interactive !== false &&
         !opts.json &&
         (!requireOpenUndefined || opts.open === undefined) &&
         isTTY);
 }
-export async function browseSessionsUntilQuit(spec) {
+async function browseSessionsUntilQuit(spec) {
     for (;;) {
         let picked;
         try {

package/dist/commands/sessions-picker.d.ts

@@ -1,6 +1,6 @@
 import type { SessionEvent, SessionMeta, TodoProgress } from '../lib/session/types.js';
 import { fetchPeerPreviewDigest } from '../lib/session/remote-list.js';
-import { classifyFileChanges, changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
+import { changeCounts, toolHistogram, detectTestResult } from '../lib/session/digest.js';
 import type { FileChange } from '../lib/session/digest.js';
 import { extractArtifacts, extractHooks, extractLinks, extractSkills } from '../lib/session/highlights.js';
 /** A session whose transcript FILE is on another machine: its `filePath` is on
@@ -33,7 +33,7 @@ export interface PickedSession {
     session: SessionMeta;
     action: 'resume' | 'view';
 }
-export interface SessionPickerConfig {
+interface SessionPickerConfig {
     message: string;
     /** Dim hint line shown under the header (filters/flags tip). */
     subtitle?: string;
@@ -156,15 +156,9 @@ export interface SessionPreviewDigest {
 }
 /** Fold a harness-normalized event stream into the stable preview data model. */
 export declare function buildSessionPreviewDigest(events: SessionEvent[], session: SessionMeta): SessionPreviewDigest;
-/**
- * Unique directories the session touched, compact and human-readable.
- * Prefer `session.recentDirectoriesTouched` — the scan records it on the row, so
- * it is present for remote rows whose transcript we can't parse here — otherwise
- * derive from the file-change + tool paths already available.
- */
-export declare function directoriesTouched(session: SessionMeta, events: SessionEvent[], changes: ReturnType<typeof classifyFileChanges>): string[];
 /** Relativize a file path to its parent dir, short enough for one preview line. */
 export declare function relativizeDir(filePath: string, cwd?: string): string | undefined;
 export declare function renderLastResponse(content: string, maxLines?: number, width?: number): string[];
 /** Show an interactive session picker and return the selected session with its action (resume or view). */
 export declare function sessionPicker(config: SessionPickerConfig): Promise<PickedSession | null>;
+export {};

package/dist/commands/sessions-picker.js

@@ -417,7 +417,7 @@ export function buildPreview(session) {
     }
     // No transcript on disk — either an archived session (file gone, user turns
     // still in the DB — RUSH-2436), a live session not indexed locally, or a
-    // synthesized entry (e.g. `sessions go`). Show the header + a clean note.
+    // synthesized entry (an attach-only resume). Show the header + a clean note.
     if (!session.filePath || !fs.existsSync(session.filePath)) {
         const archivedContent = readSessionContent(session.id);
         if (archivedContent && archivedContent.trim() !== '') {
@@ -965,7 +965,7 @@ function classifySessionTool(tool, command) {
  * it is present for remote rows whose transcript we can't parse here — otherwise
  * derive from the file-change + tool paths already available.
  */
-export function directoriesTouched(session, events, changes) {
+function directoriesTouched(session, events, changes) {
     const fromMeta = session.recentDirectoriesTouched;
     if (Array.isArray(fromMeta) && fromMeta.length > 0) {
         // The scan stores ABSOLUTE paths, so they go through the same relativizer the

package/dist/commands/sessions-resume.d.ts

@@ -4,7 +4,7 @@ import { type Backend, type SurfaceItem, type EngineContext, type Packing } from
 import { type StrictResumeOptions } from './resume.js';
 /** Opening more than this many live sessions at once asks for confirmation first. */
 export declare const CONFIRM_THRESHOLD = 5;
-export interface ResumeOptions extends StrictResumeOptions {
+interface ResumeOptions extends StrictResumeOptions {
     agent?: string;
     all?: boolean;
     teams?: boolean;
@@ -32,9 +32,6 @@ export declare function buildSelectedResumeArgs(id: string, prompt: string | und
 /** IDs and tmux aliases are actions, not picker search text. Human phrases keep
  * the existing pre-filtered picker, while an explicit identity resumes directly. */
 export declare function isDirectResumeSelector(query: string): boolean;
-/** Re-enter through sessions resume so fleet routing and harness policy
- * stay centralized. The child inherits this terminal for a real interactive resume. */
-export declare function resumeSelectorInPlace(selector: string): Promise<void>;
 /**
  * Local preflight cannot inspect a peer's files or index. Leave peer validation
  * to the existing origin-device recovery hop. --here without a remote surface
@@ -64,3 +61,4 @@ export declare function resumeHostMismatch(session: Pick<SessionMeta, 'shortId'
  * user dismissed the chooser).
  */
 export declare function resolveBackend(options: ResumeOptions, ctx: EngineContext, count: number): Promise<Backend | 'inplace' | 'cancel'>;
+export {};

package/dist/commands/sessions-resume.js

@@ -394,11 +394,6 @@ export function isDirectResumeSelector(query) {
     const selector = query.trim();
     return looksLikeSessionId(selector) || isAgentTmuxAlias(selector);
 }
-/** Re-enter through sessions resume so fleet routing and harness policy
- * stay centralized. The child inherits this terminal for a real interactive resume. */
-export async function resumeSelectorInPlace(selector) {
-    await spawnCliInPlace(['sessions', 'resume', selector]);
-}
 /**
  * Local preflight cannot inspect a peer's files or index. Leave peer validation
  * to the existing origin-device recovery hop. --here without a remote surface

package/dist/commands/sessions-stats.d.ts

@@ -17,7 +17,7 @@
  */
 import type { Command } from 'commander';
 /** One installed resource, keyed the same way session_resource_usage stores it. */
-export interface InstalledResource {
+interface InstalledResource {
     kind: 'skill' | 'command';
     name: string;
     plugin: string | null;
@@ -34,3 +34,4 @@ export declare function diffZeroInvoked(installed: InstalledResource[], invoked:
     name: string;
 }>): InstalledResource[];
 export declare function registerSessionsStatsCommand(sessionsCmd: Command): void;
+export {};

package/dist/commands/sessions-stop.d.ts

@@ -19,6 +19,3 @@
  */
 import type { Command } from 'commander';
 export declare function registerSessionsStopCommand(program: Command): void;
-export declare function stopSessionAction(id: string, opts?: {
-    local?: boolean;
-}): Promise<void>;

package/dist/commands/sessions-stop.js

@@ -31,7 +31,7 @@ export function registerSessionsStopCommand(program) {
     `,
     });
 }
-export async function stopSessionAction(id, opts = {}) {
+async function stopSessionAction(id, opts = {}) {
     const { self, activeById } = await gatherLiveTargets(!!opts.local, { includeCloud: true, selector: id });
     const resolved = resolveOne(activeById, id);
     if ('error' in resolved) {

package/dist/commands/sessions-tail.d.ts

@@ -2,7 +2,7 @@ import type { Command } from 'commander';
 import type { SessionMeta, SessionAgentId } from '../lib/session/types.js';
 /** Whether a session's transcript can be live-tailed (append-only JSONL agents). */
 export declare function isTailable(agent: SessionAgentId): boolean;
-export interface TailFileOptions {
+interface TailFileOptions {
     /** If true, emit every line from byte 0 first, then follow. Default false (EOF). */
     fromStart?: boolean;
 }
@@ -28,3 +28,4 @@ export declare function streamSessionTail(session: SessionMeta, options?: {
 }): Promise<void>;
 /** Attach the `tail` subcommand to an existing `sessions` command. */
 export declare function registerSessionsTailCommand(sessionsCmd: Command): void;
+export {};

package/dist/commands/sessions-trace.d.ts

@@ -7,7 +7,7 @@ import type { LineageEdge, LineageNode, SessionLineage } from '../lib/session/tr
 /** Versioned envelope emitted by `--json` — the stable contract for consumers. */
 export declare const SESSIONS_TRACE_SCHEMA_VERSION = 1;
 /** The `diff` block of a `layout: 'compare'` envelope — everything but the two full trajectories, which already ride `sessions`. */
-export interface SessionsTraceDiffEnvelope {
+interface SessionsTraceDiffEnvelope {
     divergence?: TrajectoryDivergence;
     added: TrajectoryStep[];
     removed: TrajectoryStep[];
@@ -17,7 +17,7 @@ export interface SessionsTraceDiffEnvelope {
     truncatedB: number;
 }
 /** The `lineage` block of a `layout: 'lineage'` envelope — the delegation graph. */
-export interface SessionsTraceLineageEnvelope {
+interface SessionsTraceLineageEnvelope {
     rootId: string;
     nodes: LineageNode[];
     edges: LineageEdge[];
@@ -25,7 +25,7 @@ export interface SessionsTraceLineageEnvelope {
     unresolvedParentIds: string[];
 }
 /** The `--json` envelope: the versioned contract for the ext / triaging agents. */
-export interface SessionsTraceEnvelope {
+interface SessionsTraceEnvelope {
     schemaVersion: typeof SESSIONS_TRACE_SCHEMA_VERSION;
     kind: 'sessions-trace';
     layout: 'single' | 'compare' | 'lineage';
@@ -60,7 +60,7 @@ interface TraceOptions {
     compare?: boolean;
     tree?: boolean;
 }
-export type RenderFormat = 'html' | 'text' | 'json';
+type RenderFormat = 'html' | 'text' | 'json';
 /**
  * Pick the rendering by audience: explicit `--html/--text/--json` win; otherwise
  * a person at a TTY gets the visual HTML and a piped/headless caller (an agent)
@@ -84,8 +84,6 @@ export declare function renderSessionSteps(session: SessionMeta, options?: {
     redact?: boolean;
     knownSecrets?: readonly string[];
 }): string;
-/** Attach the trace behaviour to a command node (canonical or top-level alias). */
-export declare function configureTraceCommand(cmd: Command): Command;
 /** Canonical `agents sessions trace <selectors...>`. */
 export declare function registerSessionsTraceCommand(sessionsCmd: Command): void;
 /** Top-level alias `agents trace <selectors...>` (mirrors `agents insights`). */

package/dist/commands/sessions-trace.js

@@ -184,7 +184,7 @@ export function renderSessionSteps(session, options = {}) {
     return `${lines.join('\n')}\n\n${footer}\n`;
 }
 /** Attach the trace behaviour to a command node (canonical or top-level alias). */
-export function configureTraceCommand(cmd) {
+function configureTraceCommand(cmd) {
     cmd
         .description('Visualize a session as a trajectory — a tool-call timeline you can read at a glance. Opens a visual for a person; prints a compact trajectory for an agent.')
         .option('--html', 'Force the HTML rendering (opens in a browser)')