@phnx-labs/agents-cli 1.22.39 → 1.22.41

package/dist/lib/triggers/webhook.js

@@ -15,9 +15,9 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as path from 'path';
-import { jobRunsOnThisDevice, listJobs, substituteWebhookPrompt } from '../routines.js';
+import { jobRunsOnThisDevice, listJobs, substituteWebhookPrompt } from '../scheduling/routines.js';
 import { executeJobDetached } from '../runner.js';
-import { emit } from '../events.js';
+import { emit } from '../feed/events.js';
 import { listHandlers, handlerMatchesWebhook, executeHandler, buildWebhookContext, } from './handlers.js';
 /** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
 export function webhookRepo(payload) {
@@ -264,6 +264,76 @@ export function verifyLinearTimestamp(payload, now = Date.now(), toleranceMs = 6
     const ts = payload.webhookTimestamp;
     return typeof ts === 'number' && Math.abs(now - ts) <= toleranceMs;
 }
+/**
+ * Verify a Slack request signature (the `v0` scheme). Slack signs the base
+ * string `v0:${timestamp}:${rawBody}` with the app's signing secret and sends
+ * the hex digest as `X-Slack-Signature: v0=<hex>`, alongside the unix
+ * `X-Slack-Request-Timestamp`. The timestamp is BOTH part of the signed base
+ * string AND checked for freshness here — a request older than `toleranceSec`
+ * (default 5 min) is rejected, so a captured, correctly-signed body cannot be
+ * replayed later. Fails closed on any missing/malformed header.
+ */
+export function verifySlackSignature(headers, rawBody, secret, now = Date.now(), toleranceSec = 300) {
+    const ts = header(headers, 'x-slack-request-timestamp');
+    if (!ts || !/^\d+$/.test(ts))
+        return false;
+    if (Math.abs(Math.floor(now / 1000) - Number(ts)) > toleranceSec)
+        return false;
+    const received = header(headers, 'x-slack-signature');
+    const signature = received?.startsWith('v0=') ? received.slice('v0='.length) : undefined;
+    // Concatenate the base-string prefix with the raw body bytes so a non-ASCII
+    // payload hashes identically to Slack's own `v0:${ts}:${body}` string.
+    const base = Buffer.concat([Buffer.from(`v0:${ts}:`, 'utf-8'), rawBody]);
+    const expected = crypto.createHmac('sha256', secret).update(base).digest('hex');
+    return timingSafeHexEqual(signature, expected);
+}
+/**
+ * Parse a Slack delivery body into a normalized {@link SlackPayload}. Slack
+ * sends slash commands as `application/x-www-form-urlencoded` and Events API
+ * deliveries (including the `url_verification` handshake) as
+ * `application/json` — this is the one place that content-type branch lives.
+ */
+export function parseSlackBody(contentType, rawBody) {
+    if ((contentType ?? '').includes('application/x-www-form-urlencoded')) {
+        const form = new URLSearchParams(rawBody.toString('utf-8'));
+        // A slash command carries no thread; its reply posts to the channel.
+        return {
+            type: 'slash_command',
+            command: form.get('command') ?? undefined,
+            text: form.get('text') ?? undefined,
+            channel: form.get('channel_id') ?? undefined,
+            user: form.get('user_id') ?? undefined,
+            response_url: form.get('response_url') ?? undefined,
+            team: form.get('team_id') ?? undefined,
+        };
+    }
+    const json = rawBody.length > 0 ? JSON.parse(rawBody.toString('utf-8')) : {};
+    const type = String(json.type ?? '');
+    if (type === 'url_verification') {
+        return { type, challenge: typeof json.challenge === 'string' ? json.challenge : '' };
+    }
+    const event = (json.event ?? {});
+    return {
+        type: type || 'event_callback',
+        event_id: typeof json.event_id === 'string' ? json.event_id : undefined,
+        event_type: typeof event.type === 'string' ? event.type : undefined,
+        text: typeof event.text === 'string' ? event.text : undefined,
+        channel: typeof event.channel === 'string' ? event.channel : undefined,
+        thread_ts: typeof event.thread_ts === 'string'
+            ? event.thread_ts
+            : typeof event.ts === 'string'
+                ? event.ts
+                : undefined,
+        user: typeof event.user === 'string' ? event.user : undefined,
+        team: typeof json.team_id === 'string' ? json.team_id : undefined,
+    };
+}
+/** The `event` name a Slack delivery fires under: the slash command, or the event subtype. */
+export function slackEventName(payload) {
+    if (payload.type === 'slash_command')
+        return payload.command ?? 'slash_command';
+    return payload.event_type ?? payload.type;
+}
 export function createMemoryDeliveryStore(maxEntries = 1000) {
     const seen = new Map();
     const touch = (id) => {
@@ -405,7 +475,7 @@ function deliveryId(source, headers, rawBody) {
     return `${source}:${named ?? crypto.createHash('sha256').update(rawBody).digest('hex')}`;
 }
 function sourceFromPath(pathname) {
-    const match = /^\/hooks\/(github|linear)\/?$/.exec(pathname ?? '');
+    const match = /^\/hooks\/(github|linear|slack)\/?$/.exec(pathname ?? '');
     return match ? match[1] : null;
 }
 async function readRawBody(req, maxBytes) {
@@ -420,18 +490,119 @@ async function readRawBody(req, maxBytes) {
     }
     return Buffer.concat(chunks);
 }
+/**
+ * Resolve once a receiver is actually accepting connections, REJECT if the bind
+ * failed. `server.listen()` reports a bind failure (EADDRINUSE, EACCES) as an
+ * asynchronous `'error'` event, never a throw — so a `try/catch` around
+ * `startWebhookServer` cannot see it, and without this the event reaches Node's
+ * default handler and takes the whole process down. Every caller that hosts a
+ * receiver MUST await this rather than assuming the return means "bound".
+ */
+export function waitForListening(server) {
+    if (server.listening)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            server.off('listening', onListening);
+            server.off('error', onError);
+        };
+        const onListening = () => { cleanup(); resolve(); };
+        const onError = (err) => { cleanup(); reject(err); };
+        server.once('listening', onListening);
+        server.once('error', onError);
+    });
+}
 /**
  * Start a localhost-bound receiver. It accepts only:
  *   POST /hooks/github  with X-Hub-Signature-256
  *   POST /hooks/linear  with Linear-Signature + fresh webhookTimestamp
  *
+ * **The ack is asynchronous (RUSH-2548).** Once a delivery has passed signature
+ * verification, freshness, dedup, and rate limiting, the receiver writes
+ * `202 {ok:true, accepted:true}` IMMEDIATELY and dispatches the matched routines
+ * and handlers afterwards. Dispatch starts an agent run and takes 15-20s, which
+ * exceeds Linear's delivery timeout — holding the socket open across it made
+ * every real delivery log a timeout + retry on Linear's side. Nothing about the
+ * dedup ledger changes: the `<source>:<delivery-id>` key is still what makes a
+ * retry a no-op, per-job `markJob` still lets a retry finish only the matches
+ * that failed, and the delivery is marked complete only after it settles.
+ *
+ * A retry that lands WHILE the first is still settling is answered as a
+ * duplicate from an in-flight set, since `deliveryStore.seen` only reports
+ * completed deliveries and would otherwise let a mid-flight retry double-fire.
+ *
+ * `onMatch` fires as soon as matching is known, before any dispatch; `onDelivery`
+ * fires only once every matched routine/handler has settled — see their docs on
+ * `WebhookServerOptions`. A caller that wants a prompt "this fired" log uses
+ * `onMatch`, not `onDelivery` (RUSH-2722).
+ *
  * Returns the underlying server so callers can `close()` it.
  */
 export function startWebhookServer(options) {
     const deliveryStore = options.deliveryStore ?? createMemoryDeliveryStore();
+    /** Delivery ids acked but not yet settled — dedup across the async window. */
+    const inFlight = new Set();
     const rateLimiter = options.rateLimiter ?? createMemoryRateLimiter(options.rateLimitPerMinute ?? 60, 60_000);
     const ipRateLimiter = options.ipRateLimiter ?? createMemoryRateLimiter(options.ipRateLimitPerMinute ?? 120, 60_000);
     const maxBodyBytes = options.maxBodyBytes ?? 1024 * 1024;
+    /**
+     * Dispatch an already-acked delivery: matched routines first, then matched
+     * handlers, then mark the delivery complete. A failure leaves the delivery
+     * UNMARKED (its per-job `markJob` entries survive), so a later retry of the
+     * same delivery id re-runs only what did not complete — the same partial-retry
+     * ledger the synchronous receiver had, minus the 4xx that used to request it.
+     */
+    async function settleDelivery(webhook, id) {
+        const { source, event: webhookEvent } = webhook;
+        try {
+            const context = buildWebhookContext(webhook);
+            const fireOptions = options.fire ?? {};
+            // Match FIRST, before any dispatch — matching is a pure in-memory lookup,
+            // so this is the earliest point the receiver knows what fired, and the
+            // right time to log it (RUSH-2722). Dispatching a `run.command` handler
+            // can then block on the shelled-out process for minutes; that must never
+            // hold the "fired" log back with it.
+            const matchedJobs = matchJobsToWebhook(fireOptions.jobs ?? listJobs(), webhook);
+            const matchedHandlers = listHandlers().filter((handler) => handlerMatchesWebhook(handler, webhook));
+            options.onMatch?.(webhook, matchedJobs.map((job) => job.name), matchedHandlers.map((handler) => handler.name));
+            const firedJobs = await fireWebhookJobs(webhook, {
+                ...fireOptions,
+                jobs: matchedJobs,
+                context,
+                skipJobNames: deliveryStore.completedJobs(id),
+                onJobFired: (job, firedJob) => {
+                    emit('webhook.fired', { source, event: webhookEvent, deliveryId: id, jobName: job.name, runId: firedJob.runId });
+                    deliveryStore.markJob(id, job.name);
+                    fireOptions.onJobFired?.(job, firedJob);
+                },
+            });
+            const firedHandlers = [];
+            const handlerErrors = [];
+            await Promise.allSettled(matchedHandlers.map(async (handler) => {
+                if (deliveryStore.completedJobs(id).has(handler.name))
+                    return;
+                emit('webhook.matched', { source, event: webhookEvent, deliveryId: id, handlerName: handler.name });
+                try {
+                    const result = await executeHandler(handler, webhook);
+                    deliveryStore.markJob(id, handler.name);
+                    firedHandlers.push(result);
+                }
+                catch (err) {
+                    handlerErrors.push({ handlerName: handler.name, error: err.message });
+                }
+            }));
+            deliveryStore.mark(id);
+            for (const failure of handlerErrors) {
+                emit('webhook.failed', { source, event: webhookEvent, deliveryId: id, handlerName: failure.handlerName, error: failure.error });
+            }
+            options.onDelivery?.(webhook, firedJobs, firedHandlers);
+        }
+        catch (err) {
+            const error = err;
+            emit('webhook.failed', { source, event: webhookEvent, deliveryId: id, error: error.message });
+            options.onDeliveryError?.(webhook, error);
+        }
+    }
     const server = http.createServer((req, res) => {
         void (async () => {
             if (req.method !== 'POST') {
@@ -475,17 +646,58 @@ export function startWebhookServer(options) {
                 const rawBody = await readRawBody(req, maxBodyBytes);
                 const valid = source === 'github'
                     ? verifyGithubSignature(req.headers, rawBody, secret)
-                    : verifyLinearSignature(req.headers, rawBody, secret);
+                    : source === 'linear'
+                        ? verifyLinearSignature(req.headers, rawBody, secret)
+                        : verifySlackSignature(req.headers, rawBody, secret);
                 if (!valid) {
                     emit('webhook.rejected', { source, reason: 'invalid signature' });
                     res.writeHead(401, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: 'invalid signature' }));
                     return;
                 }
+                // Slack diverges from the GitHub/Linear JSON path: two content-types
+                // (slash = form, events = JSON), a one-time url_verification handshake,
+                // a body-carried event id, and a 200 ack Slack shows to the caller.
+                if (source === 'slack') {
+                    const slack = parseSlackBody(header(req.headers, 'content-type'), rawBody);
+                    // One-time Events API URL handshake: echo the challenge, dispatch nothing.
+                    if (slack.type === 'url_verification') {
+                        res.writeHead(200, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ challenge: slack.challenge ?? '' }));
+                        return;
+                    }
+                    const slackEvent = slackEventName(slack);
+                    // Slash commands carry no event_id, so fall back to a body hash for dedup.
+                    const slackId = `slack:${slack.event_id ?? crypto.createHash('sha256').update(rawBody).digest('hex')}`;
+                    emit('webhook.received', { source, event: slackEvent, deliveryId: slackId });
+                    if (deliveryStore.seen(slackId) || inFlight.has(slackId)) {
+                        res.writeHead(200, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, duplicate: true }));
+                        return;
+                    }
+                    if (!rateLimiter.take(source)) {
+                        emit('webhook.rejected', { source, event: slackEvent, deliveryId: slackId, reason: 'rate limit exceeded' });
+                        res.writeHead(429, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'rate limit exceeded' }));
+                        return;
+                    }
+                    const slackWebhook = { source, event: slackEvent, payload: slack };
+                    emit('webhook.authorized', { source, event: slackEvent, deliveryId: slackId });
+                    // ACK FIRST (RUSH-2548): a 200 inside Slack's 3s window. A slash
+                    // command renders the ack text to the caller; an event delivery
+                    // ignores the body. Dispatch outlives the ack, same as GitHub/Linear.
+                    inFlight.add(slackId);
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end(slack.type === 'slash_command'
+                        ? JSON.stringify({ response_type: 'ephemeral', text: 'On it — replying in this thread.' })
+                        : '');
+                    void settleDelivery(slackWebhook, slackId).finally(() => inFlight.delete(slackId));
+                    return;
+                }
                 const id = deliveryId(source, req.headers, rawBody);
                 const event = source === 'github' ? (header(req.headers, 'x-github-event') ?? '') : '';
                 emit('webhook.received', { source, event, deliveryId: id });
-                if (deliveryStore.seen(id)) {
+                if (deliveryStore.seen(id) || inFlight.has(id)) {
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify({ ok: true, duplicate: true, fired: [] }));
                     return;
@@ -510,45 +722,12 @@ export function startWebhookServer(options) {
                     payload,
                 };
                 emit('webhook.authorized', { source, event: webhookEvent, deliveryId: id });
-                const context = buildWebhookContext(webhook);
-                const fireOptions = options.fire ?? {};
-                const firedJobs = await fireWebhookJobs(webhook, {
-                    ...fireOptions,
-                    context,
-                    skipJobNames: deliveryStore.completedJobs(id),
-                    onJobFired: (job, firedJob) => {
-                        emit('webhook.fired', { source, event: webhookEvent, deliveryId: id, jobName: job.name, runId: firedJob.runId });
-                        deliveryStore.markJob(id, job.name);
-                        fireOptions.onJobFired?.(job, firedJob);
-                    },
-                });
-                const handlers = listHandlers();
-                const matchedHandlers = handlers.filter((handler) => handlerMatchesWebhook(handler, webhook));
-                const firedHandlers = [];
-                const handlerErrors = [];
-                await Promise.allSettled(matchedHandlers.map(async (handler) => {
-                    if (deliveryStore.completedJobs(id).has(handler.name))
-                        return;
-                    emit('webhook.matched', { source, event: webhookEvent, deliveryId: id, handlerName: handler.name });
-                    try {
-                        const result = await executeHandler(handler, webhook);
-                        deliveryStore.markJob(id, handler.name);
-                        firedHandlers.push(result);
-                    }
-                    catch (err) {
-                        handlerErrors.push({ handlerName: handler.name, error: err.message });
-                    }
-                }));
-                deliveryStore.mark(id);
-                options.onDelivery?.(webhook, firedJobs, firedHandlers);
-                res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({
-                    ok: true,
-                    fired: firedJobs.map((f) => f.jobName),
-                    runs: firedJobs,
-                    handlers: firedHandlers,
-                    ...(handlerErrors.length > 0 ? { handlerErrors } : {}),
-                }));
+                // ACK FIRST (RUSH-2548). Everything that could reject this delivery has
+                // run; what remains starts agent runs and outlives any sender timeout.
+                inFlight.add(id);
+                res.writeHead(202, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, accepted: true, deliveryId: id }));
+                void settleDelivery(webhook, id).finally(() => inFlight.delete(id));
             }
             catch (err) {
                 res.writeHead(400, { 'content-type': 'application/json' });

package/dist/lib/types.d.ts

@@ -790,6 +790,17 @@ export interface Meta {
     /** Preferred provider account per harness. Explicit --account wins. */
     accounts?: {
         defaults?: Partial<Record<AgentId, string>>;
+        /** Named harness-owned identities. Metadata only; OAuth credentials stay in the harness home. */
+        native?: Record<string, {
+            id: string;
+            name: string;
+            agent: AgentId;
+            identityKey: string;
+            identityLabel?: string;
+            scope: 'version' | 'device';
+        }>;
+        /** Exact installation/custom-harness target -> stable account id. */
+        bindings?: Record<string, string>;
     };
     agents?: Partial<Record<AgentId, string>>;
     /**
@@ -955,8 +966,9 @@ export interface Meta {
      * user-scope keys from the device-config registry (`lib/device-config.ts`) —
      * currently `interactiveHost` and `usagePrimaryHost`. Syncs fleet-wide via
      * `agents repo push/pull`.
-     * Device-scope keys live under `fleet.devices.<name>.config` instead (see
-     * {@link Meta.fleet}).
+     * Device-scope keys live in the per-device doc
+     * `devices/<name>/agents.yaml` `config:` block, layered over the fleet-wide
+     * defaults in {@link Meta.fleet} (`fleet.defaults.config`).
      */
     config?: Record<string, unknown>;
     /**
@@ -979,7 +991,7 @@ export interface Meta {
      */
     deviceConfig?: Record<string, unknown>;
     /**
-     * Agent-host registry keyed by host name (the `--host`/`--device` dispatch overlay). Portable user
+     * Agent-host registry keyed by host name (the `--device` dispatch overlay). Portable user
      * config synced with `agents repo push/pull`. For `ssh-config` hosts this is
      * just an overlay (caps/os) — the connection details stay in ~/.ssh/config and
      * are never copied. `inline` hosts carry their own address/user.
@@ -989,9 +1001,9 @@ export interface Meta {
      * Declarative fleet profile (`agents apply` / `ag apply`). Additive to the
      * schema — project `agents:` version-pins are untouched. Declares which agents
      * every device should have, which config to sync, and how login propagates.
-     * `fleet.devices.<name>.config` is also the central store for per-device
-     * operator config (`agents devices config <name>`) — the device-scope keys of
-     * the `lib/device-config.ts` registry.
+     * `fleet.defaults.config` is also the fleet-wide DEFAULTS layer of the
+     * device-config store (`agents devices config --fleet <key> <value>`) — read
+     * between the built-in default and the per-device doc's `config:` block.
      * Full shape in `lib/fleet/types.ts` (FleetManifest).
      */
     fleet?: import('./fleet/types.js').FleetManifest;
@@ -1098,7 +1110,7 @@ export interface HostEntry {
 /** Browser profile definition stored in agents.yaml. */
 export interface BrowserProfileConfig {
     description?: string;
-    browser: 'chrome' | 'comet' | 'chromium' | 'brave' | 'edge' | 'custom';
+    browser: 'chrome' | 'comet' | 'chromium' | 'brave' | 'edge' | 'arc' | 'custom';
     binary?: string;
     electron?: boolean;
     /**

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

@@ -1,5 +1,5 @@
 import { type HeadroomEntry } from './usage-refresh.js';
-import { type UsageWindow } from './usage.js';
+import { type UsageWindow } from './accounting/usage.js';
 export declare const USAGE_FLEET_VERSION = 1;
 export declare const USAGE_FLEET_FILE = ".usage-fleet.json";
 export interface UsageFleetWindow {

package/dist/lib/usage-fleet.js

@@ -13,7 +13,7 @@ import { loadDevices } from './devices/registry.js';
 import { atomicWriteFileSync } from './fs-atomic.js';
 import { getCacheDir } from './state.js';
 import { readHeadroomCache, writeHeadroomEntries, } from './usage-refresh.js';
-import { readClaudeUsageCache, writeClaudeUsageCache, } from './usage.js';
+import { readClaudeUsageCache, writeClaudeUsageCache, } from './accounting/usage.js';
 export const USAGE_FLEET_VERSION = 1;
 export const USAGE_FLEET_FILE = '.usage-fleet.json';
 /** Publisher/subscriber role selection, kept pure for the daemon gate test. */

package/dist/lib/usage-refresh.d.ts

@@ -1,4 +1,4 @@
-import { type UsageHeadroom, type UsageSnapshot, type UsageInfo } from './usage.js';
+import { type UsageHeadroom, type UsageSnapshot, type UsageInfo } from './accounting/usage.js';
 import type { AgentId } from './types.js';
 /**
  * Default schedule between successful (or attempted) live usage fetches for one

package/dist/lib/usage-refresh.js

@@ -50,9 +50,9 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getCacheDir } from './state.js';
 import { atomicWriteFileSync, ensureLockTarget, withFileLock } from './fs-atomic.js';
-import { deriveUsageHeadroom, buildCanonicalUsageContext, USAGE_SOURCE_AGENT_IDS, } from './usage.js';
+import { deriveUsageHeadroom, buildCanonicalUsageContext, USAGE_SOURCE_AGENT_IDS, } from './accounting/usage.js';
 import { getAccountInfo } from './agents.js';
-import { listInstalledVersions, getVersionHomePath } from './versions.js';
+import { listInstalledVersions, getVersionHomePath } from './installations/versions.js';
 /**
  * Default schedule between successful (or attempted) live usage fetches for one
  * account. Floor and ceiling of the delay helper are pinned to this so the
@@ -202,7 +202,7 @@ export async function buildLocalUsageAccounts() {
                 // only, never the interactive login (see loadClaudeOauth); no setup-token
                 // reads as "usage pending".
                 fetch: async () => {
-                    const { getUsageInfoForIdentity } = await import('./usage.js');
+                    const { getUsageInfoForIdentity } = await import('./accounting/usage.js');
                     return getUsageInfoForIdentity({
                         agentId,
                         home: fetchInput.home,

package/dist/lib/version-duplicates.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { getAccountInfo, agentLabel } from './agents.js';
-import { compareVersions, getVersionHomePath, listInstalledVersions, } from './versions.js';
-import { buildCanonicalUsageContext, getUsageLookupKey, } from './usage.js';
+import { compareVersions, getVersionHomePath, listInstalledVersions, } from './installations/versions.js';
+import { buildCanonicalUsageContext, getUsageLookupKey, } from './accounting/usage.js';
 function duplicateIdentity(info) {
     if (!info)
         return null;

package/dist/lib/view-types.d.ts

@@ -0,0 +1,56 @@
+import type { ConfiguredModelSource } from './models.js';
+import type { ProfileSummary } from './profiles.js';
+import type { AgentId } from './types.js';
+export type SyncState = 'synced' | 'new' | 'modified' | 'deleted';
+export interface ViewJsonVersion {
+    version: string;
+    isDefault: boolean;
+    isolated: boolean;
+    isIsolatedDefault: boolean;
+    signedIn: boolean;
+    email: string | null;
+    accountId?: string | null;
+    organizationType?: string | null;
+    organizationName?: string | null;
+    plan: string | null;
+    usageStatus: 'available' | 'rate_limited' | 'out_of_credits' | null;
+    overageCredits?: {
+        amount: number;
+        currency: string;
+    } | null;
+    windows: Array<{
+        key: 'session' | 'week' | 'sonnet_week' | 'month';
+        label?: string;
+        usedPercent: number;
+        resetsAt: string | null;
+    }>;
+    lastActive: string | null;
+    path: string;
+    configuredModel?: {
+        model: string;
+        source: ConfiguredModelSource;
+    } | null;
+    resources?: VersionResourcesJson;
+}
+export interface ViewJsonAgent {
+    agent: AgentId;
+    versions: ViewJsonVersion[];
+    harnesses: ProfileSummary[];
+}
+export type ResourceSection = 'commands' | 'skills' | 'mcp' | 'memory' | 'hooks' | 'workflows' | 'plugins';
+export interface ResourceItemJson {
+    name: string;
+    scope?: 'user' | 'project';
+    syncState?: SyncState;
+    description?: string;
+    ruleCount?: number;
+}
+export interface VersionResourcesJson {
+    commands?: ResourceItemJson[];
+    skills?: ResourceItemJson[];
+    mcp?: ResourceItemJson[];
+    memory?: ResourceItemJson[];
+    hooks?: ResourceItemJson[];
+    workflows?: ResourceItemJson[];
+    plugins?: ResourceItemJson[];
+}

package/dist/lib/view-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/watchdog/rotate.d.ts

@@ -27,7 +27,7 @@
  *
  * Config: `watchdog.rotate: on|off` in agents.yaml (default on), read per tick.
  */
-import type { InjectTarget } from '../terminal/inject.js';
+import type { InjectTarget } from '../terminal/index.js';
 import type { ActiveSession } from '../session/active.js';
 /**
  * Agent-reported hard-limit texts, matched against a session transcript tail.
@@ -78,7 +78,7 @@ export declare function exitSequenceFor(agent: string): string[];
  * host (affinity) → harness (cross-harness headroom) → account (balanced) and
  * exits nonzero when every layer is exhausted. Ported from apps/ext
  * autoRotate.ts buildAutoRotateLaunchCommand. A terminal on a REMOTE device
- * rotates ON that device (`--host`); a local terminal omits it. `--session-id`
+ * rotates ON that device (`--device`); a local terminal omits it. `--session-id`
  * is honored only when the CLI picks claude (existing claude-only semantics)
  * and ignored otherwise — passing it unconditionally keeps the terminal's
  * AGENT_SESSION_ID aligned with the session Claude actually creates.

package/dist/lib/watchdog/rotate.js

@@ -30,7 +30,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { readMeta, writeMeta } from '../state.js';
-import { collectHarnessCandidates, classifyHarnessCandidates, pickHarnessWeighted, earliestResetAcross, formatNoHealthyHarnessError, } from '../rotate.js';
+import { collectHarnessCandidates, classifyHarnessCandidates, pickHarnessWeighted, earliestResetAcross, formatNoHealthyHarnessError, } from '../accounting/rotate.js';
 import { resolveWatchdogSessionPath } from './read.js';
 // --- detection ---------------------------------------------------------------
 /**
@@ -160,7 +160,7 @@ export function exitSequenceFor(agent) {
  * host (affinity) → harness (cross-harness headroom) → account (balanced) and
  * exits nonzero when every layer is exhausted. Ported from apps/ext
  * autoRotate.ts buildAutoRotateLaunchCommand. A terminal on a REMOTE device
- * rotates ON that device (`--host`); a local terminal omits it. `--session-id`
+ * rotates ON that device (`--device`); a local terminal omits it. `--session-id`
  * is honored only when the CLI picks claude (existing claude-only semantics)
  * and ignored otherwise — passing it unconditionally keeps the terminal's
  * AGENT_SESSION_ID aligned with the session Claude actually creates.
@@ -168,7 +168,7 @@ export function exitSequenceFor(agent) {
 export function buildRotateLaunchCommand(opts) {
     let cmd = 'agents run auto --interactive';
     if (opts.host) {
-        cmd += ` --host ${shellQuoteHost(opts.host)}`;
+        cmd += ` --device ${shellQuoteHost(opts.host)}`;
     }
     cmd += ` --session-id ${opts.sessionId}`;
     return cmd;

package/dist/lib/watchdog/runner.d.ts

@@ -32,10 +32,9 @@
  */
 import type { ActiveSession } from '../session/active.js';
 import { type PresenceTransition } from '../session/presence.js';
-import { type InjectRail } from '../terminal/resolve.js';
-import { type InjectResult, type InjectTarget } from '../terminal/inject.js';
+import { type InjectRail, type InjectResult, type InjectTarget } from '../terminal/index.js';
 import { type StallStatus, type WatchdogCandidate } from './watchdog.js';
-import { type OpenBlock } from '../feed.js';
+import { type OpenBlock } from '../feed/feed.js';
 import { type RotateGateResult, type RotatePhase, type RotateState } from './rotate.js';
 /** Per-session policy sentinel. `keep` is the default (watchdog may nudge). */
 export type WatchdogPolicy = 'off' | 'keep' | 'handsoff';

package/dist/lib/watchdog/runner.js

@@ -35,8 +35,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { getActiveSessions } from '../session/active.js';
 import { reconcilePresence, loadPresence, savePresence, observedFromActive, } from '../session/presence.js';
-import { resolveInjectTargetForSession, } from '../terminal/resolve.js';
-import { injectIntoTerminal } from '../terminal/inject.js';
+import { resolveInjectTargetForSession, injectIntoTerminal, } from '../terminal/index.js';
 import { classifyTerminal, isLikelyTrulyBlocked, renderWatchdogPrompt, parseWatchdogResponse, } from './watchdog.js';
 import { readWatchdogTail, WATCHDOG_STALL_MS, WATCHDOG_COOLDOWN_MS, WATCHDOG_DORMANT_MS, WATCHDOG_TAIL_LINES, } from './read.js';
 import { getRuntimeStateDir } from '../state.js';
@@ -44,7 +43,7 @@ import { withFileLock, atomicWriteFileSync, ensureLockTarget } from '../fs-atomi
 import { resolveAnswerRoute, isOpenQuestionBlock } from '../answer-router.js';
 import { enqueue, mailboxDir } from '../mailbox.js';
 import { mailboxIdForActiveSession } from '../mailbox-target.js';
-import { readBlock, blockIdForSession, buildDeclaredBlock, publishBlock } from '../feed.js';
+import { readBlock, blockIdForSession, buildDeclaredBlock, publishBlock } from '../feed/feed.js';
 import { summarizeWatchdogTail } from './watchdogTail.js';
 import { appendWatchdogEvents } from './log.js';
 import { buildRotateLaunchCommand, buildRotateReplayText, classifyTailForRotate, defaultRotateGate, defaultTuiLiveFor, exitSequenceFor, isInflightPhase, isWatchdogRotateEnabled, listInflightRotates, readRotateState, recordRotateSkip, shouldLogRotateSkip, writeRotateState, DEFAULT_ROTATE_READINESS_MS, DEFAULT_ROTATE_SKIP_COOLDOWN_MS, DEFAULT_ROTATE_FAILED_COOLDOWN_MS, } from './rotate.js';
@@ -239,7 +238,7 @@ async function deliverViaResume(session, text) {
         return { ok: false, error: 'no session id to resume' };
     try {
         const [{ getAgentsInvocation }, { spawn }] = await Promise.all([
-            import('../daemon.js'),
+            import('../daemon/daemon.js'),
             import('child_process'),
         ]);
         const inv = getAgentsInvocation(['run', session.kind, '--resume', sid, '--', text]);

package/dist/lib/workflows.js

@@ -11,7 +11,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { capableAgents, supports } from './capabilities.js';
 import { getProjectAgentsDir, getSystemWorkflowsDir, getUserWorkflowsDir, getTrashWorkflowsDir, getEnabledExtraRepos, getPluginsDir, getSystemPluginsDir, getProjectPluginsDir, } from './state.js';
-import { listInstalledVersions, getVersionHomePath } from './versions.js';
+import { listInstalledVersions, getVersionHomePath } from './installations/versions.js';
 /**
  * Hard upper bound on items a single `for_each` expands, absent an explicit
  * `max_items`. A guard against a runaway producer spawning unbounded teammates

package/dist/lib/wrap.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Terminal word-wrap — one shared helper for the whole CLI.
+ *
+ * Multi-line word wrapping is the gap the single-line helpers in
+ * `session/width.ts` (`truncateToWidth`, `padToWidth`) do not fill. Anywhere that
+ * renders variable-length text into a fixed-width terminal wraps through THIS,
+ * never a per-field slice.
+ *
+ * Width is measured with `stringWidth` (from the canonical `session/width.ts`),
+ * NOT `String.length`: the text this wraps is routinely ANSI-coloured (chalk /
+ * marked-terminal output) and may carry OSC-8 hyperlinks, where `.length`
+ * over-counts the invisible escape bytes. Words are split on whitespace, so a
+ * wrap boundary always falls between escape sequences, never inside one.
+ */
+/**
+ * Hard-wrap `text` to `cols` visible columns.
+ *
+ * - Splits on existing newlines first (each paragraph wraps independently).
+ * - Wraps on whitespace; a single word wider than the available width is emitted
+ *   on its own line rather than split mid-word (and never mid-escape).
+ * - Width is the visible display width via `stringWidth`, so ANSI colour and
+ *   OSC-8 hyperlink escapes do not inflate the count.
+ * - `hangingIndent` pads every line AFTER the first with that many spaces, so a
+ *   labelled value ("Latest  <text>") keeps its continuation lines aligned under
+ *   the value. The wrapping width is `cols - indent`.
+ * - Floor: when `hangingIndent` is set, the width is floored at 8 so a
+ *   pathologically large indent still makes forward progress. With no indent the
+ *   floor is 1, so a legitimately small `cols` is respected, never overridden. A
+ *   non-finite `cols` degrades to the floor rather than silently disabling wrap.
+ *
+ * Returns the wrapped lines (never mutates input). An empty string yields [''].
+ */
+export declare function wrapToWidth(text: string, cols: number, hangingIndent?: number): string[];