@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/fleet/capture.js

@@ -1,42 +1,11 @@
-/**
- * Serialize the live environment into a `fleet:` manifest.
- *
- * `captureFleet` is PURE — it takes the previous manifest plus already-gathered
- * inputs (device names, per-device agent specs, browser profiles, secret-bundle
- * names, routine names) and returns the new manifest. All I/O (registry read,
- * `agents secrets`/`routines` enumeration, YAML write) happens in the command
- * (`commands/fleet-capture.ts`); keeping this pure makes the privacy contract —
- * NAMES ONLY, never IPs/usernames — trivially unit-testable.
- *
- * Additive by design: it merges OVER an existing manifest and never clobbers a
- * hand-authored per-device override (`agents:` you set by hand wins over a
- * captured one). The captured roster reflects live state, so it becomes the
- * source of truth for WHICH devices exist.
- */
-/**
- * Build the new `fleet:` manifest from the previous one and captured inputs.
- * Pure — no SSH, no filesystem, no registry. The returned object carries device
- * names + desired state only; a caller that serializes it to YAML can assert no
- * address/username ever appears.
- */
 export function captureFleet(prev, inputs) {
     const prevDevices = prev && prev.devices !== 'all' && typeof prev.devices === 'object'
         ? prev.devices
         : {};
-    // Roster: explicit map of the captured names. A hand-authored override for a
-    // device that still exists is preserved; a captured agent list only fills in
-    // when the manifest didn't already pin one for that device.
-    //
-    // A device absent from `inputs.devices` drops OUT of the roster — that is the
-    // intended "live state is the source of truth for WHICH devices exist". A
-    // leftover `config:` on an override is the LEGACY #2458 store (folded into
-    // per-device docs by migrateDeviceConfigStores). Carry it forward so a
-    // capture from a box that has not seen a peer cannot re-strip a not-yet-
-    // migrated peer's settings. Config only, never its roster fields.
     const devices = {};
     for (const [name, prevOverride] of Object.entries(prevDevices)) {
         if (inputs.devices.includes(name))
-            continue; // handled by the roster loop below
+            continue;
         const config = prevOverride?.config;
         if (config && Object.keys(config).length > 0)
             devices[name] = { config };
@@ -51,16 +20,12 @@ export function captureFleet(prev, inputs) {
         devices[name] = override;
     }
     const manifest = {
-        // Keep hand-authored defaults; otherwise seed from the source snapshot.
         defaults: prev?.defaults ?? inputs.defaults ?? {},
         devices,
     };
     if (prev?.discovery && Object.keys(prev.discovery).length > 0) {
         manifest.discovery = { ...prev.discovery };
     }
-    // Dismissals are operator state, not live state — a capture must never wipe
-    // them (fleet.ignored syncs; losing it re-suggests every dismissed node
-    // fleet-wide). Carry forward verbatim, same contract as `discovery`.
     if (prev?.ignored && prev.ignored.length > 0) {
         manifest.ignored = prev.ignored.map((e) => ({ ...e }));
     }

package/dist/lib/fleet/manifest.d.ts

@@ -1,51 +1,13 @@
-/**
- * Parse + validate the `fleet:` block of a profile manifest and resolve it into
- * per-device desired state.
- *
- * `fleet:` is additive to the `Meta` schema (`types.ts`). Any `-f <file>` that
- * carries a `fleet:` block is a valid manifest, so `ag apply -f agents.yaml`
- * works against the project file. The functions here are pure (no SSH, no
- * registry I/O) so they're fully unit-testable; device enumeration is injected.
- */
 import type { FleetManifest, DeviceDesired } from './types.js';
-/** Validate a raw `fleet:` object (already YAML-parsed) into a typed manifest. */
 export declare function parseFleetManifest(raw: unknown): FleetManifest;
-/** Read a YAML file and extract + validate its `fleet:` block. */
 export declare function readFleetFile(filePath: string): FleetManifest;
 interface ResolveContext {
-    /** Device names currently online (used to expand `devices: all`). */
     onlineDevices: string[];
-    /** All registered device names (used to validate explicit entries). */
     registeredDevices: string[];
-    /** The source machine, always excluded from the target set. */
     source: string;
-    /** Names the bootstrap could not resolve from Tailscale (off-tailnet, ignored,
-     * or a typo). These are SKIPPED with the caller's warning rather than aborting
-     * the whole reconcile — a manifest naming an asleep laptop must not hard-fail
-     * every other device. Without a bootstrap, this is empty and an unregistered
-     * name still throws (genuine misconfig, caught early). */
     unresolved?: string[];
 }
-/**
- * Expand a manifest into concrete per-device desired states. `devices: all`
- * expands to every online registered device minus the source; an explicit map
- * validates each name against the registry. Devices with no desired agents,
- * sync scopes, and `login: skip` are still returned (probe/report only).
- */
 export declare function resolveDesired(manifest: FleetManifest, ctx: ResolveContext): DeviceDesired[];
-/**
- * The message to print when a reconcile resolved zero target devices.
- *
- * An explicitly empty roster (`fleet.devices: {}` — the default on a fresh box)
- * is the ACTIONABLE case: the engine ran fine, there is simply nothing declared
- * to converge, so name the empty key and how to fill it. A gray "nothing to
- * apply" there reads like the command is dead — the exact confusion that made
- * `apply` look like a broken command during the RUSH-2981 surface review
- * (PHNX-3422). Any OTHER zero-target case (a `devices: all` fleet with no online
- * peers, or an explicit roster whose every name was unresolved — off-tailnet,
- * ignored, or a typo, the only names `resolveDesired` drops) already had its
- * reason surfaced above, so it stays a plain note.
- */
 export declare function emptyTargetsMessage(manifest: FleetManifest): {
     style: 'hint' | 'plain';
     lines: string[];

package/dist/lib/fleet/manifest.js

@@ -1,12 +1,3 @@
-/**
- * Parse + validate the `fleet:` block of a profile manifest and resolve it into
- * per-device desired state.
- *
- * `fleet:` is additive to the `Meta` schema (`types.ts`). Any `-f <file>` that
- * carries a `fleet:` block is a valid manifest, so `ag apply -f agents.yaml`
- * works against the project file. The functions here are pure (no SSH, no
- * registry I/O) so they're fully unit-testable; device enumeration is injected.
- */
 import * as fs from 'fs';
 import * as yaml from 'yaml';
 const LOGIN_MODES = ['sync', 'skip'];
@@ -41,12 +32,9 @@ function validateDefaults(v, where) {
         agents: o.agents,
         sync: o.sync,
         login: validateLogin(o.login, where),
-        // `config:` is operator config (`agents devices config`); inert to the
-        // reconcile engine but part of the manifest shape.
         config: o.config,
     };
 }
-/** Validate a raw `fleet:` object (already YAML-parsed) into a typed manifest. */
 export function parseFleetManifest(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         throw new Error('fleet: block must be a mapping with a `devices:` key.');
@@ -63,10 +51,6 @@ export function parseFleetManifest(raw) {
     else if (typeof o.devices === 'object' && o.devices !== null && !Array.isArray(o.devices)) {
         const map = {};
         for (const [name, ov] of Object.entries(o.devices)) {
-            // An empty entry (`device: {}`) inherits defaults — represent as {}.
-            // (A per-device `config:` here is the LEGACY #2458 store — parsed through
-            // so reads stay lossless, folded into the per-device doc by the config
-            // migration, never written by current code.)
             map[name] = ov == null ? {} : validateDefaults(ov, `devices.${name}`);
         }
         devices = map;
@@ -88,7 +72,6 @@ export function parseFleetManifest(raw) {
         }
         manifest.discovery = discovery;
     }
-    // Additive, backward-compatible extras (captured by `agents fleet capture`).
     if (o.secrets !== undefined) {
         if (typeof o.secrets !== 'object' || o.secrets === null || Array.isArray(o.secrets)) {
             throw new Error('fleet: secrets must be a mapping with a `bundles:` list.');
@@ -107,7 +90,6 @@ export function parseFleetManifest(raw) {
     }
     return manifest;
 }
-/** Read a YAML file and extract + validate its `fleet:` block. */
 export function readFleetFile(filePath) {
     if (!fs.existsSync(filePath)) {
         throw new Error(`Manifest not found: ${filePath}`);
@@ -128,7 +110,6 @@ export function readFleetFile(filePath) {
     }
     return parseFleetManifest(fleet);
 }
-/** Merge a per-device override over defaults into a concrete desired state. */
 function mergeDesired(device, defaults, override) {
     return {
         device,
@@ -137,12 +118,6 @@ function mergeDesired(device, defaults, override) {
         login: override.login ?? defaults.login ?? 'sync',
     };
 }
-/**
- * Expand a manifest into concrete per-device desired states. `devices: all`
- * expands to every online registered device minus the source; an explicit map
- * validates each name against the registry. Devices with no desired agents,
- * sync scopes, and `login: skip` are still returned (probe/report only).
- */
 export function resolveDesired(manifest, ctx) {
     const defaults = manifest.defaults ?? {};
     const out = [];
@@ -158,8 +133,6 @@ export function resolveDesired(manifest, ctx) {
     for (const [name, override] of Object.entries(manifest.devices)) {
         if (name === ctx.source)
             continue;
-        // Bootstrap couldn't register this name (off-tailnet / ignored / typo) —
-        // skip it (the caller already surfaced it) instead of aborting the run.
         if (unresolved.has(name))
             continue;
         if (!ctx.registeredDevices.includes(name)) {
@@ -169,19 +142,6 @@ export function resolveDesired(manifest, ctx) {
     }
     return out;
 }
-/**
- * The message to print when a reconcile resolved zero target devices.
- *
- * An explicitly empty roster (`fleet.devices: {}` — the default on a fresh box)
- * is the ACTIONABLE case: the engine ran fine, there is simply nothing declared
- * to converge, so name the empty key and how to fill it. A gray "nothing to
- * apply" there reads like the command is dead — the exact confusion that made
- * `apply` look like a broken command during the RUSH-2981 surface review
- * (PHNX-3422). Any OTHER zero-target case (a `devices: all` fleet with no online
- * peers, or an explicit roster whose every name was unresolved — off-tailnet,
- * ignored, or a typo, the only names `resolveDesired` drops) already had its
- * reason surfaced above, so it stays a plain note.
- */
 export function emptyTargetsMessage(manifest) {
     const rosterEmpty = manifest.devices !== 'all' && Object.keys(manifest.devices).length === 0;
     if (rosterEmpty) {

package/dist/lib/fleet/types.d.ts

@@ -1,212 +1,75 @@
-/**
- * Shared types for the fleet profile-sync feature (`agents apply` / `ag apply`).
- *
- * `agents.yaml` gains an additive `fleet:` block that declares a *profile*: which
- * agents every device should have installed, which config scopes to reconcile,
- * and whether logins/tokens propagate. `apply` reconciles the live fleet to it.
- *
- * These types are the contract shared by the manifest parser (`manifest.ts`),
- * the reconcile engine (`apply.ts`), the auth propagation (`auth-sync.ts`), and
- * the command (`commands/apply.ts`). Runtime probe/diff shapes live here too so
- * the pure diff can be unit-tested without SSH.
- */
-/**
- * How login/token state propagates to a device.
- * - `sync` (default): push portable credentials where possible, surface the rest
- *   as a manual login.
- * - `skip`: probe/report only; take no login action.
- * (A per-agent interactive `prompt` mode is intentionally not offered yet — it
- * was removed rather than accepted as a silent no-op that behaves like `skip`.)
- */
 export type FleetLoginMode = 'sync' | 'skip';
-/** Defaults applied to every targeted device unless a per-device entry overrides. */
 export interface FleetDefaults {
-    /** Agent specs to ensure installed, e.g. `['claude@latest', 'codex@latest']`. */
     agents?: string[];
-    /** Config sync scopes to reconcile on each device, e.g. `['user']`. */
     sync?: string[];
-    /** Login propagation strategy. Default `'sync'`. */
     login?: FleetLoginMode;
-    /**
-     * Fleet-wide config defaults (`agents devices config --fleet <key> <value>`)
-     * — the middle layer of the device-config store: built-in default <
-     * `fleet.defaults.config` < per-device `devices/<name>/agents.yaml`
-     * `config:`. Inert to the reconcile engine (apply never pushes it; it takes
-     * effect through the config read path). Names and non-secret values only.
-     */
     config?: Record<string, unknown>;
 }
-/** Per-device override; any omitted field inherits from `defaults`. */
 export interface FleetDeviceOverride {
     agents?: string[];
     sync?: string[];
     login?: FleetLoginMode;
-    /**
-     * LEGACY home of per-device operator config (#2458); the current store is the
-     * per-device doc `devices/<name>/agents.yaml` `config:` block. Existing
-     * values are folded into the device doc by lib/devices/config-migration.ts
-     * and stripped here — current code never writes this field.
-     */
     config?: Record<string, unknown>;
 }
-/**
- * The `fleet:` block as it appears in `agents.yaml` (or any `-f` file). `devices`
- * is either the literal string `'all'` (every online registered device minus the
- * source machine) or an explicit map of device-name -> override.
- */
 export interface FleetManifest {
     defaults?: FleetDefaults;
     devices: 'all' | Record<string, FleetDeviceOverride>;
-    /**
-     * Fleet-wide extras captured by `agents fleet capture` so a fresh machine can
-     * reconstruct the whole environment, not just installed agents. All additive,
-     * portable, and LEAK-FREE — names only, never connection details.
-     *
-     * (Browser profiles are deliberately NOT captured here: the central `browser:`
-     * block already syncs verbatim via `agents repo push/pull`, so duplicating it
-     * would be redundant — and its ssh:// endpoints can carry `user@host`, which
-     * must never be copied into a second location.)
-     */
-    /** Secrets-bundle NAMES to ensure exist — values live in the keychain and are
-     * never captured or pushed; `apply` surfaces missing bundles to recreate. */
     secrets?: {
         bundles?: string[];
     };
-    /** Routine NAMES that should be active on the fleet (files sync via the repo). */
     routines?: string[];
-    /**
-     * Portable user decisions for Tailscale discovery. A name maps to `approved`
-     * or `ignored`; absence means pending. Connection metadata remains in each
-     * machine's local device registry and is never committed.
-     */
     discovery?: Record<string, 'approved' | 'ignored'>;
-    /**
-     * Tailnet node names the user dismissed from auto-discovery, with who
-     * dismissed each and when. Lives here rather than in a per-device doc because
-     * a dismissed node is deliberately NOT a device — it never enters the
-     * registry, so it has no per-device folder. Syncs fleet-wide with the rest of
-     * `agents.yaml`, so a dismissal on one box stops the suggestion on every box.
-     */
     ignored?: IgnoredDeviceEntry[];
 }
-/** One dismissal record in {@link FleetManifest.ignored}. */
 export interface IgnoredDeviceEntry {
-    /** Tailscale node name the user dismissed. */
     name: string;
-    /** ISO-8601 timestamp of the dismissal. */
     ignoredAt: string;
-    /** machineId() of the box the dismissal was made on. */
     ignoredOn: string;
 }
-/**
- * A device's desired state after merging defaults with its override and
- * expanding `devices: all`. This is what the reconcile engine drives toward.
- */
 export interface DeviceDesired {
-    /** Registered device name (from `agents devices`). */
     device: string;
-    /** Resolved agent specs to ensure installed. */
     agents: string[];
-    /** Config sync scopes. */
     sync: string[];
-    /** Login propagation strategy for this device. */
     login: FleetLoginMode;
 }
-/**
- * What a probe found on one device. Populated from `readyProbe` plus an
- * installed-agents listing; `reachable: false` short-circuits everything else.
- */
 export interface DeviceProbe {
     device: string;
     reachable: boolean;
-    /** Platform of the device (`linux` | `macos` | `windows`), for login classification. */
     platform?: string;
-    /** agents-cli version present on the device (undefined if not installed). */
     cliVersion?: string;
-    /** Agent ids currently installed on the device. */
     installedAgents: string[];
-    /**
-     * Installed version strings per agent id (e.g. `{ claude: ['2.1.170', '2.1.207'] }`),
-     * parsed from `agents view --json` on the device. Only populated when the plan
-     * involves a version-pinned spec (`claude@2.1.170`, or a `claude@all` expansion)
-     * — a bare `claude`/`claude@latest` roster never pays for the extra probe. When
-     * undefined, version-pinned specs fall back to id-level presence.
-     */
     installedVersions?: Record<string, string[]>;
-    /**
-     * Secrets bundles already present on the device: name -> `updated_at` (or ''
-     * when the remote reports none). Only populated when the manifest declares
-     * bundles AND `--provision-secrets` is set — a fleet that uses no bundles
-     * never pays for the extra round trip.
-     *
-     * METADATA ONLY. `agents secrets list --json` returns names and timestamps and
-     * explicitly never values, which is what makes this probe safe to run.
-     */
     remoteBundles?: Record<string, string>;
-    /** Reason string when `reachable` is false or the probe partially failed. */
     note?: string;
 }
-/** One planned action against a device, in a single reconcile dimension. */
-export type FleetActionKind = 'install-cli' | 'upgrade-cli' | 'add-agent' | 'sync-config' | 'needs-login'
-/** Push a declared secrets bundle to the device over SSH. Opt-in only
- * (`--provision-secrets`) and gated on a pinned host key, because this moves
- * credential VALUES to another machine (RUSH-1968). */
- | 'push-secret'
-/** A declared secrets bundle that could NOT be pushed — the flag is off, the
- * host key isn't pinned, or the bundle is already current. Surfaced as a manual
- * recreate, like `needs-login`. */
- | 'needs-secret';
+export type FleetActionKind = 'install-cli' | 'upgrade-cli' | 'add-agent' | 'sync-config' | 'needs-login' | 'push-secret' | 'needs-secret';
 export interface FleetAction {
     device: string;
     kind: FleetActionKind;
-    /** Agent id for agent/login actions; undefined for cli/config actions. */
     agent?: string;
-    /** Full agent spec for `add-agent` (e.g. `claude@2.1.170`) so the plan can show
-     * the exact version being installed; equals the id for a bare/latest spec. */
     spec?: string;
-    /** Bundle name for `push-secret` / `needs-secret`, so the executor pushes the
-     *  bundle the planner decided on rather than re-deriving it from the detail
-     *  string. */
     bundle?: string;
-    /** Human, one-line description of the action. */
     detail: string;
 }
-/**
- * The full reconcile plan: per-device desired vs probed, plus the flat list of
- * actions. Pure output of `diffFleet(desired, probes)` — drives both `--plan`
- * rendering and the confirm prompt.
- */
 export interface FleetPlan {
     devices: DeviceDiff[];
     actions: FleetAction[];
 }
-/** Per-device diff row rendered in the plan matrix. */
 export interface DeviceDiff {
     device: string;
     desired: DeviceDesired;
     probe: DeviceProbe;
     actions: FleetAction[];
-    /** Agents that must be logged in on the device but can't be propagated
-     * (source token is device-bound, e.g. macOS keychain). Surfaced, not faked. */
     loginBlocked: string[];
-    /** Secrets-bundle names the profile declares that must be recreated on the
-     * device (values are keychain-local — never captured or pushed). Surfaced. */
     secretsNeeded: string[];
 }
-/** A portable auth file captured from a source agent home, ready to propagate. */
 export interface AuthFilePayload {
-    /** Agent id this file belongs to. */
     agent: string;
-    /** Path relative to the agent's config dir (or $HOME), reconstructed on target. */
     rel: string;
-    /** File contents, base64. */
     contentB64: string;
-    /** POSIX mode to restore (e.g. 0o600 for credentials). */
     mode: number;
 }
-/** Result of classifying one source agent's auth for propagation. */
 export interface AuthSnapshotResult {
     files: AuthFilePayload[];
-    /** Agent ids whose auth is device-bound (keychain) and cannot be captured. */
     bound: string[];
 }

package/dist/lib/fleet/types.js

@@ -1,13 +1 @@
-/**
- * Shared types for the fleet profile-sync feature (`agents apply` / `ag apply`).
- *
- * `agents.yaml` gains an additive `fleet:` block that declares a *profile*: which
- * agents every device should have installed, which config scopes to reconcile,
- * and whether logins/tokens propagate. `apply` reconciles the live fleet to it.
- *
- * These types are the contract shared by the manifest parser (`manifest.ts`),
- * the reconcile engine (`apply.ts`), the auth propagation (`auth-sync.ts`), and
- * the command (`commands/apply.ts`). Runtime probe/diff shapes live here too so
- * the pure diff can be unit-tested without SSH.
- */
 export {};

package/dist/lib/fleet-cache.d.ts

@@ -1,20 +1,8 @@
 import { type FleetStatusRow } from './fleet-status.js';
-/**
- * The fleet-status union the daemon publishes (own row) and the fleet-status
- * command unions (peer rows) — this host's stats + agent workload for every
- * known host, keyed by host. Cache-only: a cold mirror yields an empty map.
- */
 export declare function readFleetStatus(): Record<string, FleetStatusRow>;
 export type { FleetStatusRow };
-/** An account's projected headroom, as published by the daemon refresher. */
 interface AccountHeadroom {
     status: 'available' | 'rate_limited' | null;
-    /** Projected minutes until the session window caps; null = unknown/idle. */
     minutesToLimit: number | null;
 }
-/**
- * The daemon-computed headroom for an account, or null when nothing has been
- * published yet. Cache-only — a cold cache simply yields null, and callers
- * degrade to snapshot-only behavior.
- */
 export declare function readAccountHeadroom(usageKey: string): AccountHeadroom | null;

package/dist/lib/fleet-cache.js

@@ -1,32 +1,8 @@
-/**
- * One synchronous, disk-only read facade over the fleet/usage caches.
- *
- * These readers NEVER touch the network and NEVER SSH — they read the caches
- * the daemon keeps warm (usage snapshot, projected headroom, fleet status) and
- * return instantly. That is the whole point: the routing hot path
- * (`agents run` → rotate.ts), device affinity (smart-launch.ts), and Factory can
- * consult live-ish fleet state without paying a provider fetch or an ssh probe
- * on a latency-sensitive path.
- *
- * Writers live elsewhere (the daemon's `runUsageRefresh` for usage/headroom,
- * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
- * side only.
- */
 import { readHeadroomEntry } from './usage-refresh.js';
 import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
-/**
- * The fleet-status union the daemon publishes (own row) and the fleet-status
- * command unions (peer rows) — this host's stats + agent workload for every
- * known host, keyed by host. Cache-only: a cold mirror yields an empty map.
- */
 export function readFleetStatus() {
     return readFleetStatusMirror();
 }
-/**
- * The daemon-computed headroom for an account, or null when nothing has been
- * published yet. Cache-only — a cold cache simply yields null, and callers
- * degrade to snapshot-only behavior.
- */
 export function readAccountHeadroom(usageKey) {
     const entry = readHeadroomEntry(usageKey);
     if (!entry)

package/dist/lib/fleet-shared-state.d.ts

@@ -2,16 +2,6 @@ import type { CachedUsageSnapshot } from './accounting/usage.js';
 export declare const FLEET_SHARED_STATE_VERSION = 1;
 export declare const FLEET_SHARED_STATE_FILE = "daemon-state.json";
 export type SharedAuthStatus = 'ready' | 'missing' | 'invalid';
-/**
- * One session's lightweight preview/metadata, mirrored to the fleet so the
- * interactive device renders a remote-host row's topic/preview INLINE instead of
- * fetching the peer's digest live over SSH per row (PHNX-3792). Deliberately
- * NOT a full transcript: only the fields a list row and a compact preview card
- * need. `machine` is the EXECUTION host the publisher recorded (so an offloaded
- * session's mirror row matches the same `machine:id` key the live fan-out uses,
- * never double-counting), `firstUser` is a bounded first-user-message snippet,
- * and `capturedAt` stamps publish time for the staleness marker.
- */
 export interface SessionMirrorRow {
     id: string;
     shortId: string;
@@ -21,27 +11,19 @@ export interface SessionMirrorRow {
     cwd?: string;
     topic?: string;
     label?: string;
-    /** The publisher's daemon-generated headline (PHNX-3797), when it has produced one. */
     title?: string;
     firstUser?: string;
     lastActivity?: string;
     timestamp: string;
     ticketId?: string;
     prUrl?: string;
-    /** Daemon-computed goal (PHNX-3939) — carried so a peer renders it with no transcript. */
     goal?: string;
-    /** Daemon-computed progress checkpoints, newest last (PHNX-3939). */
-    checkpoints?: import('./session/types.js').SessionCheckpoint[];
-    /** Daemon-computed detailed checklist (PHNX-3939). */
-    summaryChecklist?: import('./session/types.js').SessionChecklistItem[];
-    /** Lifecycle of the daemon-computed summary (PHNX-3939). */
-    summaryState?: import('./session/types.js').SummaryState;
-    /** Tidied latest user turn, so a peer row shows what the agent was asked (PHNX-3939). */
-    request?: import('./session/types.js').SessionRequest;
-    /** Bounded narration-anchored steps, so a peer row shows what the agent did. */
-    timeline?: import('./session/types.js').SessionTimeline;
-    /** Bounded file-change list for the peer row. */
-    files?: import('./session/types.js').SessionFiles;
+    checkpoints?: import('@phnx-labs/sessions-cli/reader').SessionCheckpoint[];
+    summaryChecklist?: import('@phnx-labs/sessions-cli/reader').SessionChecklistItem[];
+    summaryState?: import('@phnx-labs/sessions-cli/reader').SummaryState;
+    request?: import('@phnx-labs/sessions-cli/reader').SessionRequest;
+    timeline?: import('@phnx-labs/sessions-cli/reader').SessionTimeline;
+    files?: import('@phnx-labs/sessions-cli/reader').SessionFiles;
     capturedAt: number;
 }
 export interface FleetSharedDeviceState {
@@ -56,19 +38,9 @@ export interface FleetSharedDeviceState {
     sessions?: {
         rows: SessionMirrorRow[];
     };
-    /**
-     * Per-account auth verdict rows, written by the account-state daemon service
-     * (`account-state-daemon-service.ts`) and read by `readSharedAccountVerdicts`.
-     * Opaque here: the envelope carries them across the exchange unchanged.
-     */
     accounts?: {
         rows: unknown[];
     };
-    /**
-     * Epoch ms this box received the envelope from its owner over the SSH
-     * exchange. Present ONLY in a peer's file on this box, never in a device's own
-     * file. auth-sync reads it per peer to know that peer has replied at all.
-     */
     receivedAt?: number;
 }
 interface FleetSharedStatePatch {
@@ -85,14 +57,7 @@ interface FleetSharedStateReadResult {
         message: string;
     }>;
 }
-/** Path owned by one device in the conflict-free tracked device-doc tree. */
 export declare function fleetSharedStatePath(device: string, userAgentsDir?: string): string;
-/**
- * Validate an already-parsed envelope. `owner` pins the `device` field when the
- * caller knows whose envelope this must be (a file under `devices/<owner>/`);
- * an envelope arriving over the exchange names its own owner, so the caller
- * passes none and checks `device` against the dialed peer afterwards.
- */
 export declare function parseFleetSharedDeviceStateEnvelope(parsed: unknown, owner?: string): FleetSharedDeviceState;
 export declare function updateFleetSharedDeviceState(device: string, patch: FleetSharedStatePatch, userAgentsDir?: string): {
     changed: boolean;
@@ -110,26 +75,8 @@ export declare function updateFleetSharedDeviceStateAsync(device: string, patch:
     changed: boolean;
     path: string;
 }>;
-/** Read every valid peer-owned state file; malformed peers fail separately. */
 export declare function readFleetSharedDeviceStates(userAgentsDir?: string): FleetSharedStateReadResult;
-/**
- * This device's own envelope as it stands on disk — what the usage-sync exchange
- * sends to peers and what `__usage-ingest --reply` prints back. A device that has
- * never published anything yields the bare `{version, device}` envelope, so a
- * peer still learns the device exists and answered.
- */
 export declare function readOwnFleetSharedDeviceState(device: string, userAgentsDir?: string): FleetSharedDeviceState;
-/**
- * Store a PEER's envelope, received over the SSH exchange, in that peer's file on
- * this box, stamped with `receivedAt`. Merges field-by-field onto whatever the
- * file already holds, so a partial envelope (a placement probe sends usage only)
- * refreshes that field without erasing the peer's last auth verdict, session
- * digests, or account rows. The five readers of `devices/<peer>/daemon-state.json`
- * (usage merge, poller claims, auth verdicts, session mirror, account catalog)
- * are unchanged by the transport swap. Async because it runs on the daemon's
- * usage-sync tick once per peer reply: the sync lock would `sleepSync` the event
- * loop for up to 30 s under contention (see {@link updateFleetSharedDeviceStateAsync}).
- */
 export declare function storePeerFleetSharedDeviceState(state: FleetSharedDeviceState, userAgentsDir?: string, receivedAt?: number): Promise<{
     changed: boolean;
     path: string;