@phnx-labs/agents-cli 1.21.0 → 1.21.2

package/dist/lib/feed-broadcast.js

@@ -23,8 +23,20 @@
  *
  * Delivery is best-effort and reported: a sink that fails prints a warning and
  * the post still stands. Losing a mirror must never cost the operator the post.
+ *
+ * A second sink shape (RUSH-2123) delivers **in-process** through the same
+ * channel-provider registry `agents send` uses (`channel:` instead of
+ * `command:`) — no spawn, no argv templating. `channel: owner` is the address
+ * alias that expands to `notify.owner.{channel,to}`, matching `agents notify`.
+ * When the operator has never written a `feed.broadcast` block at all, an
+ * important-level post falls back to that owner address implicitly
+ * ({@link effectiveBroadcastConfig}) rather than reaching nobody — see that
+ * function's doc for why this was a silent failure before.
  */
 import { spawnSync } from 'child_process';
+import { isOwnerAlias, readOwnerDest, resolveSendEnvelope, deliverEnvelope } from './channels/send.js';
+import { lookupTransport } from './channels/resolve.js';
+import { registerBuiltinProviders } from './channels/providers/index.js';
 const LEVEL_RANK = { milestone: 0, important: 1 };
 /** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
 export function parseFeedPostLevel(raw) {
@@ -50,8 +62,12 @@ export function parseFeedPostLevel(raw) {
 export function blockBroadcastContext(block, extras = {}) {
     const ask = block.questions?.[0]?.text?.trim() || 'agent is blocked';
     const links = [block.pr].filter((l) => !!l && /^https?:\/\//i.test(l));
+    // Prefer explicit title/body from the feed post; fall back to the ask as body.
+    const title = extras.title?.trim() || undefined;
+    const text = extras.body?.trim() || ask;
     return {
-        text: ask,
+        ...(title ? { title } : {}),
+        text,
         level: 'important',
         ticket: block.ticket,
         project: extras.project,
@@ -92,24 +108,118 @@ export function blockDeliveryFailure(blocked, outcomes) {
 }
 const PLACEHOLDER = /\{([a-z]+)\}/g;
 /**
- * A human-facing one-liner for a messaging sink: what project, what happened,
- * and the link to go read more. Leading with the project is deliberate — a
- * message that opens with an agent name tells the reader nothing about which of
- * their projects just moved.
+ * Short host label for a phone line — strip user@ and domain so
+ * `muqsit@mac-mini.tailnet.ts.net` reads as `mac-mini`.
+ */
+export function shortHost(host) {
+    if (!host?.trim())
+        return undefined;
+    let h = host.trim();
+    const at = h.lastIndexOf('@');
+    if (at !== -1)
+        h = h.slice(at + 1);
+    const dot = h.indexOf('.');
+    if (dot > 0)
+        h = h.slice(0, dot);
+    return h || undefined;
+}
+/** First 8 hex chars of a session id for the footer (readable, not a full uuid). */
+export function shortSessionChunk(session) {
+    if (!session?.trim())
+        return undefined;
+    const hex = session.replace(/-/g, '').toLowerCase();
+    const chunk = hex.replace(/[^a-f0-9]/g, '').slice(0, 8);
+    return chunk || undefined;
+}
+/**
+ * Scrub em/en dashes from outbound phone copy (house rule + iMessage readability).
+ * Collapses whitespace; does not invent meaning.
+ */
+export function scrubOutboundDashes(text) {
+    return text
+        .replace(/\u2014/g, ' - ')
+        .replace(/\u2013/g, ' - ')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
+/**
+ * Footer like "Sent from my iPhone" — who posted, a session crumb, which box.
+ *
+ *   Sent from grok/a02da0e2 on mac-mini
+ *
+ * Agent name first; session chunk for disambiguation when many groks run;
+ * host last. Skip the uninformative default label `agent`.
+ */
+export function composeBroadcastFooter(ctx) {
+    const agent = ctx.agent?.trim();
+    const agentLabel = agent && agent !== 'agent' ? agent : undefined;
+    const session = shortSessionChunk(ctx.session);
+    const host = shortHost(ctx.host);
+    let who;
+    if (agentLabel && session)
+        who = `${agentLabel}/${session}`;
+    else if (agentLabel)
+        who = agentLabel;
+    else if (session)
+        who = session;
+    if (who && host)
+        return `Sent from ${who} on ${host}`;
+    if (who)
+        return `Sent from ${who}`;
+    if (host)
+        return `Sent from host ${host}`;
+    return undefined;
+}
+/**
+ * Human-facing body for a messaging sink (`{message}`).
+ *
+ * ```
+ * Title in a few words
+ *
+ * Body of what happened or the ask.
+ *
+ * Sent from grok/a02da0e2 on mac-mini
+ * agents focus a02da0e2          (blocks only)
+ * https://…                      (optional attach URL)
+ * ```
+ *
+ * Title first (scannable subject). Blank line. Body. Footer provenance so a
+ * fleet of agents is attributable without crowding the ask. Prefer `{message}`
+ * over bare `{text}` in messaging sinks.
  */
 export function composeBroadcastMessage(ctx) {
-    const head = ctx.project ? `${ctx.project} · ${ctx.text}` : ctx.text;
+    const title = scrubOutboundDashes(ctx.title ?? '');
+    const body = scrubOutboundDashes(ctx.text ?? '');
+    // Title preferred; if an older post has no title, body alone still sends.
+    const head = title || body;
+    const mid = title && body && title !== body ? body : undefined;
+    const footer = composeBroadcastFooter(ctx);
     const link = ctx.links?.find((l) => /^https?:\/\//i.test(l));
-    // A block's second line is the command that unblocks it. The operator reading
-    // this on a phone should not have to go find the session — the one action they
-    // must take travels with the ask. A status post has no such action, so it keeps
-    // the link there instead.
-    const tail = [ctx.focus, link].filter(Boolean);
-    return tail.length ? `${head}\n${tail.join('\n')}` : head;
+    // Block focus and link trail after the "Sent from" footer so the human
+    // sentence stays at the top and the action/link are still one glance away.
+    const trail = [footer, ctx.focus, link].filter(Boolean);
+    const parts = [];
+    if (head)
+        parts.push(head);
+    if (mid) {
+        // Blank line between subject and body (title, then space, then message).
+        parts.push('');
+        parts.push(mid);
+    }
+    if (trail.length) {
+        // Blank line before the footer block (iPhone "Sent from my iPhone" spacing).
+        if (parts.length)
+            parts.push('');
+        parts.push(trail.join('\n'));
+    }
+    return parts.join('\n').trim();
 }
 /** The values a template may reference, resolved once per post. */
 function templateVars(ctx) {
     return {
+        title: ctx.title,
         text: ctx.text,
         ticket: ctx.ticket,
         project: ctx.project,
@@ -153,17 +263,39 @@ export function renderSinkArgv(template, ctx) {
 /**
  * Which sinks this post reaches, in config order. Pure — the dry-run listing and
  * the real fan-out plan through here, so what `--dry-run` shows is what runs.
+ *
+ * A `channel:` sink is gated by the same `minLevel` rule as a `command:` sink —
+ * one level check for both shapes, so a dry-run plan is truthful regardless of
+ * which shape an operator's sink uses.
  */
 export function planFeedBroadcast(config, ctx) {
     if (!config)
         return [];
     const planned = [];
     for (const [name, sink] of Object.entries(config)) {
-        if (!Array.isArray(sink?.command) || sink.command.length === 0)
+        if (!sink)
             continue;
         const min = sink.minLevel ?? 'milestone';
         if (LEVEL_RANK[ctx.level] < LEVEL_RANK[min])
             continue;
+        const channel = sink.channel?.trim();
+        if (channel) {
+            // The owner alias resolves its recipient from notify.owner at delivery
+            // time; any other channel name needs an explicit recipient now, or the
+            // sink can never fire with a hole in it (same contract as a missing argv
+            // placeholder below).
+            if (!isOwnerAlias(channel) && !sink.to?.trim())
+                continue;
+            planned.push({
+                name,
+                channel,
+                to: isOwnerAlias(channel) ? undefined : sink.to.trim(),
+                text: composeBroadcastMessage(ctx),
+            });
+            continue;
+        }
+        if (!Array.isArray(sink.command) || sink.command.length === 0)
+            continue;
         const argv = renderSinkArgv(sink.command, ctx);
         if (!argv)
             continue;
@@ -172,24 +304,97 @@ export function planFeedBroadcast(config, ctx) {
     return planned;
 }
 /**
- * Run the planned sinks. Each is a direct spawn with a bounded lifetime; a sink
- * that fails or is not installed is reported, never thrown — the post is already
- * written and must not be undone by a mirror that could not be reached.
+ * The effective sink config for a post: the operator's `feed.broadcast`, or —
+ * when that is unset or empty — an implicit fallback straight to
+ * `notify.owner`, for a post worth interrupting someone over.
+ *
+ * Before this, `broadcastPostedEvent`/`broadcastBlock` returned early the
+ * moment `feed.broadcast` was empty, even when `notify.owner` was fully
+ * configured — so the common case (an operator who set up owner notifications
+ * but never wrote a `feed.broadcast` block) produced a `--blocked` post that
+ * looked recorded and reached nobody. `agents notify` already treats
+ * `notify.owner` as the default human destination; this makes an important
+ * feed post/block use that same default instead of requiring a second,
+ * redundant config block that says the same thing.
+ *
+ * The fallback only fires for `important` — a routine `milestone` post stays
+ * record-only, matching the `minLevel` contract every declared sink already
+ * follows. An operator-declared `feed.broadcast` (any non-empty config)
+ * always wins outright; the fallback never layers on top of it.
  */
-export function runFeedBroadcast(planned, timeoutMs = 20_000) {
-    return planned.map(({ name, argv }) => {
-        const result = spawnSync(argv[0], argv.slice(1), {
-            encoding: 'utf-8',
-            timeout: timeoutMs,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        if (result.error) {
-            return { name, ok: false, error: result.error.message };
+export function effectiveBroadcastConfig(config, level, meta) {
+    if (config && Object.keys(config).length > 0)
+        return config;
+    if (level !== 'important')
+        return undefined;
+    if (!readOwnerDest(meta))
+        return undefined;
+    return { owner: { channel: 'owner' } };
+}
+function runCommandSink(name, argv, timeoutMs) {
+    const result = spawnSync(argv[0], argv.slice(1), {
+        encoding: 'utf-8',
+        timeout: timeoutMs,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        return { name, ok: false, error: result.error.message };
+    }
+    if (result.status !== 0) {
+        const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-1)[0];
+        return { name, ok: false, error: tail || `exited ${result.status}` };
+    }
+    return { name, ok: true };
+}
+/**
+ * Deliver one `channel:` sink through the real provider registry —
+ * `resolveSendEnvelope` reuses `agents notify`'s owner-alias expansion, and
+ * `deliverEnvelope` is the same seam `agents send` calls. A bad channel name
+ * is checked with `lookupTransport` (the non-throwing lookup) BEFORE handing
+ * off to `deliverEnvelope`: that function's own resolution `die()`s on an
+ * unregistered provider, which is the right answer for an interactive `agents
+ * send` typo but would take the whole broadcast fan-out down with it here —
+ * one misconfigured sink must report a failure, not kill the process running
+ * every other sink.
+ */
+async function runChannelSink(sink, meta) {
+    const name = sink.name;
+    // Registration is idempotent and normally happens inside deliverEnvelope();
+    // it has to happen before the lookupTransport pre-check below too, or the
+    // very first channel sink in a process would report "no channel provider"
+    // for a name that is, in fact, registered.
+    registerBuiltinProviders();
+    const owner = isOwnerAlias(sink.channel);
+    const resolved = resolveSendEnvelope({
+        text: sink.text ?? '',
+        channel: owner ? undefined : sink.channel,
+        to: owner ? 'owner' : sink.to,
+        ownerMode: owner,
+    }, meta);
+    if (!resolved.ok)
+        return { name, ok: false, error: resolved.error };
+    const { provider, error } = lookupTransport(resolved.envelope.channel, meta);
+    if (!provider)
+        return { name, ok: false, error };
+    const result = await deliverEnvelope(resolved.envelope, meta);
+    return result.ok ? { name, ok: true } : { name, ok: false, error: result.error };
+}
+/**
+ * Run the planned sinks. A `command:` sink is a direct spawn with a bounded
+ * lifetime; a `channel:` sink delivers in-process. Either way a sink that
+ * fails or is not installed/registered is reported, never thrown — the post
+ * is already written and must not be undone by a mirror that could not be
+ * reached.
+ */
+export async function runFeedBroadcast(planned, meta, timeoutMs = 20_000) {
+    const outcomes = [];
+    for (const sink of planned) {
+        if (sink.channel) {
+            outcomes.push(await runChannelSink(sink, meta));
         }
-        if (result.status !== 0) {
-            const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-1)[0];
-            return { name, ok: false, error: tail || `exited ${result.status}` };
+        else {
+            outcomes.push(runCommandSink(sink.name, sink.argv ?? [], timeoutMs));
         }
-        return { name, ok: true };
-    });
+    }
+    return outcomes;
 }

package/dist/lib/feed-post.d.ts

@@ -2,8 +2,15 @@ import { type ActivityEvent, type Attachment } from './activity.js';
 import { type PidSessionEntry } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export declare const STATUS_POST_MAX_CHARS = 500;
+/** Title is a phone subject line - about four or five words, not a paragraph. */
+export declare const STATUS_TITLE_MAX_CHARS = 60;
 export interface FeedPostInput {
-    /** Human-readable progress text (required). Domain-agnostic free text. */
+    /**
+     * Short subject (required for new posts). ~4–5 words. Phone broadcasts put
+     * this on the first line so a scan names the topic before the body.
+     */
+    title: string;
+    /** Body text (required). Domain-agnostic free text — what happened / the ask. */
     text: string;
     /** Override session id (escape hatch for scripts/tests). Prefer auto-resolve. */
     sessionId?: string;
@@ -92,9 +99,16 @@ export declare function buildAttachments(tokens: string[] | undefined, ctx: {
     sessionId: string;
     updateId: string;
 }): Attachment[];
+/**
+ * Collapse whitespace and strip em/en dashes (house rule: no em-dashes in
+ * agent-authored outbound copy — phones and plain text render them poorly).
+ */
+export declare function scrubDashes(text: string): string;
 export declare function normalizeStatusText(text: string): string;
+/** Normalize a short subject line for a post. */
+export declare function normalizeStatusTitle(title: string): string;
 /**
  * Append a `status.posted` milestone for the calling agent.
- * Throws if text is empty or session identity cannot be resolved.
+ * Throws if title/text is empty or session identity cannot be resolved.
  */
 export declare function postFeedStatus(input: FeedPostInput): FeedPostResult;

package/dist/lib/feed-post.js

@@ -1,13 +1,14 @@
 /**
  * Agent status posts — deliberate progress messages into the activity stream.
  *
- * Surface: `agents feed post <text>` (agent-callable; humans watch via
- * `agents feed` / `agents activity` / `agents events --module activity`).
+ * Surface: `agents feed post --title <subject> <body>` (agent-callable; humans
+ * watch via `agents feed` / `agents activity` / `agents events --module activity`).
  *
  * Identity is automatic: session id, agent, cwd, launch/pid/tmux provenance
  * are resolved from the process environment and the per-pid launch registry
- * (`lib/session/pid-registry.ts`). The agent only authors free-form text —
- * no domain-specific flags (tickets, URLs, tracks).
+ * (`lib/session/pid-registry.ts`). The agent authors a short title + body —
+ * no domain-specific flags (tickets, URLs, tracks). Phone `{message}` ends with
+ * a "Sent from agent/session on host" footer.
  *
  * Storage: append-only activity log as a `status.posted` milestone. Does NOT
  * open a feed block (blocks remain "needs you" state only).
@@ -23,6 +24,8 @@ import { isValidMailboxId } from './mailbox.js';
 import { listPidSessionEntries, readPidSessionEntry, } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export const STATUS_POST_MAX_CHARS = 500;
+/** Title is a phone subject line - about four or five words, not a paragraph. */
+export const STATUS_TITLE_MAX_CHARS = 60;
 /**
  * Resolve who is posting. Order:
  *  1. Explicit --session flag
@@ -241,22 +244,46 @@ export function buildAttachments(tokens, ctx) {
     }
     return out;
 }
+/**
+ * Collapse whitespace and strip em/en dashes (house rule: no em-dashes in
+ * agent-authored outbound copy — phones and plain text render them poorly).
+ */
+export function scrubDashes(text) {
+    return text
+        .replace(/\u2014/g, ' - ') // em dash —
+        .replace(/\u2013/g, ' - ') // en dash –
+        .replace(/\s+/g, ' ')
+        .trim();
+}
 export function normalizeStatusText(text) {
-    const collapsed = text.replace(/\s+/g, ' ').trim();
+    const collapsed = scrubDashes(text);
     if (!collapsed)
         return '';
     if (collapsed.length <= STATUS_POST_MAX_CHARS)
         return collapsed;
     return `${collapsed.slice(0, STATUS_POST_MAX_CHARS - 1)}…`;
 }
+/** Normalize a short subject line for a post. */
+export function normalizeStatusTitle(title) {
+    const collapsed = scrubDashes(title);
+    if (!collapsed)
+        return '';
+    if (collapsed.length <= STATUS_TITLE_MAX_CHARS)
+        return collapsed;
+    return `${collapsed.slice(0, STATUS_TITLE_MAX_CHARS - 1)}…`;
+}
 /**
  * Append a `status.posted` milestone for the calling agent.
- * Throws if text is empty or session identity cannot be resolved.
+ * Throws if title/text is empty or session identity cannot be resolved.
  */
 export function postFeedStatus(input) {
+    const title = normalizeStatusTitle(input.title ?? '');
     const detail = normalizeStatusText(input.text);
+    if (!title) {
+        throw new Error('Title is empty. Usage: agents feed post --title "Short subject" "what just happened"');
+    }
     if (!detail) {
-        throw new Error('Status text is empty. Usage: agents feed post "what just happened"');
+        throw new Error('Status text is empty. Usage: agents feed post --title "Short subject" "what just happened"');
     }
     const identity = resolvePostIdentity(input);
     if (!identity) {
@@ -285,6 +312,7 @@ export function postFeedStatus(input) {
         cwd: identity.cwd,
         agent: identity.agent,
         tool: 'feed.post',
+        title,
         detail,
         ...(project ? { project } : {}),
         ...(identity.pid !== undefined ? { pid: identity.pid } : {}),

package/dist/lib/feed.js

@@ -255,7 +255,7 @@ export function clearBlockLifecycle(blockId, root) {
 export function buildDeclaredBlock(agent, input) {
     const text = input.text.trim().replace(/\s+/g, ' ');
     if (!text) {
-        throw new Error('Block text is empty. Usage: agents feed post "what you need from the user" --blocked');
+        throw new Error('Block text is empty. Usage: agents feed post --title "Short subject" "what you need from the user" --blocked');
     }
     const options = (input.options ?? [])
         .map((label) => label.trim())

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

@@ -0,0 +1,37 @@
+/**
+ * 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 { type UsageSnapshot } from './usage.js';
+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 };
+/** The last cached usage snapshot for an account, or null. Cache-only. */
+export declare function readAccountUsage(usageKey: string): UsageSnapshot | null;
+/** An account's projected headroom, as published by the daemon refresher. */
+export 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

@@ -0,0 +1,40 @@
+/**
+ * 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 { readClaudeUsageCache } from './usage.js';
+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 last cached usage snapshot for an account, or null. Cache-only. */
+export function readAccountUsage(usageKey) {
+    return readClaudeUsageCache(usageKey);
+}
+/**
+ * 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)
+        return null;
+    return { status: entry.status, minutesToLimit: entry.minutesToLimit };
+}

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

@@ -0,0 +1,53 @@
+import { type DeviceStats } from './devices/health.js';
+/** Live agent workload on a host. */
+export interface FleetAgentCounts {
+    /** Sessions actively working (status === 'running'). */
+    running: number;
+    /** Total live sessions regardless of status (running/idle/input-required/…). */
+    live: number;
+    /** Running count broken down by context: terminal / teams / cloud / headless. */
+    byContext: Record<string, number>;
+    /** Running count broken down by agent CLI: claude / codex / cursor / … */
+    byAgent: Record<string, number>;
+}
+/** One host's published status row. */
+export interface FleetStatusRow {
+    host: string;
+    agents: FleetAgentCounts;
+    /** Resource stats from the local probe; null when the probe produced nothing. */
+    stats: DeviceStats | null;
+    /** Epoch ms this row was computed. */
+    capturedAt: number;
+}
+/** Minimal shape needed to count workload — a subset of ActiveSession. */
+type CountableSession = {
+    status?: string;
+    context?: string;
+    kind?: string;
+    pidAlive?: boolean;
+};
+/**
+ * Tally running-agent workload from a host's live sessions. "running" is the
+ * actively-working set (`status === 'running'`); `live` is every session the
+ * host is tracking. Pure so the tally is unit-tested without a live scan.
+ */
+export declare function computeAgentCounts(sessions: ReadonlyArray<CountableSession>): FleetAgentCounts;
+/**
+ * Probe THIS host's status — resource stats locally (no SSH) and agent workload
+ * from the local live-session set (`getActiveSessions({ localOnly: true })`,
+ * which never dials a remote host). Never throws: a failed sub-probe degrades to
+ * null stats / zero counts.
+ */
+export declare function probeLocalFleetStatus(host: string, now?: number): Promise<FleetStatusRow>;
+export declare function setFleetStatusMirrorPathForTest(mirrorPath: string | null): string | null;
+/** Read the whole fleet-status mirror (best-effort; missing/corrupt → empty). */
+export declare function readFleetStatus(): Record<string, FleetStatusRow>;
+/** Merge rows into the mirror (best-effort; preserves other hosts' rows). */
+export declare function writeFleetStatusRows(entries: Record<string, FleetStatusRow>): void;
+/**
+ * Publish THIS host's row into the mirror (probe self, no SSH). The daemon calls
+ * this on its warm tick; it is the whole of the daemon's fleet-status duty now
+ * that cross-host probing is gone.
+ */
+export declare function publishLocalFleetStatus(host: string): Promise<FleetStatusRow>;
+export {};