@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/commands/go.d.ts

@@ -1,52 +1,13 @@
 import { type ActiveSession } from '../lib/session/active.js';
-import type { SessionMeta } from '../lib/session/types.js';
-import { type LiveStatusFilter } from './sessions.js';
-/**
- * Scope a live-session pool by device and live status. Pure so the `focus`
- * device/status filters are unit-testable without touching the sweep. `hosts`
- * keeps only sessions whose `machine` is in the set (local rows carry `self`,
- * remote rows carry their peer tag); `statuses` reuses `--active`'s exact
- * `matchesLiveStatus` derivation rather than a parallel status table.
- */
+import type { SessionMeta } from '@phnx-labs/sessions-cli/reader';
+import { type LiveStatusFilter } from './ps-roster.js';
 export declare function filterLivePool(sessions: ActiveSession[], opts?: {
     hosts?: string[];
     statuses?: LiveStatusFilter[];
 }): ActiveSession[];
-/**
- * Live rows whose session id starts with `selector` (case-insensitive prefix).
- * Same match `resolveOne` uses, so skip-fleet and resolve stay aligned.
- */
 export declare function localLiveSelectorMatches(sessions: ActiveSession[], selector: string): ActiveSession[];
-/**
- * Skip `gatherRemoteActive` when local already answered the selector:
- * two local matches fail closed without waiting for a sleeping peer that
- * might collide; a single local hit skips only when the selector is a full
- * UUID or unique-enough 8-hex (`isUniqueEnoughSelector`). A shorter unique
- * local prefix still races the fleet so a remote collision can fail closed.
- * Zero matches still race the fleet.
- */
 export declare function shouldSkipRemoteSweep(localMatches: ActiveSession[], selector: string): boolean;
-/**
- * First-hit abort predicate for a live-id fleet race. A full UUID is globally
- * unique so the first exact hit is the only hit. A unique-enough live prefix
- * (8+ chars, the tmux `ag-<agent>-<8hex>` short id) aborts remaining SSH once
- * a reachable peer answers — unanswered boxes must not delay (PHNX-3298).
- * Shorter prefixes stay all-settle.
- */
 export declare function isDefinitiveLiveMatch(session: ActiveSession, selector: string): boolean;
-/**
- * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
- * default (it has no local pid to attach), but `detach` opts in with
- * `includeCloud` so it can resolve a cloud id and refuse it with a clear message
- * instead of a bare "no live session".
- *
- * `hosts` scopes the sweep to named devices — the fan-out only dials them, and the
- * pool is then filtered to `s.machine ∈ hosts` so a stray local row can't leak in.
- * `statuses` narrows to the live-state words `--active` uses (orphan/crashed/…).
- * `selector` (detach/stop) skips fleet SSH when local already has a unique live
- * id or a local collision; omit it for browse (`focus` with no id) so the picker
- * still all-settles.
- */
 export declare function gatherLiveTargets(local: boolean, opts?: {
     includeCloud?: boolean;
     hosts?: string[];
@@ -56,40 +17,15 @@ export declare function gatherLiveTargets(local: boolean, opts?: {
     self: string;
     activeById: Map<string, ActiveSession>;
 }>;
-/** Interactive pick over the live sessions' rich SessionMeta; returns the chosen live session. */
 export declare function pickLiveTarget(activeById: Map<string, ActiveSession>, self: string, message: string, enterHint: string): Promise<ActiveSession | null>;
-/**
- * Multi-select over the live sessions' rich SessionMeta (same rows as
- * `pickLiveTarget`, but a checkbox picker) — the plural sibling that lets `focus`
- * open several sessions at once. Mirrors `sessions resume`'s `multiItemPicker`
- * wiring; returns the chosen live sessions in pick order, or `[]` on cancel.
- */
 export declare function pickLiveTargets(activeById: Map<string, ActiveSession>, self: string, message: string): Promise<ActiveSession[]>;
-/**
- * Map each live session to its rich SessionMeta (worktree/PR/changes/tools/tests
- * via the shared picker), reusing `discoverSessions`. Remote or unindexed live
- * sessions get a minimal synthesized meta so they still appear and jump.
- */
 export declare function buildLivePool(activeById: Map<string, ActiveSession>, self: string): Promise<SessionMeta[]>;
 export interface Where {
     label: string;
     action: string;
 }
-/** What `jumpTo` writes after a remote tmux attach's SSH stream returns. Pure so
- *  the ControlMaster close path is unit-tested without SSH (RUSH-3227). */
 export declare function remoteAttachEndedNotice(sessionId: string | undefined, host: string, code: number): string | undefined;
-/**
- * Pure, testable mirror of `jumpTo`'s path selection (jumpTo itself has side
- * effects — process.exit / ssh / osascript). Keep the branch ORDER in sync with
- * `jumpTo` below: remote-tmux, then local-tmux, then ghostty, then refuse.
- */
 export declare function describeWhere(s: ActiveSession, self: string): Where;
-/**
- * What to do when a session can't be *attached* (no tmux/Ghostty rail). `go`
- * refuses; `focus` opens a new tab and resumes. `remote` is the peer name when
- * the session lives on another machine, else undefined. `fallbackId` is the
- * indexed session id when the live row has not registered one yet (PHNX-3356).
- */
 export type UnreachableFallback = (s: ActiveSession, remote: string | undefined, fallbackId?: string) => void | Promise<void>;
 export type AttachRailLiveness = {
     state: 'alive';
@@ -99,11 +35,6 @@ export type AttachRailLiveness = {
 } | {
     state: 'missing';
 };
-/** Probe the tmux process, not just retained provenance. This is deliberately
- * called immediately before an attach so remain-on-exit panes cannot masquerade
- * as living agent sessions. */
 export declare function probeAttachRail(s: ActiveSession, self: string): Promise<AttachRailLiveness>;
-/** Strict attach-only fallback: no pane means no attach. Never open a shell or
- * start recovery, because both would violate the caller's no-fork intent. */
 export declare function refuseFallback(s: ActiveSession, remote: string | undefined, fallbackId?: string): Promise<void>;
 export declare function jumpTo(s: ActiveSession, self: string, fallback?: UnreachableFallback, fallbackId?: string): Promise<void>;

package/dist/commands/go.js

@@ -1,14 +1,3 @@
-/**
- * The shared live-session reach engine that `sessions focus` / `resume --attach-only`
- * import ("attach or refuse", never fork/resume):
- *   - `gatherLiveTargets` / `pickLiveTarget` / `buildLivePool` — live-session discovery + picker
- *   - `jumpTo` — the side-effecting jump: attach the already-running terminal
- *       local tmux    -> attach (switch-client when already inside tmux)
- *       local Ghostty -> focus its tab (Cmd+<n> via System Events; tab # from ghostty-tabs)
- *       remote tmux   -> ssh -tt + tmux attach (pane->session resolved on the remote)
- *       otherwise     -> hand off to the `UnreachableFallback` (attach-only refuses; focus resumes)
- *   - `refuseFallback` — the attach-only fallback (remote -> login shell; local -> refuse)
- */
 import chalk from 'chalk';
 import path from 'path';
 import { execFile } from 'child_process';
@@ -18,7 +7,8 @@ import { isSessionIdShape } from '../lib/session/pid-registry.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { discoverSessions } from '../lib/session/discover.js';
 import { deriveShortId } from '../lib/session/short-id.js';
-import { dedupeByMachineSession, mergeLocalFirst, pickSessionInteractive, matchesLiveStatus, filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, isUniqueEnoughSelector, } from './sessions.js';
+import { mergeLocalFirst, pickSessionInteractive, filterSessionsByQuery, formatPickerLabel, pickerColumnsFor, isUniqueEnoughSelector } from './sessions.js';
+import { dedupeByMachineSession, matchesLiveStatus } from './ps-roster.js';
 import { buildPreview } from './sessions-picker.js';
 import { multiItemPicker } from '../lib/picker.js';
 import { isPromptCancelled } from './utils.js';
@@ -31,13 +21,6 @@ import { connectionEndedNotice } from '../lib/hosts/reconnect.js';
 import { enumerateGhosttyTabs, assignGhosttyTabs } from '../lib/session/ghostty-tabs.js';
 import { addressabilityRecoveryHint } from '../lib/terminal/resolve.js';
 const execFileAsync = promisify(execFile);
-/**
- * Scope a live-session pool by device and live status. Pure so the `focus`
- * device/status filters are unit-testable without touching the sweep. `hosts`
- * keeps only sessions whose `machine` is in the set (local rows carry `self`,
- * remote rows carry their peer tag); `statuses` reuses `--active`'s exact
- * `matchesLiveStatus` derivation rather than a parallel status table.
- */
 export function filterLivePool(sessions, opts = {}) {
     let out = sessions;
     if (opts.hosts?.length) {
@@ -49,22 +32,10 @@ export function filterLivePool(sessions, opts = {}) {
     }
     return out;
 }
-/**
- * Live rows whose session id starts with `selector` (case-insensitive prefix).
- * Same match `resolveOne` uses, so skip-fleet and resolve stay aligned.
- */
 export function localLiveSelectorMatches(sessions, selector) {
     const q = selector.toLowerCase();
     return sessions.filter((s) => (s.sessionId ?? '').toLowerCase().startsWith(q));
 }
-/**
- * Skip `gatherRemoteActive` when local already answered the selector:
- * two local matches fail closed without waiting for a sleeping peer that
- * might collide; a single local hit skips only when the selector is a full
- * UUID or unique-enough 8-hex (`isUniqueEnoughSelector`). A shorter unique
- * local prefix still races the fleet so a remote collision can fail closed.
- * Zero matches still race the fleet.
- */
 export function shouldSkipRemoteSweep(localMatches, selector) {
     if (localMatches.length >= 2)
         return true;
@@ -72,13 +43,6 @@ export function shouldSkipRemoteSweep(localMatches, selector) {
         return isUniqueEnoughSelector(selector);
     return false;
 }
-/**
- * First-hit abort predicate for a live-id fleet race. A full UUID is globally
- * unique so the first exact hit is the only hit. A unique-enough live prefix
- * (8+ chars, the tmux `ag-<agent>-<8hex>` short id) aborts remaining SSH once
- * a reachable peer answers — unanswered boxes must not delay (PHNX-3298).
- * Shorter prefixes stay all-settle.
- */
 export function isDefinitiveLiveMatch(session, selector) {
     const id = (session.sessionId ?? '').toLowerCase();
     const q = selector.trim().toLowerCase();
@@ -93,19 +57,6 @@ function liveSelectorEarlyExit(selector) {
         return undefined;
     return { isDefinitive: (item) => isDefinitiveLiveMatch(item, selector) };
 }
-/**
- * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
- * default (it has no local pid to attach), but `detach` opts in with
- * `includeCloud` so it can resolve a cloud id and refuse it with a clear message
- * instead of a bare "no live session".
- *
- * `hosts` scopes the sweep to named devices — the fan-out only dials them, and the
- * pool is then filtered to `s.machine ∈ hosts` so a stray local row can't leak in.
- * `statuses` narrows to the live-state words `--active` uses (orphan/crashed/…).
- * `selector` (detach/stop) skips fleet SSH when local already has a unique live
- * id or a local collision; omit it for browse (`focus` with no id) so the picker
- * still all-settles.
- */
 export async function gatherLiveTargets(local, opts = {}) {
     const self = machineId();
     const localActive = await getActiveSessions();
@@ -125,7 +76,7 @@ export async function gatherLiveTargets(local, opts = {}) {
             });
             active = dedupeByMachineSession([...localActive, ...remote.sessions]);
         }
-        catch { /* remote sweep is best-effort */ }
+        catch { }
     }
     active = filterLivePool(active, { hosts: opts.hosts, statuses: opts.statuses });
     const activeById = new Map();
@@ -138,7 +89,6 @@ export async function gatherLiveTargets(local, opts = {}) {
     }
     return { self, activeById };
 }
-/** Interactive pick over the live sessions' rich SessionMeta; returns the chosen live session. */
 export async function pickLiveTarget(activeById, self, message, enterHint) {
     const pool = await buildLivePool(activeById, self);
     if (pool.length === 0)
@@ -148,17 +98,10 @@ export async function pickLiveTarget(activeById, self, message, enterHint) {
         return null;
     return activeById.get(picked.session.id) ?? null;
 }
-/**
- * Multi-select over the live sessions' rich SessionMeta (same rows as
- * `pickLiveTarget`, but a checkbox picker) — the plural sibling that lets `focus`
- * open several sessions at once. Mirrors `sessions resume`'s `multiItemPicker`
- * wiring; returns the chosen live sessions in pick order, or `[]` on cancel.
- */
 export async function pickLiveTargets(activeById, self, message) {
     const pool = await buildLivePool(activeById, self);
     if (pool.length === 0)
         return [];
-    // gutter: 6 = the multi-select cursor + checkbox ('> [x] ') multiItemPicker prepends.
     const cols = { ...pickerColumnsFor(pool), gutter: 6 };
     let chosen;
     try {
@@ -183,17 +126,12 @@ export async function pickLiveTargets(activeById, self, message) {
         return [];
     return chosen.map((m) => activeById.get(m.id)).filter((s) => !!s);
 }
-/**
- * Map each live session to its rich SessionMeta (worktree/PR/changes/tools/tests
- * via the shared picker), reusing `discoverSessions`. Remote or unindexed live
- * sessions get a minimal synthesized meta so they still appear and jump.
- */
 export async function buildLivePool(activeById, self) {
     let metas = [];
     try {
         metas = await discoverSessions({ all: true, since: '30d', limit: 1000 });
     }
-    catch { /* fall back to synthesized metas */ }
+    catch { }
     const byId = new Map();
     for (const m of metas)
         byId.set(m.id, m);
@@ -205,15 +143,6 @@ export async function buildLivePool(activeById, self) {
 }
 function synthMeta(s, self) {
     const remote = !sessionProcessIsLocal(s, self);
-    // For a local session, locate the real transcript so the picker's buildPreview
-    // parses it directly (rich Prompt/Changes/Tools/Last response) rather than
-    // rendering from the indexed digest. For Claude that resolves off disk; every
-    // other harness resolves the id THROUGH the session index (RUSH-2691), so a
-    // local non-Claude session the index has not reached yet yields '' here and
-    // gets the same clean "not indexed here" note as a remote one — which is the
-    // honest answer, since the pre-RUSH-2691 alternative was a co-located
-    // stranger's transcript. Remote transcripts live on the peer, so leave
-    // filePath empty there too.
     const filePath = remote ? '' : (findSessionFileForKind(s.kind, s.cwd, s.sessionId) ?? '');
     return {
         id: s.sessionId,
@@ -231,24 +160,15 @@ function synthMeta(s, self) {
 function shortId(s) {
     return (s.sessionId ?? '').slice(0, 8) || '-';
 }
-/** What `jumpTo` writes after a remote tmux attach's SSH stream returns. Pure so
- *  the ControlMaster close path is unit-tested without SSH (RUSH-3227). */
 export function remoteAttachEndedNotice(sessionId, host, code) {
     if (!sessionId)
         return undefined;
     return connectionEndedNotice({ kind: 'session', id: sessionId }, host, { dropped: code === SSH_CONN_FAILURE_CODE });
 }
-/**
- * Pure, testable mirror of `jumpTo`'s path selection (jumpTo itself has side
- * effects — process.exit / ssh / osascript). Keep the branch ORDER in sync with
- * `jumpTo` below: remote-tmux, then local-tmux, then ghostty, then refuse.
- */
 export function describeWhere(s, self) {
     const remote = sessionProcessHost(s, self);
     const mux = s.provenance?.mux;
     if (mux?.kind === 'tmux' && mux.pane) {
-        // When the renderer has resolved the current viewer, fold it into the label
-        // so `focus` reports "tmux %3 (viewing in codium tab 2)" / "(detached)".
         const view = s.viewingIn
             ? ` (viewing in ${s.viewingIn.app}${s.viewingIn.tab != null ? ` tab ${s.viewingIn.tab}` : ''})`
             : '';
@@ -262,9 +182,6 @@ export function describeWhere(s, self) {
         return { label: `${s.host ?? 'shell'} on ${remote}`, action: `open a shell on ${remote}` };
     return { label: s.host ?? 'unknown terminal', action: 'resume it (no live attach rail)' };
 }
-/** Probe the tmux process, not just retained provenance. This is deliberately
- * called immediately before an attach so remain-on-exit panes cannot masquerade
- * as living agent sessions. */
 export async function probeAttachRail(s, self) {
     const mux = s.provenance?.mux;
     if (mux?.kind !== 'tmux' || !mux.pane)
@@ -293,8 +210,6 @@ export async function probeAttachRail(s, self) {
         ? { state: 'dead', exitStatus: Number.isFinite(exitStatus) ? exitStatus : undefined }
         : { state: 'alive' };
 }
-/** Strict attach-only fallback: no pane means no attach. Never open a shell or
- * start recovery, because both would violate the caller's no-fork intent. */
 export async function refuseFallback(s, remote, fallbackId) {
     if (remote) {
         console.log(chalk.yellow(`Can't attach ${shortId(s)} on ${remote} — it has no living tmux pane.`));
@@ -308,7 +223,6 @@ export async function refuseFallback(s, remote, fallbackId) {
 export async function jumpTo(s, self, fallback = refuseFallback, fallbackId) {
     const remote = sessionProcessHost(s, self);
     const mux = s.provenance?.mux;
-    // Path C: remote tmux — ssh in and attach, resolving the pane's session on the remote.
     if (remote) {
         if (mux?.kind === 'tmux' && mux.pane) {
             const liveness = await probeAttachRail(s, self);
@@ -331,11 +245,9 @@ export async function jumpTo(s, self, fallback = refuseFallback, fallbackId) {
                 process.stderr.write(notice);
             process.exit(code);
         }
-        // Remote, not in tmux → hand off to the fallback (go: shell; focus: resume in a tab).
         await fallback(s, remote, fallbackId);
         return;
     }
-    // Path B: local tmux — attach (or switch-client if we're already inside tmux).
     if (mux?.kind === 'tmux' && mux.pane) {
         const liveness = await probeAttachRail(s, self);
         if (liveness.state !== 'alive') {
@@ -354,9 +266,6 @@ export async function jumpTo(s, self, fallback = refuseFallback, fallbackId) {
             return;
         }
         console.log(chalk.gray(`Attaching ${shortId(s)} (tmux ${tgt}) — Ctrl-b d to detach.`));
-        // Repair a legacy/stale pane-died hook before the attach client takes over
-        // — the 5-min daemon reconcile that used to cover this was deleted;
-        // attach-time repair is what closes the gap now (RUSH-2435).
         if (session)
             await ensureSessionHookRepaired(session, socket);
         const code = await attachTmux({ socket, args: ['attach-session', '-t', tgt] });
@@ -364,14 +273,13 @@ export async function jumpTo(s, self, fallback = refuseFallback, fallbackId) {
             await teardownIfAgentExited(session, socket);
         process.exit(code);
     }
-    // Path A: local Ghostty — focus its tab (Cmd+N via System Events).
     if (s.host === 'ghostty') {
         let tab;
         try {
             const surfaces = await enumerateGhosttyTabs();
             tab = assignGhosttyTabs([s], surfaces).get(s);
         }
-        catch { /* best-effort */ }
+        catch { }
         if (tab != null && tab <= 9) {
             const script = `tell application "Ghostty" to activate\n` +
                 `delay 0.15\n` +
@@ -385,10 +293,8 @@ export async function jumpTo(s, self, fallback = refuseFallback, fallbackId) {
             chalk.gray(tab != null ? ` — switch to tab ${tab} (Cmd+${tab}).` : " — couldn't pinpoint its tab (same-repo forks are ambiguous); switch tabs manually."));
         return;
     }
-    // Path D: no attach rail (headless / plain terminal) → hand off to the fallback.
     await fallback(s, undefined, fallbackId);
 }
-/** Resolve a local tmux pane id to its session name + window index. */
 async function resolveLocalPane(socket, pane) {
     try {
         const res = await runTmux({ socket, args: ['display-message', '-pt', pane, '-p', '#{session_name}\t#{window_index}'], throwOnError: false });

package/dist/commands/harness-hooks.d.ts

@@ -1,48 +1,7 @@
-/**
- * Production {@link WizardHooks} for the harness create/edit wizard.
- *
- * The engine ({@link ./harness-wizard.js}) is pure and hook-driven; this module
- * supplies the three real extension points the sibling subtasks fill:
- *   - `pickModel`      — a catalog pick from the host's own model list
- *                        (`getModelCatalog`), with a free-text escape hatch and a
- *                        free-text FALLBACK when the host exposes no catalog
- *                        (RUSH-2220).
- *   - `connectionTest` — a real pre-save smoke test through `agents run`
- *                        (RUSH-2221), delegated to {@link runHarnessConnectionTest}.
- *   - `editable`       — the resolver-sourced per-host editability matrix
- *                        (RUSH-2222), {@link defaultEditable}.
- *
- * Kept out of the engine so the engine stays testable with a scripted IO and no
- * catalog probe, keychain read, or subprocess.
- */
 import type { AgentId } from '../lib/types.js';
 import { type ModelInfo } from '../lib/models.js';
 import { type WizardHooks, type WizardIO, type WizardChoice } from './harness-wizard.js';
-/**
- * Build the model `select` choices from a catalog. Pure, so the labelling +
- * escape-hatch rows are unit-tested with no catalog probe. Every list ends with
- * a "type a custom id" row so a model the catalog doesn't list is always
- * reachable; in edit mode a "keep current" row leads.
- */
 export declare function buildModelChoices(models: ModelInfo[], current?: string): WizardChoice<string>[];
-/**
- * Prompt over an already-resolved catalog: a `select` of the models plus the
- * keep-current / custom-id rows, mapping the sentinel choices back to a concrete
- * model id. Split from the catalog probe so the KEEP / CUSTOM / pick branches are
- * unit-tested with a scripted IO and no installed agent.
- */
 export declare function chooseModelFromCatalog(io: WizardIO, models: ModelInfo[], current: string | undefined): Promise<string>;
-/**
- * The catalog-backed model pick (RUSH-2220). Returns the chosen model id, or
- * `null` to fall through to the engine's free-text prompt when the host exposes
- * no probeable catalog — so a host we can't enumerate degrades to today's
- * free-text behaviour rather than blocking.
- */
 export declare function pickModel(io: WizardIO, host: AgentId | undefined, version: string | undefined, current: string | undefined): Promise<string | null>;
-/**
- * Assemble the production hook set the harness commands drive the wizard with.
- * The connection-test hook reads the assembled draft's `name` — the caller writes
- * the profile to disk first, then invokes the test through the real `agents run`
- * path against that name.
- */
 export declare function harnessHooks(): WizardHooks;

package/dist/commands/harness-hooks.js

@@ -1,43 +1,13 @@
-/**
- * Production {@link WizardHooks} for the harness create/edit wizard.
- *
- * The engine ({@link ./harness-wizard.js}) is pure and hook-driven; this module
- * supplies the three real extension points the sibling subtasks fill:
- *   - `pickModel`      — a catalog pick from the host's own model list
- *                        (`getModelCatalog`), with a free-text escape hatch and a
- *                        free-text FALLBACK when the host exposes no catalog
- *                        (RUSH-2220).
- *   - `connectionTest` — a real pre-save smoke test through `agents run`
- *                        (RUSH-2221), delegated to {@link runHarnessConnectionTest}.
- *   - `editable`       — the resolver-sourced per-host editability matrix
- *                        (RUSH-2222), {@link defaultEditable}.
- *
- * Kept out of the engine so the engine stays testable with a scripted IO and no
- * catalog probe, keychain read, or subprocess.
- */
 import chalk from 'chalk';
 import { getModelCatalog } from '../lib/models.js';
 import { getGlobalDefault, listInstalledVersions } from '../lib/installations/versions.js';
 import { runHarnessConnectionTest } from '../lib/harness-connection-test.js';
 import { defaultEditable, } from './harness-wizard.js';
-/** Sentinel select values for the two non-catalog rows in the model pick. */
 const CUSTOM_MODEL = '__custom_model__';
 const KEEP_MODEL = '__keep_model__';
-/**
- * The installed version whose model catalog to read for a host. The wizard has
- * no version in hand for a fresh create, so it reads the host's default (or its
- * sole installed) version — the same version a bare `agents run <host>` uses.
- * Null when the host has no installed version to probe (→ free-text model).
- */
 function catalogVersionFor(host) {
     return getGlobalDefault(host) || listInstalledVersions(host)[0] || null;
 }
-/**
- * Build the model `select` choices from a catalog. Pure, so the labelling +
- * escape-hatch rows are unit-tested with no catalog probe. Every list ends with
- * a "type a custom id" row so a model the catalog doesn't list is always
- * reachable; in edit mode a "keep current" row leads.
- */
 export function buildModelChoices(models, current) {
     const choices = [];
     if (current)
@@ -55,12 +25,6 @@ export function buildModelChoices(models, current) {
     choices.push({ name: 'Type a custom model id…', value: CUSTOM_MODEL });
     return choices;
 }
-/**
- * Prompt over an already-resolved catalog: a `select` of the models plus the
- * keep-current / custom-id rows, mapping the sentinel choices back to a concrete
- * model id. Split from the catalog probe so the KEEP / CUSTOM / pick branches are
- * unit-tested with a scripted IO and no installed agent.
- */
 export async function chooseModelFromCatalog(io, models, current) {
     const choice = await io.select({
         message: 'Model',
@@ -72,12 +36,6 @@ export async function chooseModelFromCatalog(io, models, current) {
         return io.input({ message: 'Model id', default: current });
     return choice;
 }
-/**
- * The catalog-backed model pick (RUSH-2220). Returns the chosen model id, or
- * `null` to fall through to the engine's free-text prompt when the host exposes
- * no probeable catalog — so a host we can't enumerate degrades to today's
- * free-text behaviour rather than blocking.
- */
 export async function pickModel(io, host, version, current) {
     if (!host)
         return null;
@@ -89,12 +47,6 @@ export async function pickModel(io, host, version, current) {
         return null;
     return chooseModelFromCatalog(io, catalog.models, current);
 }
-/**
- * Assemble the production hook set the harness commands drive the wizard with.
- * The connection-test hook reads the assembled draft's `name` — the caller writes
- * the profile to disk first, then invokes the test through the real `agents run`
- * path against that name.
- */
 export function harnessHooks() {
     return {
         pickModel,