@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/session/tool-index.js

@@ -14,7 +14,7 @@ export const TOOL_PROGRAM_COUNT_SCHEMA_VERSION = 1;
 export const TOOL_QUERY_MAX_CLAUSES = 32;
 export const TOOL_QUERY_MAX_CLAUSE_BYTES = 4096;
 export const TOOL_QUERY_MAX_CALL_ROWS = 50_000;
-export const TOOL_QUERY_MAX_RESULT_BYTES = 8 * 1024 * 1024;
+const TOOL_QUERY_MAX_RESULT_BYTES = 8 * 1024 * 1024;
 export const TOOL_QUERY_MAX_RESULT_SESSIONS = 1_000;
 export const TOOL_QUERY_MAX_SERIALIZED_BYTES = 15 * 1024 * 1024;
 export const TOOL_QUERY_MERGE_OVERHEAD_BYTES = 64 * 1024;
@@ -400,7 +400,7 @@ function tokenizeClause(source) {
     return tokens;
 }
 /** Parse one same-call clause. Unprefixed terms search every evidence field. */
-export function parseToolQueryClause(source) {
+function parseToolQueryClause(source) {
     const fields = new Set(['tool', 'program', 'input', 'output', 'status', 'exit', 'error']);
     return tokenizeClause(source).map((token) => {
         const colon = token.indexOf(':');

package/dist/lib/session/tool-store.d.ts

@@ -22,7 +22,7 @@ export interface ToolScanResumePoint {
      */
     parsedOffset: number;
 }
-export interface PersistToolCallsOptions {
+interface PersistToolCallsOptions {
     /**
      * `replace` drops the session's stored evidence first — correct for a parse
      * that started at byte 0. `append` merges the batch into what is already
@@ -68,3 +68,4 @@ export declare function planEventToolResume(db: Database.Database, sessionId: st
     fileMtimeMs: number;
     fileSize: number;
 }, currentEventCount: number): EventToolScanResumePoint | null;
+export {};

package/dist/lib/session/trajectory-compare.d.ts

@@ -35,7 +35,7 @@ export interface TrajectoryComparison {
     truncatedA: number;
     truncatedB: number;
 }
-export interface DiffTrajectoriesOptions {
+interface DiffTrajectoriesOptions {
     /** Cap on tool steps considered per side (the LCS table is O(n*m)). Default 1000. */
     maxDiffSteps?: number;
 }
@@ -45,3 +45,4 @@ export interface DiffTrajectoriesOptions {
  * did. Never mutates either input.
  */
 export declare function diffTrajectories(a: SessionTrajectory, b: SessionTrajectory, options?: DiffTrajectoriesOptions): TrajectoryComparison;
+export {};

package/dist/lib/session/trajectory-lineage.d.ts

@@ -65,7 +65,7 @@ export interface SessionLineage {
      */
     unresolvedParentIds: string[];
 }
-export interface BuildLineageOptions {
+interface BuildLineageOptions {
     /**
      * Which session the graph is about. The graph is always rooted at that
      * session's TOPMOST ancestor in the pool, so passing a child still renders its
@@ -90,3 +90,4 @@ export interface BuildLineageOptions {
  * sessions in the pool supply edges but never become nodes.
  */
 export declare function buildLineage(sessions: SessionMeta[], options?: BuildLineageOptions): SessionLineage;
+export {};

package/dist/lib/session/trajectory-text.d.ts

@@ -1,7 +1,7 @@
 import type { SessionTrajectory } from './trajectory.js';
 import type { TrajectoryComparison } from './trajectory-compare.js';
 import type { SessionLineage } from './trajectory-lineage.js';
-export interface RenderTrajectoryTextOptions {
+interface RenderTrajectoryTextOptions {
     /** Collapse to error steps and their immediate neighbours. */
     errorsOnly?: boolean;
     /** Cap on the step lines emitted; the remainder is collapsed with a count. */
@@ -9,7 +9,7 @@ export interface RenderTrajectoryTextOptions {
 }
 /** Render one session's trajectory as compact, ANSI-free text. */
 export declare function renderTrajectoryText(model: SessionTrajectory, options?: RenderTrajectoryTextOptions): string;
-export interface RenderTrajectoryCompareTextOptions {
+interface RenderTrajectoryCompareTextOptions {
     /** Cap on step lines listed per diff column; the remainder is collapsed with a count. Default 15. */
     maxDiffLines?: number;
 }
@@ -35,3 +35,4 @@ export declare function renderTrajectoryCompareText(cmp: TrajectoryComparison, o
  * the shape of the fan-out; `agents sessions trace <child>` answers one child.
  */
 export declare function renderLineageText(lineage: SessionLineage): string;
+export {};

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

@@ -80,7 +80,7 @@ export interface SessionTrajectory {
     /** Steps dropped by the `maxSteps` cap, surfaced so truncation is never silent. */
     truncatedSteps: number;
 }
-export interface BuildTrajectoryOptions {
+interface BuildTrajectoryOptions {
     /** Redact derived labels/details (default true; `--no-redact` is local-only). */
     redact?: boolean;
     /** Known secret values to mask, from `knownSecretValuesFromEnv()`. */
@@ -142,3 +142,4 @@ export declare function pairSteps(events: SessionEvent[], eventMs: number[], fir
  * event array and therefore an empty trajectory — never a crash or a fabricated one.
  */
 export declare function buildTrajectory(events: SessionEvent[], meta: SessionMeta, options?: BuildTrajectoryOptions): SessionTrajectory;
+export {};

package/dist/lib/session/viewing-in.d.ts

@@ -21,7 +21,7 @@ import type { TmuxClient } from '../tmux/session.js';
 import type { ActiveSession } from './active.js';
 import { type GhosttySurface } from './ghostty-tabs.js';
 /** Where a tmux-hosted session is currently displayed. */
-export interface ViewingIn {
+interface ViewingIn {
     /** Host app of the attached client — 'ghostty', 'iterm', 'code', 'codium', … */
     app: string;
     /** 1-based tab number within that app, when it can be resolved. */
@@ -83,3 +83,4 @@ export declare function resolveViewingIn(session: ActiveSession, clients: TmuxCl
  * Ghostty's `index of tab`. Exported for the parser test.
  */
 export declare function itermTabFromSessionId(value: string | undefined): number | undefined;
+export {};

package/dist/lib/sessions-client.js

@@ -70,12 +70,9 @@ const ENGINE_VERBS = new Set([
     'tail',
     'watch',
     'preview',
-    'attach',
     'focus',
     'render',
     'stats',
-    'go',
-    'reconnect',
     'migrations',
     'export',
 ]);

package/dist/lib/settings-manifest.d.ts

@@ -17,7 +17,7 @@
  * `hasTrustDialogAccepted: false` to `true` — see the note on that entry.)
  */
 import type { AgentId } from './types.js';
-export interface CarryForwardResult {
+interface CarryForwardResult {
     /** Manifest rel paths that were created or updated in the target home. */
     applied: string[];
     /** Backup directory holding pre-merge copies of modified target files, if any. */
@@ -39,3 +39,4 @@ export declare function fillGaps(target: Record<string, unknown>, source: Record
  * Only fills gaps — never overwrites target values — so it is idempotent.
  */
 export declare function carryForwardSettings(agent: AgentId, fromHome: string, toHome: string): CarryForwardResult;
+export {};

package/dist/lib/setup-tool-install.d.ts

@@ -0,0 +1,3 @@
+import { type SetupTool } from './setup-tool-status.js';
+/** Use the host installer; setup must not install or start a tool from a read. */
+export declare function installSetupTool(tool: Exclude<SetupTool, 'secrets'>): Promise<boolean>;

package/dist/lib/setup-tool-install.js

@@ -0,0 +1,26 @@
+import { installCli, resolveCliManifest } from './cli-resources.js';
+import { getCachedToolSetup, refreshToolSetup } from './setup-tool-status.js';
+const PACKAGES = {
+    browser: '@phnx-labs/browser-cli@0.1.3',
+    computer: '@phnx-labs/computer-cli@0.1.5',
+};
+/** Use the host installer; setup must not install or start a tool from a read. */
+export async function installSetupTool(tool) {
+    if (getCachedToolSetup().find((row) => row.tool === tool)?.installed)
+        return true;
+    const manifest = resolveCliManifest(tool) ?? {
+        name: tool,
+        check: { kind: 'which', cmd: tool },
+        install: [{ npm: PACKAGES[tool] }],
+        source: 'builtin',
+        path: '',
+    };
+    const result = installCli(manifest);
+    if (result.error)
+        console.error(result.error);
+    const rows = await refreshToolSetup(tool);
+    const installed = rows[0]?.installed === true;
+    if (!installed && !result.error)
+        console.error(`${tool} installation did not produce a standalone executable on PATH.`);
+    return result.installed && installed;
+}

package/dist/lib/setup-tool-status.d.ts

@@ -0,0 +1,22 @@
+export declare const SETUP_TOOLS: readonly ["browser", "computer", "secrets"];
+export type SetupTool = typeof SETUP_TOOLS[number];
+export interface ToolSetupRow {
+    tool: SetupTool;
+    installed: boolean | null;
+    executable?: string;
+    version?: string;
+    readiness: 'ready' | 'needs-setup' | 'permission-required' | 'stopped' | 'unsupported' | 'unknown';
+    detail: string;
+    checkedAtMs: number | null;
+}
+export interface ToolSetupOptions {
+    cacheDir?: string;
+}
+export declare function toolSetupCacheDir(options?: ToolSetupOptions): string;
+/** Presence is metadata; health is the last explicit check, never a timer probe. */
+export declare function getCachedToolSetup(options?: ToolSetupOptions): ToolSetupRow[];
+export declare function toolReadiness(tool: SetupTool, status: unknown): Pick<ToolSetupRow, 'readiness' | 'detail'>;
+/** A shared disk lock coalesces overlapping requests from separate CLI clients. */
+export declare function refreshToolSetup(tool?: SetupTool | 'all', options?: ToolSetupOptions): Promise<ToolSetupRow[]>;
+/** File notifications are shared by the daemon collector; no background probes. */
+export declare function subscribeToolSetup(listener: (rows: ToolSetupRow[]) => void, options?: ToolSetupOptions): () => void;

package/dist/lib/setup-tool-status.js

@@ -0,0 +1,215 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { findInPath } from './agent-spec/agents.js';
+import { getCacheDir, getDeviceMetaPath, getHelpersDir, getUserAgentsDir } from './state.js';
+import { atomicWriteJsonSync, withFileLockAsync } from './fs-atomic.js';
+import { probeCapture } from './probe.js';
+import { invocation, isStandaloneComputer } from './computer-client.js';
+import { getSocketPath as browserSocketPath } from './browser/ipc.js';
+export const SETUP_TOOLS = ['browser', 'computer', 'secrets'];
+export function toolSetupCacheDir(options = {}) {
+    return path.join(options.cacheDir ?? getCacheDir(), 'setup-tools');
+}
+function cachePath(tool, options) {
+    return path.join(toolSetupCacheDir(options), `${tool}.json`);
+}
+function setupInputs(tool) {
+    const inputs = [path.join(getUserAgentsDir(), 'agents.yaml'), getDeviceMetaPath()];
+    if (tool === 'browser')
+        inputs.push(browserSocketPath());
+    if (tool === 'computer')
+        inputs.push(process.env.COMPUTER_HELPER_SOCKET || path.join(getHelpersDir(), 'computer.sock'));
+    return inputs;
+}
+function inputStamp(tool) {
+    return setupInputs(tool).map((file) => {
+        try {
+            const stat = fs.statSync(file);
+            return `${file}:${stat.ino}:${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            return `${file}:missing`;
+        }
+    }).join('|');
+}
+function binaryMetadata(tool) {
+    const empty = { tool, installed: false, readiness: 'needs-setup', detail: 'CLI is not installed.', checkedAtMs: null };
+    try {
+        const explicit = process.env[`${tool.toUpperCase()}_BIN`]?.trim();
+        const accept = (candidate) => {
+            if (tool === 'computer')
+                return isStandaloneComputer(candidate);
+            if (tool === 'browser') {
+                try {
+                    return !fs.realpathSync(candidate).endsWith(path.join('dist', 'browser.js'));
+                }
+                catch {
+                    return false;
+                }
+            }
+            return true;
+        };
+        let executable = explicit ? (accept(explicit) ? explicit : null) : findInPath(tool, { accept });
+        if (!executable)
+            return { row: empty, fingerprint: 'missing' };
+        if (/\.(cmd|ps1)$/i.test(executable)) {
+            const packageDir = path.join(path.dirname(executable), 'node_modules', '@phnx-labs', `${tool}-cli`);
+            const pkg = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'));
+            const entry = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.[tool];
+            if (pkg.name !== `@phnx-labs/${tool}-cli` || typeof entry !== 'string')
+                throw new Error('unrecognized npm launcher');
+            const resolved = path.resolve(packageDir, entry);
+            if (!resolved.startsWith(`${path.resolve(packageDir)}${path.sep}`))
+                throw new Error('invalid npm entrypoint');
+            executable = resolved;
+        }
+        fs.accessSync(executable, process.platform === 'win32' || /\.[cm]?js$/i.test(executable) ? fs.constants.R_OK : fs.constants.X_OK);
+        const real = fs.realpathSync(executable);
+        const stat = fs.statSync(real);
+        if (!stat.isFile())
+            throw new Error('not a file');
+        let version;
+        let dir = path.dirname(real);
+        for (let depth = 0; depth < 5; depth++) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+                if (pkg.name === `@phnx-labs/${tool}-cli` && typeof pkg.version === 'string') {
+                    version = pkg.version;
+                    break;
+                }
+            }
+            catch { /* Executables need not be npm packages. */ }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return {
+            fingerprint: `${real}:${stat.size}:${stat.mtimeMs}:${version ?? ''}|${inputStamp(tool)}`,
+            row: { tool, installed: true, executable, version, readiness: 'unknown', detail: 'Installed. Health has not been checked.', checkedAtMs: null },
+        };
+    }
+    catch {
+        return { fingerprint: 'unavailable', row: { ...empty, installed: null, readiness: 'unknown', detail: 'Executable could not be inspected.' } };
+    }
+}
+function readCache(tool, options) {
+    try {
+        const cached = JSON.parse(fs.readFileSync(cachePath(tool, options), 'utf8'));
+        if (cached.v === 1 && cached.row?.tool === tool && typeof cached.fingerprint === 'string')
+            return cached;
+    }
+    catch { /* No health result yet. */ }
+    return null;
+}
+/** Presence is metadata; health is the last explicit check, never a timer probe. */
+export function getCachedToolSetup(options = {}) {
+    return SETUP_TOOLS.map((tool) => {
+        const { row, fingerprint } = binaryMetadata(tool);
+        const cached = readCache(tool, options);
+        return cached?.fingerprint === fingerprint ? { ...cached.row, executable: row.executable, version: row.version } : row;
+    });
+}
+export function toolReadiness(tool, status) {
+    if (!status || typeof status !== 'object')
+        return { readiness: 'unknown', detail: 'The CLI returned an unreadable health result.' };
+    const value = status;
+    if (tool === 'computer') {
+        if (value.installed === false)
+            return { readiness: 'needs-setup', detail: 'CLI installed; computer helper needs setup.' };
+        if (value.running === true && value.trusted === true)
+            return { readiness: 'ready', detail: 'Helper is running and Accessibility is granted. Screen Recording is checked when capturing.' };
+        if (value.running === true && value.trusted === false)
+            return { readiness: 'permission-required', detail: 'Grant Accessibility to Agents Computer in System Settings.' };
+        if (value.running === false)
+            return { readiness: 'stopped', detail: 'Computer helper is stopped or unreachable.' };
+    }
+    if (tool === 'browser') {
+        if (value.running === true)
+            return { readiness: 'ready', detail: 'Browser service is running.' };
+        if (value.running === false)
+            return { readiness: 'stopped', detail: 'Browser service is stopped.' };
+    }
+    return { readiness: 'unknown', detail: typeof value.error === 'string' && value.error.trim() ? value.error.slice(0, 500) : 'The CLI did not report a recognized health state.' };
+}
+async function checkTool(row) {
+    if (!row.installed || !row.executable)
+        return { ...row, checkedAtMs: Date.now() };
+    // The standalone has no non-interactive health JSON. Do not list bundles or
+    // unlock the broker merely to paint a settings row.
+    if (row.tool === 'secrets')
+        return { ...row, checkedAtMs: Date.now(), detail: 'Installed. Secret access is checked when used; this check does not unlock secrets.' };
+    try {
+        const { command, prefix } = invocation(row.executable);
+        const { stdout } = await probeCapture(command, [...prefix, 'status', '--json'], 8000, { acceptedExitCodes: [0, 1], maxOutputBytes: 256 * 1024 });
+        return { ...row, ...toolReadiness(row.tool, JSON.parse(stdout)), checkedAtMs: Date.now() };
+    }
+    catch {
+        return { ...row, readiness: 'unknown', detail: 'Health check failed or timed out. Check again to retry.', checkedAtMs: Date.now() };
+    }
+}
+/** A shared disk lock coalesces overlapping requests from separate CLI clients. */
+export async function refreshToolSetup(tool = 'all', options = {}) {
+    const requestedAt = Date.now();
+    const dir = toolSetupCacheDir(options);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (const selected of tool === 'all' ? SETUP_TOOLS : [tool]) {
+        const file = cachePath(selected, options);
+        await withFileLockAsync(file, async () => {
+            const metadata = binaryMetadata(selected);
+            const cached = readCache(selected, options);
+            if (cached?.fingerprint === metadata.fingerprint && (cached.row.checkedAtMs ?? 0) >= requestedAt)
+                return;
+            const row = await checkTool(metadata.row);
+            atomicWriteJsonSync(file, { v: 1, fingerprint: metadata.fingerprint, row });
+        }, { realpath: false, acquireTimeoutMs: 20_000 });
+    }
+    return getCachedToolSetup(options).filter((row) => tool === 'all' || row.tool === tool);
+}
+/** File notifications are shared by the daemon collector; no background probes. */
+export function subscribeToolSetup(listener, options = {}) {
+    const dir = toolSetupCacheDir(options);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const paths = new Set([dir, ...(process.env.PATH ?? '').split(path.delimiter).filter(Boolean)]);
+    for (const tool of SETUP_TOOLS)
+        for (const input of setupInputs(tool))
+            paths.add(path.dirname(input));
+    for (const row of getCachedToolSetup(options)) {
+        if (row.executable) {
+            paths.add(path.dirname(row.executable));
+            try {
+                paths.add(path.dirname(fs.realpathSync(row.executable)));
+            }
+            catch { /* Removed since discovery. */ }
+        }
+    }
+    let previous = JSON.stringify(getCachedToolSetup(options));
+    let debounce;
+    const changed = () => {
+        if (debounce)
+            return;
+        debounce = setTimeout(() => {
+            debounce = undefined;
+            const rows = getCachedToolSetup(options);
+            const next = JSON.stringify(rows);
+            if (next !== previous) {
+                previous = next;
+                listener(rows);
+            }
+        }, 150);
+        debounce.unref();
+    };
+    const watchers = [];
+    for (const target of paths) {
+        try {
+            const watcher = fs.watch(target, { persistent: false }, changed);
+            watcher.on('error', changed);
+            watchers.push(watcher);
+        }
+        catch { /* Absent PATH entries have no executable to report. */ }
+    }
+    changed();
+    return () => { if (debounce)
+        clearTimeout(debounce); for (const watcher of watchers)
+        watcher.close(); };
+}

package/dist/lib/share-runtime.d.ts

@@ -0,0 +1,11 @@
+/** Best-effort runtime env for spawned agents. Never throws AND never prompts.
+ *
+ * Auto-injecting the share write token on every `agents run` is a background
+ * convenience, NOT a user-initiated secret access — so it MUST NOT raise a Touch
+ * ID sheet (SEC-13: an agent launch never pops biometry on its own). The read is
+ * always `agentOnly`: it resolves the token only from the injected env or an
+ * already-held / no-ACL bundle, and silently returns undefined otherwise (the
+ * agent can still publish via its own `artifacts share` credentials). For
+ * zero-friction auto-share with no prompt: unlock once (`agents secrets unlock
+ * share`) or make it no-ACL (`agents secrets policy share never`). */
+export declare function shareRuntimeEnv(): Record<string, string> | undefined;

package/dist/lib/share-runtime.js

@@ -0,0 +1,63 @@
+// Runtime share-token injection for spawned agents.
+//
+// The artifact share ENGINE moved to `@phnx-labs/artifacts-cli` (PHNX-3992);
+// agents-cli no longer publishes artifacts itself. What stays here is the thin
+// glue that lets a dispatched agent inherit the operator's BYO write token so
+// its own `artifacts share` can publish headlessly: `run`/`teams`/`cloud`
+// dispatch call `shareRuntimeEnv()` and forward the result into the agent env.
+// artifacts-cli honors the same `SHARE_WRITE_TOKEN` variable, so the injection
+// contract is unchanged by the extraction.
+//
+// The endpoint config still lives in `agents.yaml` under `share:` (Meta.share)
+// so a previously-provisioned BYO endpoint keeps syncing fleet-wide; the raw
+// write token lives in the keychain-backed `share` secrets bundle, never on disk.
+import { readMeta } from './state.js';
+import { bundleExistsSync as bundleExists, readAndResolveBundleEnvSync as readAndResolveBundleEnv, } from './secrets-client.js';
+const SHARE_BUNDLE = 'share';
+const SHARE_TOKEN_KEY = 'WRITE_TOKEN';
+const SHARE_TOKEN_ENV_KEY = 'SHARE_WRITE_TOKEN';
+/** Trim; empty / whitespace-only strings are absent. */
+function nonempty(v) {
+    const t = v?.trim();
+    return t ? t : undefined;
+}
+/** Whether a BYO share endpoint is still configured in `agents.yaml`. */
+function hasShareEndpoint() {
+    return !!nonempty(readMeta().share?.baseUrl);
+}
+/** The write token as injected ephemerally into fleet/cloud agents. */
+function readWriteTokenEnv(env = process.env) {
+    const token = env[SHARE_TOKEN_ENV_KEY]?.trim();
+    return token ? token : null;
+}
+/** Best-effort runtime env for spawned agents. Never throws AND never prompts.
+ *
+ * Auto-injecting the share write token on every `agents run` is a background
+ * convenience, NOT a user-initiated secret access — so it MUST NOT raise a Touch
+ * ID sheet (SEC-13: an agent launch never pops biometry on its own). The read is
+ * always `agentOnly`: it resolves the token only from the injected env or an
+ * already-held / no-ACL bundle, and silently returns undefined otherwise (the
+ * agent can still publish via its own `artifacts share` credentials). For
+ * zero-friction auto-share with no prompt: unlock once (`agents secrets unlock
+ * share`) or make it no-ACL (`agents secrets policy share never`). */
+export function shareRuntimeEnv() {
+    if (!hasShareEndpoint())
+        return undefined;
+    const fromEnv = readWriteTokenEnv();
+    if (fromEnv)
+        return { [SHARE_TOKEN_ENV_KEY]: fromEnv };
+    try {
+        if (!bundleExists(SHARE_BUNDLE))
+            return undefined;
+        const { env } = readAndResolveBundleEnv(SHARE_BUNDLE, {
+            caller: 'share',
+            keys: [SHARE_TOKEN_KEY],
+            agentOnly: true, // never raise a Touch ID sheet on an agent launch (SEC-13)
+        });
+        const token = env[SHARE_TOKEN_KEY];
+        return token ? { [SHARE_TOKEN_ENV_KEY]: token } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/shim-heal.d.ts

@@ -1,5 +1,5 @@
 import type { SelfHealReport } from './self-heal/types.js';
-export interface InteractiveShimHealResult {
+interface InteractiveShimHealResult {
     noticeLines: string[] | null;
     report: SelfHealReport;
 }
@@ -9,10 +9,6 @@ export interface InteractiveShimHealResult {
  * won't move; a PATH entry that was just added / needs a reload).
  */
 export declare function runInteractiveShimHeal(): Promise<InteractiveShimHealResult>;
-/**
- * Back-compat wrapper for callers that only need the persistent one-time notice.
- */
-export declare function healShimsInteractive(): Promise<string[] | null>;
 type PathNoticeState = 'ok' | 'added' | 'reload';
 /**
  * A stable signature of the conditions worth surfacing: the sorted set of

package/dist/lib/shim-heal.js

@@ -54,12 +54,6 @@ export async function runInteractiveShimHeal() {
     }
     return { noticeLines: lines.length > 0 ? lines : null, report };
 }
-/**
- * Back-compat wrapper for callers that only need the persistent one-time notice.
- */
-export async function healShimsInteractive() {
-    return (await runInteractiveShimHeal()).noticeLines;
-}
 function noticeStatePath() {
     return path.join(getRuntimeStateDir(), 'shim-notice.json');
 }

package/dist/lib/smart-launch.d.ts

@@ -8,8 +8,6 @@
 import { type AffinityRow } from './session/db.js';
 import { type DevicePlacementSignal } from './teams/scheduler.js';
 import type { AgentType } from './teams/agents.js';
-/** Peakiness of usage weights; >1 amplifies the most-used option. */
-export declare const DEFAULT_AFFINITY_ALPHA = 1.3;
 export interface WeightedCandidate {
     key: string;
     launches: number;
@@ -41,7 +39,7 @@ export declare function sampleWeighted(candidates: WeightedCandidate[], rng?: ()
  * keep agents off).
  */
 export declare function listOnlineDeviceNames(localName?: string): string[];
-export interface DeviceAffinityOptions {
+interface DeviceAffinityOptions {
     sinceDays?: number;
     alpha?: number;
     /**
@@ -64,7 +62,7 @@ export interface DeviceAffinityPlan {
     pickedDeviceKey: string | null;
 }
 /** Live placement plan used by the explicit `--device auto` surface. */
-export interface DeviceAutoPlan {
+interface DeviceAutoPlan {
     /** null means the local machine won the comparison. */
     host: string | null;
     candidates: Array<{
@@ -114,21 +112,17 @@ export declare function resolveDeviceAuto(agent?: string, opts?: {
 export declare function resolveDeviceAffinity(opts?: DeviceAffinityOptions): DeviceAffinityPlan;
 /** True when a host flag value means affinity pick. */
 export declare function isDeviceAuto(value: string | undefined | null): boolean;
-export type DeviceAutoHostOptions = {
+type DeviceAutoHostOptions = {
     host?: string;
     device?: string;
     on?: string;
     computer?: string;
-    /** @deprecated Hidden alias for `--device auto`. */
-    smart?: boolean;
     balanced?: boolean;
     strategy?: string;
 };
 export type DeviceAutoApplyResult = {
     /** True when automatic placement ran successfully. */
     attempted: boolean;
-    /** True when deprecated `--smart` was seen. */
-    deprecationSmart: boolean;
     /** Present when affinity resolved without error. */
     banner?: {
         hostLabel: string;
@@ -137,7 +131,7 @@ export type DeviceAutoApplyResult = {
     };
 };
 /**
- * Apply `--device auto` (and deprecated `--smart`) onto run options.
+ * Apply `--device auto` onto run options.
  * Mutates `options` in place. Placement failures propagate without rewriting
  * `auto`, so callers fail loud instead of silently launching locally.
  */
@@ -146,3 +140,4 @@ export declare function applyDeviceAutoToOptions(options: DeviceAutoHostOptions,
     agent?: string;
     accountPickerRequested?: boolean;
 }): Promise<DeviceAutoApplyResult>;
+export {};

package/dist/lib/smart-launch.js

@@ -13,7 +13,7 @@ import { normalizeHost } from './machine-id.js';
 import { probePoolSignals } from './teams/placement-probe.js';
 import { pickBestDevice } from './teams/scheduler.js';
 /** Peakiness of usage weights; >1 amplifies the most-used option. */
-export const DEFAULT_AFFINITY_ALPHA = 1.3;
+const DEFAULT_AFFINITY_ALPHA = 1.3;
 /**
  * Convert affinity rows into positive weights: launches^α (floor 1 for any
  * row with launches > 0 so a single-use host still participates).
@@ -176,7 +176,7 @@ export async function resolveDeviceAuto(agent, opts = {}) {
     if (eligiblePool.length === 0) {
         throw new Error(formatNoHealthyDeviceError(pool, signals, agent));
     }
-    // `agents devices prefer <name>` boosts a device in the ranking — resolved
+    // `agents devices config <name> auto-launch.preferred on` boosts a device in the ranking — resolved
     // over the same pool so a fleet default reaches a doc-less box.
     const preferred = opts.preferred ?? autoLaunchPreferredSet(pool, { roster: pool });
     const picked = pickBestDevice(eligiblePool, [], { signals, agentLabel: agent, preferred });
@@ -260,21 +260,14 @@ export function isDeviceAuto(value) {
 }
 const HOST_SLOTS = ['host', 'device', 'on', 'computer'];
 /**
- * Apply `--device auto` (and deprecated `--smart`) onto run options.
+ * Apply `--device auto` onto run options.
  * Mutates `options` in place. Placement failures propagate without rewriting
  * `auto`, so callers fail loud instead of silently launching locally.
  */
 export async function applyDeviceAutoToOptions(options, deps = {}) {
-    let deprecationSmart = false;
-    if (options.smart) {
-        const anyHost = HOST_SLOTS.some((k) => typeof options[k] === 'string' && options[k].trim() !== '');
-        if (!anyHost)
-            options.device = 'auto';
-        deprecationSmart = true;
-    }
     const hasAuto = HOST_SLOTS.some((k) => isDeviceAuto(options[k]));
     if (!hasAuto) {
-        return { attempted: false, deprecationSmart };
+        return { attempted: false };
     }
     const accountPickerRequested = deps.accountPickerRequested ?? false;
     const resolve = deps.resolve ?? ((accountPicker) => resolveDeviceAuto(deps.agent, { accountPicker }));
@@ -296,7 +289,6 @@ export async function applyDeviceAutoToOptions(options, deps = {}) {
     const acctNote = accountPickerRequested ? 'accounts=picker' : 'accounts=balanced';
     return {
         attempted: true,
-        deprecationSmart,
         banner: { hostLabel, deviceHint, acctNote },
     };
 }

package/dist/lib/snapshot.d.ts

@@ -19,7 +19,7 @@ import type { AgentId } from './types.js';
 import type { UnifiedSyncStatus } from './sync-status.js';
 import type { ViewJsonAgent } from './view-types.js';
 /** One open-block row in the optional feed summary (no full question bodies). */
-export interface SnapshotFeedBlock {
+interface SnapshotFeedBlock {
     blockId: string;
     sessionId: string;
     host: string;
@@ -66,7 +66,7 @@ export interface FleetSnapshot {
     /** Present when --with-sync (UnifiedSyncStatus; does not replace `agents sync status`). */
     sync?: UnifiedSyncStatus;
 }
-export interface ComputeSnapshotOptions {
+interface ComputeSnapshotOptions {
     /** Restrict inventory to one agent id. */
     agent?: AgentId;
     /** Local sessions only — no cross-machine SSH fan-out. Default true for cheap polls. */
@@ -101,3 +101,4 @@ export declare function assembleSnapshot(parts: {
  * `local: false` (or hosts) to match full `sessions --active` fleet scope.
  */
 export declare function computeSnapshot(opts?: ComputeSnapshotOptions): Promise<FleetSnapshot>;
+export {};