@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/commands/sessions-share.js

@@ -1,27 +1,29 @@
 /**
  * `agents sessions share <id>` — publish one session transcript as a link.
  *
- * Composes three pieces that already existed but were never wired together:
- * `renderSessionMarkdownDocument()` (redacted transcript),
- * `renderSessionHtmlDocument()` (self-contained branded page), and
- * `publishFile()` (the R2-backed share Worker). Before this, sharing a session
- * meant three commands and a detour through the external artifacts-cli.
+ * Renders the session locally — `renderSessionMarkdownDocument()` (redacted
+ * transcript) and `renderSessionHtmlDocument()` (self-contained branded page) —
+ * then publishes it through the standalone `artifacts` CLI (`artifacts share`),
+ * the single home for artifact sharing since PHNX-3992. agents-cli holds no
+ * share engine of its own; this command contributes the session-specific
+ * rendering and redaction, and forwards the finished page to `artifacts share`.
  *
- * Unlisted by default, unlike `agents artifacts share`. A transcript carries file
- * paths, command output, error text, and whatever a tool printed — strictly more
- * than a plan does — so it does not belong in the public `/<user>` gallery unless
- * the operator asks for it with `--public`. The URL itself stays world-readable:
- * unlisted is a capability URL, not a secret.
+ * Unlisted by default, unlike `artifacts share` (public by default). A transcript
+ * carries file paths, command output, error text, and whatever a tool printed —
+ * strictly more than a plan does — so it does not belong in the public `/<user>`
+ * gallery unless the operator asks for it with `--public`. The URL itself stays
+ * world-readable: unlisted is a capability URL, not a secret.
  */
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { spawnSync } from 'node:child_process';
 import chalk from 'chalk';
 import { setHelpSections } from '../lib/help.js';
-import { knownSecretValuesFromEnv } from '../lib/redact.js';
+import { knownSecretValuesFromEnv, redactEmails } from '../lib/redact.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { renderSessionHtmlDocument } from '../lib/session/share-html.js';
-import { publishFile, redactEmails } from '../lib/share/publish.js';
+import { resolveArtifactsBin, invocation, ArtifactsClientError } from '../lib/artifacts-client.js';
 import { renderSessionMarkdownDocument } from './sessions-render.js';
 import { selectSessions } from './sessions-export.js';
 import { parseAgentFilter } from './sessions.js';
@@ -35,23 +37,33 @@ export function defaultSessionSlug(session) {
     return `session-${session.shortId || session.id}`;
 }
 /**
- * Map the command's flags onto {@link PublishOptions}.
+ * Build the `artifacts share` argv for a session publish.
  *
- * Extracted so the defaults are testable directly. `unlisted` in particular is the
- * security-relevant one — it inverts the parent command's public-by-default
- * behavior, and a test that re-implements this mapping would still pass with it
- * flipped.
+ * Extracted so the mapping is testable directly. The security-relevant default
+ * is `--visibility unlisted` — it inverts `artifacts share`'s public default, and
+ * a test that re-implements this mapping would still pass with it flipped.
  */
-export function buildSharePublishOptions(session, options) {
-    return {
-        slug: options.slug ?? defaultSessionSlug(session),
-        unlisted: options.public !== true,
-        expire: options.expire,
-        force: options.force === true,
-        cover: options.cover !== false,
-        label: options.label,
-        meta: { kind: 'session' },
-    };
+export function buildArtifactsShareArgs(session, options, file) {
+    const args = [
+        'share',
+        file,
+        '--slug',
+        options.slug ?? defaultSessionSlug(session),
+        '--visibility',
+        options.public === true ? 'public' : 'unlisted',
+        '--meta',
+        'kind=session',
+        '--json',
+    ];
+    if (options.expire)
+        args.push('--expire', options.expire);
+    if (options.force === true)
+        args.push('--force');
+    if (options.cover === false)
+        args.push('--no-cover');
+    if (options.label)
+        args.push('--label', options.label);
+    return args;
 }
 export function registerSessionsShareCommand(sessionsCmd) {
     const cmd = sessionsCmd
@@ -59,7 +71,7 @@ export function registerSessionsShareCommand(sessionsCmd) {
         .description('Publish one session as a redacted, self-contained web page and print the link.')
         .option('--public', 'List the page in your public share gallery (default: unlisted capability URL)')
         .option('--slug <slug>', 'URL slug under your namespace (default: session-<shortId>)')
-        .option('--label <text>', 'Display title in the gallery and `agents artifacts share list`')
+        .option('--label <text>', 'Display title in the gallery and `artifacts share list`')
         .option('--expire <spec>', 'Auto-expire window: 30d, 12h, a date, or never (default: 30d)')
         .option('--reasoning <mode>', 'Reasoning visibility: omit, fold, or include', 'omit')
         .option('--force', 'Publish despite the sensitive-content scan flagging the transcript')
@@ -76,22 +88,23 @@ agents sessions share a1b2c3d4 --reasoning fold
 
 # A link that does not decay
 agents sessions share a1b2c3d4 --expire never`,
-        notes: `Requires a share endpoint: 'agents artifacts share status' shows it, 'agents artifacts setup'
-provisions one, 'agents artifacts share join <baseUrl>' uses an existing one.
+        notes: `Publishes through the standalone artifacts CLI — install it with
+'npm i -g @phnx-labs/artifacts-cli'. Sign in with
+'artifacts auth login' for the managed endpoint (zero Cloudflare setup), or configure
+your own bucket with 'artifacts share setup' / 'artifacts share join <baseUrl>'.
 
 Unlisted by default — the URL is world-readable but the page stays out of your public
-gallery and out of 'agents artifacts share list'. Pass --public to list it.
+gallery and out of 'artifacts share list'. Pass --public to list it.
 
-Secrets are redacted and the same pre-publish scan as 'agents artifacts share' runs on the
-page, so a transcript carrying emails or credential-shaped strings is refused
-unless you pass --force. --no-redact (the sessions-level flag) disables redaction
-and is a bad idea for anything you publish.
+Secrets are redacted and 'artifacts share' runs its own pre-publish scan on the page,
+so a transcript carrying emails or credential-shaped strings is refused unless you pass
+--force. --no-redact (the sessions-level flag) disables redaction and is a bad idea for
+anything you publish.
 
 Re-running with the same session updates the same URL and keeps the prior version
-as a revision ('agents artifacts share revisions <slug>').
+as a revision ('artifacts share revisions <slug>').
 
-Manage published sessions with 'agents artifacts share list' and
-'agents artifacts share delete <slug>'.`,
+Manage published sessions with 'artifacts share list' and 'artifacts share delete <slug>'.`,
     });
     cmd.action(async (selector, options, command) => {
         const globals = command.optsWithGlobals();
@@ -125,25 +138,60 @@ Manage published sessions with 'agents artifacts share list' and
         });
         // Emails on top of what the renderer masks. Almost every real transcript
         // carries a few — git author addresses, `gh api user`, a pasted log — and
-        // publishToEndpoint refuses a body containing any (RUSH-2428). Masking them
-        // means the published page genuinely does not carry them; the alternative,
-        // telling people to pass --force, would train everyone to bypass the gate
-        // that also catches real credentials.
+        // `artifacts share` refuses a body containing any (its own scan). Masking
+        // them means the published page genuinely does not carry them; the
+        // alternative, telling people to pass --force, trains everyone to bypass the
+        // gate that also catches real credentials.
         //
         // Applied to the RENDERED PAGE, not the Markdown, so the text that is masked
-        // is exactly the text `scanShareContent` will scan. Markdown escaping stands
+        // is exactly the text the publish scan will see. Markdown escaping stands
         // between the two: `foo\@example.com` hides from the pattern in the Markdown
         // and reappears as a live address once marked drops the backslash.
         const page = renderSessionHtmlDocument(session, markdown, { redacted: redact });
         const html = redact ? redactEmails(page) : page;
-        // A real file on disk is what publishFile() takes, and the OG capturer opens
-        // it in a browser. 0600 + a per-run directory keeps the intermediate off a
-        // world-readable /tmp path while it exists.
+        // A real file on disk is what `artifacts share` takes, and its OG capturer
+        // opens it in a browser. 0600 + a per-run directory keeps the intermediate
+        // off a world-readable /tmp path while it exists.
         const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agents-session-share-'));
         const file = path.join(dir, `${defaultSessionSlug(session)}.html`);
         try {
             fs.writeFileSync(file, html, { mode: 0o600 });
-            const result = await publishFile(file, buildSharePublishOptions(session, options));
+            let bin;
+            try {
+                bin = resolveArtifactsBin();
+            }
+            catch (err) {
+                if (err instanceof ArtifactsClientError) {
+                    process.stderr.write(chalk.red(err.message + '\n'));
+                    process.exitCode = 1;
+                    return;
+                }
+                throw err;
+            }
+            const { command: execCommand, prefix } = invocation(bin);
+            const args = [...prefix, ...buildArtifactsShareArgs(session, options, file)];
+            const proc = spawnSync(execCommand, args, { encoding: 'utf-8' });
+            if (proc.error)
+                throw proc.error;
+            if (proc.status !== 0) {
+                process.stderr.write(proc.stderr || chalk.red(`artifacts share exited ${proc.status ?? 'with no status'}\n`));
+                process.exitCode = proc.status ?? 1;
+                return;
+            }
+            let result;
+            try {
+                result = JSON.parse(proc.stdout);
+            }
+            catch {
+                // A 0 exit with non-JSON stdout (a version-skewed `artifacts` that
+                // printed a banner before the JSON, or one predating `--json` here) must
+                // fail loud with the bytes it actually returned, not an uncaught parse
+                // stack trace — mirroring `secrets-client.ts`'s `parseResponse`.
+                const preview = proc.stdout.trim().slice(0, 200);
+                process.stderr.write(chalk.red(`artifacts share returned a non-JSON response${preview ? `: ${preview}` : ' (empty output)'}\n`));
+                process.exitCode = 1;
+                return;
+            }
             if (globals.json) {
                 process.stdout.write(JSON.stringify({
                     session: session.id,
@@ -154,9 +202,10 @@ Manage published sessions with 'agents artifacts share list' and
                 return;
             }
             process.stdout.write(`${result.url}\n`);
-            const bits = [result.unlisted ? 'unlisted' : 'public', redact ? 'redacted' : chalk.red('NOT redacted')];
+            const visibility = result.visibility ?? (result.unlisted ? 'unlisted' : options.public ? 'public' : 'unlisted');
+            const bits = [visibility, redact ? 'redacted' : chalk.red('NOT redacted')];
             if (result.expiresAt)
-                bits.push(`expires ${result.expiresAt.slice(0, 10)}`);
+                bits.push(`expires ${String(result.expiresAt).slice(0, 10)}`);
             process.stderr.write(chalk.dim(`${bits.join(' · ')}\n`));
         }
         finally {

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)')

package/dist/commands/sessions.d.ts

@@ -226,7 +226,7 @@ export declare function linkCwdCell(s: Pick<SessionMeta, 'cwd' | '_remote'>, lab
  * session from an orphaned one (its terminal died, the agent is still running)
  * without re-implementing the tmux client lookup.
  */
-export interface SessionPickerJsonRow extends SessionMeta {
+interface SessionPickerJsonRow extends SessionMeta {
     state: ActiveSession['status'] | 'inactive';
     resumable: boolean;
     unwatched: boolean;
@@ -267,7 +267,7 @@ export declare function renderActiveRowLines(s: ActiveSession, indent: string, t
  */
 export declare function ownerLabel(s: ActiveSession): string;
 /** Grouped + sorted view of active sessions for the --active renderer. */
-export interface ActiveSessionsLayout {
+interface ActiveSessionsLayout {
     workspaces: Array<{
         /** Internal grouping key — `__cloud__`, `__unknown__`, or the cwd. */
         key: string;
@@ -294,7 +294,7 @@ export interface ActiveSessionsLayout {
  */
 export declare function groupActiveSessions(sessions: ActiveSession[]): ActiveSessionsLayout;
 /** One machine's active sessions, keeping the within-machine workspace layout. */
-export interface MachineGroup {
+interface MachineGroup {
     /** Normalized device id (machineId() form). */
     machine: string;
     /** The machine this command is running on — pinned first and marked. */
@@ -303,7 +303,7 @@ export interface MachineGroup {
     layout: ActiveSessionsLayout;
 }
 /** Active sessions grouped by the machine they run on. */
-export interface MachineGroupedLayout {
+interface MachineGroupedLayout {
     machines: MachineGroup[];
 }
 /**
@@ -356,10 +356,6 @@ export declare function serializeResolvedSessionsJson(sessions: SessionMeta[]):
  * JSON. The fan-out boundary supplies the machine name when an older peer row
  * omitted it. */
 export declare function parseRemoteComputerSessionRows(stdout: string, machine: string): RemoteAgentsJsonParseResult<ComputerRunRow>;
-/** Collect computer history from named peers, or every automatic peer when
- * hosts is omitted. Every peer is forced to JSON and receives the recursion
- * guard through the shared fleet transport. */
-export declare function gatherRemoteComputerSessionRows(hosts?: string[]): Promise<ComputerRunRow[]>;
 /**
  * Whether the local machine's sessions belong in an `--active` view. Local is
  * included by default; an explicit `--device` list scopes the view to
@@ -414,14 +410,6 @@ export type LiveStatusFilter = 'working' | 'idle' | 'waiting' | 'orphaned' | 'cr
 export declare function matchesLiveStatus(session: ActiveSession, status: LiveStatusFilter): boolean;
 /** Resolve convenience flags once. Multiple flags intentionally form a union. */
 export declare function requestedLiveStatuses(options: SessionsOptions): LiveStatusFilter[];
-/**
- * A bare interactive fleet listing — no query, no render/filter flag — that the
- * `runSessionBrowser` picker can represent. The single predicate shared by the
- * bare-browser branch and the `--device` early-return guard so they can't drift:
- * when this holds, an explicit `--device` scope is folded into the
- * browser (preview-rich, selectable) instead of the legacy per-host raw stream.
- */
-export declare function isBareBrowserListing(options: SessionsOptions, query: string | undefined): boolean;
 /**
  * Pure flag-gate half of {@link isBareBrowserListing} (TTY-independent, so it is
  * unit-testable): true when no query, render, or filter flag is present that the
@@ -435,7 +423,7 @@ export interface RoutineRunGroup {
     timestamp: string;
     sessions: SessionMeta[];
 }
-export interface RoutineChoice {
+interface RoutineChoice {
     name: string;
     lastRunAt: string;
     runCount: number;
@@ -443,23 +431,9 @@ export interface RoutineChoice {
 }
 export declare function buildRoutineRunGroups(sessions: SessionMeta[]): RoutineRunGroup[];
 export declare function buildRoutineChoices(sessions: SessionMeta[], runOnlyNames?: string[]): RoutineChoice[];
-/**
- * Resolve which routine the user is targeting for `--routine`. Returns `null` to
- * ABORT the command (a bad `--routine <name>` printed an error, or the user
- * cancelled the interactive pick). `{ name: null }` means "no routine was
- * selected, don't filter" — the degenerate bare `--routine` piped to a
- * non-interactive sink. `{ name }` is a chosen routine.
- *
- * The name universe is transcripts UNION every routine with a definition or a
- * run record (`safeListJobsWithRuns`), so a command-only or never-ran routine —
- * which produces no `SessionMeta` — still resolves and drills down.
- */
-export declare function selectRoutineTarget(sessions: SessionMeta[], routine: boolean | string, interactive: boolean): Promise<{
-    name: string | null;
-} | null>;
 export declare function filterSessionsByRoutine(sessions: SessionMeta[], routine: boolean | string, interactive: boolean): Promise<SessionMeta[] | null>;
 /** How a run executed — decides whether an agent session is even expected. */
-export type RoutineExecutionKind = 'agent' | 'command' | 'workflow';
+type RoutineExecutionKind = 'agent' | 'command' | 'workflow';
 export declare function executionKind(meta: RunMeta): RoutineExecutionKind;
 /** One canonical run record plus the indexed sessions linked to it by run id. */
 export interface RoutineRunEntry {
@@ -482,11 +456,6 @@ export interface RoutineDrilldown {
      *  routine. False for a pure command routine, where no session is expected. */
     isAgentRoutine: boolean;
 }
-/**
- * Reconcile a routine's canonical run records (`listRuns`, local disk) with the
- * indexed sessions for that routine (fleet-wide, keyed by `routineRunId`).
- */
-export declare function buildRoutineDrilldown(name: string, sessions: SessionMeta[]): RoutineDrilldown;
 /**
  * Render the routine drilldown: canonical run history first, each run linked to
  * its indexed agent session(s). This is the run/session seam made visible — a
@@ -522,10 +491,7 @@ export declare function mergeToolSearchEnvelopes(local: ToolSearchEnvelope, remo
 export declare function mergeToolProgramCountEnvelopes(local: ToolProgramCountEnvelope, remotes: ToolProgramCountEnvelope[]): ToolProgramCountEnvelope;
 /** Partition a fleet query by transcript origin so synced mirrors cannot duplicate results. */
 export declare function toolOriginSessions(sessions: SessionMeta[], machine: string, originOnly: boolean): SessionMeta[];
-export declare function printToolProgramCount(envelope: ToolProgramCountEnvelope): void;
 export declare function toolSearchFleetSortError(sort: string | undefined, spansDevices: boolean): string | undefined;
-/** Compact grouped evidence for humans; JSON retains every bounded field. */
-export declare function printToolSearch(envelope: ToolSearchEnvelope): void;
 /**
  * Whether a session belongs to `team`, from either end: it spawned the team, or
  * it is one of the team's teammates. Case-insensitive, matching the SQL
@@ -571,7 +537,7 @@ export declare function maybeLiveIndex(options: SessionsOptions): Promise<Map<st
  * machine cannot see still folds by basename through the same resolver.
  */
 export declare function overviewProjectKey(s: Pick<SessionMeta, 'project' | 'cwd'>, defs?: ProjectDef[]): string;
-export interface OverviewGroup {
+interface OverviewGroup {
     key: string;
     total: number;
     shown: SessionMeta[];
@@ -685,18 +651,7 @@ export declare function pickSessionInteractive(sessions: SessionMeta[], message?
  * pick handler checks before trying to read or resume one.
  */
 export declare const LIVE_ROW_PREFIX = "live:";
-export declare function isIdlessLiveRow(s: SessionMeta): boolean;
 export declare function handlePickedSession(picked: PickedSession): Promise<void>;
-/**
- * Resume `session` on the machine that owns it, when that is not this one.
- * Returns true when it handled the resume (hopped, or reported an unreachable
- * owner), false when the session is local and the caller should take over here.
- *
- * The one hop for a foreground, one-session-at-a-time resume — shared by the
- * `agents sessions` picker and by `sessions resume`'s no-tab-backend path, which
- * would otherwise reach `resumeSessionInPlace` and be refused (RUSH-2022).
- */
-export declare function resumeOnOwnerIfRemote(session: SessionMeta): Promise<boolean>;
 /**
  * Resume a session in the current terminal — a foreground takeover of this
  * process. Used by the single-select picker and by `sessions resume` when the
@@ -742,7 +697,7 @@ export declare function parseAgentFilter(agentName?: string): AgentFilter;
  * listing pool (cwd-scoped, default-capped) that PHNX-2767 hydrates past:
  * these flags MUST still exclude FTS hits after that union.
  */
-export type SessionSearchScope = {
+type SessionSearchScope = {
     agent?: string;
     project?: string;
     routine?: boolean | string;
@@ -755,7 +710,7 @@ export type SessionSearchScope = {
  * the query was a whole session id: it is unique by construction, so a miss is
  * final and must NOT widen into a text/content search.
  */
-export interface SessionQueryResolution {
+interface SessionQueryResolution {
     matches: SessionMeta[];
     byId: boolean;
     completeId: boolean;
@@ -791,23 +746,9 @@ export declare function filterSessionsByQuery(sessions: SessionMeta[], query: st
  */
 export declare function applyScopeFilters(sessions: SessionMeta[], scope: SessionSearchScope): SessionMeta[];
 export declare function artifactLookupScope(agent?: string, project?: string, routine?: boolean | string): SessionSearchScope;
-/**
- * Whether a missed local id lookup should widen to a cross-machine sweep.
- *
- * Gate (all must hold):
- *   - the query is id-shaped (`looksLikeSessionId`) — only an identifier resolves
- *     across the fleet; a search phrase never does.
- *   - not `--local` — the caller opted out of cross-machine lookup (deterministic
- *     local behavior for scripts, RUSH-2024 acceptance: "--local still restricts").
- *   - `AGENTS_SESSIONS_LOCAL` is unset — we are not ourselves a peer answering a
- *     parent's sweep, so a locate can never recurse (RUSH-2024: avoid double-fan-out).
- *
- * Pure + exported so the gate is unit-tested without driving discovery / SSH.
- */
-export declare function shouldFanOutForId(query: string, local: boolean | undefined): boolean;
 /** Injectable SSH/peer boundary so the fleet-resolve logic is unit-testable
  * without a live tailnet. Production wires these to the real remote-list infra. */
-export interface FleetResolveDeps {
+interface FleetResolveDeps {
     gatherRemoteList: typeof gatherRemoteList;
     runOnPeer: typeof runOnPeer;
 }
@@ -817,11 +758,11 @@ interface FleetHit {
     session: SessionMeta;
 }
 /** One logical session returned by the fleet, including every machine holding a copy. */
-export interface FleetSessionCandidate {
+interface FleetSessionCandidate {
     id: string;
     hits: FleetHit[];
 }
-export type MetadataResolveOutcome = {
+type MetadataResolveOutcome = {
     kind: 'resolved';
     session: SessionMeta;
 } | {
@@ -943,7 +884,7 @@ export declare function isLocallyDefinitiveMatch(session: SessionMeta, self: str
 export declare function preferOwnerAttribution(localMatches: SessionMeta[], remoteSessions: SessionMeta[], self: string): SessionMeta[];
 /** Injectable dependencies for the live-registry cold-miss fallback (RUSH-2682)
  * and the fleet-attribution reconciliation (PHNX-3890). */
-export type LiveMetadataDeps = {
+type LiveMetadataDeps = {
     loadActive?: typeof loadLocalActiveSessions;
     /** The fleet-active snapshot rows used to attribute a self-defaulted launcher
      * shim to its true execution host. Defaults to the cached fleet snapshot; the
@@ -1003,37 +944,5 @@ export declare function resolveSessionMetadata(selector: string, scope: {
     local?: boolean;
     hosts?: string[];
 }, deps?: Pick<FleetResolveDeps, 'gatherRemoteList'> & LiveMetadataDeps): Promise<void>;
-/**
- * Locate a full session id or short id prefix across the online fleet and render it from the machine
- * that holds it. The local disk already missed; this fans `sessions <id> --json
- * --all` out to every registered online peer (or the explicit `hosts` set),
- * groups the rows to distinct machines, then:
- *
- *   - exactly one logical session → delegate rendering to one peer via `runOnPeer`
- *     (its transcript and agent binary live there — a local `--device` hop would
- *     re-discover locally and dead-end), returning `'rendered'`.
- *   - more than one logical session → print every full-id candidate with its
- *     machine labels, returning `{ kind: 'conflict' }`.
- *   - none                 → `{ kind: 'not-found', deviceCount, unreachable }`,
- *     letting the caller print an honest sweep-aware message.
- *
- * A full-UUID query opts into early-exit: the first peer holding it resolves the
- * sweep and cancels the rest, so a fast peer is not bounded by the slowest one.
- * A short-id prefix stays all-settle — its ambiguity is only known once every
- * peer has answered, so it must wait to surface a conflict.
- *
- * No fuzzy/content fallback: the sweep forwards the id selector and every result
- * is resolved through `resolveSessionQuery`, the same id-only resolver used locally.
- */
-export type FleetResolveResult = {
-    kind: 'rendered';
-} | {
-    kind: 'conflict';
-} | {
-    kind: 'not-found';
-    deviceCount: number;
-    unreachable: string[];
-};
-export declare function resolveSessionAcrossFleet(query: string, mode: ViewMode, hosts?: string[], deps?: FleetResolveDeps): Promise<FleetResolveResult>;
 /** Register the `agents sessions` command with all its options and help text. */
 export declare function registerSessionsCommands(program: Command): void;