@phnx-labs/agents-cli 1.22.38 → 1.22.40

package/dist/lib/menubar/snapshot.js

@@ -1,23 +1,24 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { buildRoutineListJson } from '../../commands/routines.js';
-import { backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../../commands/sessions.js';
+import { buildRoutineListJson } from '../scheduling/routines.js';
+import { backfillActiveRowsFromIndex, isRunningLiveSession, serializeActiveSessionsForJson, serializeSessionsJson } from '../session/active.js';
 import { getConfigValue, loadAutoLaunchPreferences } from '../device-config.js';
 import { loadDevices } from '../devices/registry.js';
 import { machineId } from '../machine-id.js';
 import { querySessions } from '../session/db.js';
 import { readActiveSessionsCache } from '../session/session-cache.js';
 import { getRuntimeStateDir } from '../state.js';
+import { getCliVersion } from '../version.js';
 /**
  * The full registered-device roster for the menu bar, from the local registry
  * file only (no ssh, no stats probe) — as cheap as `buildRoutineListJson()`, so
  * it rides the same 3-minute snapshot poll instead of a second timer.
  */
 async function buildMenubarDevices() {
-    const [reg, prefs] = await Promise.all([
-        loadDevices(),
-        loadAutoLaunchPreferences(),
-    ]);
+    const reg = await loadDevices();
+    // Pass the roster so a fleet-wide default (fleet.defaults.config) reaches
+    // devices that have no doc of their own.
+    const prefs = loadAutoLaunchPreferences(Object.keys(reg));
     const interactiveHost = getConfigValue('interactive.host').value;
     const self = machineId();
     return Object.keys(reg)
@@ -63,6 +64,7 @@ export async function computeMenubarSnapshot() {
     return {
         version: 1,
         capturedAt: new Date().toISOString(),
+        cliVersion: getCliVersion(),
         routines,
         recentSessions: JSON.parse(serializeSessionsJson(recent)),
         activeSessions: serializeActiveSessionsForJson(activeSessions),

package/dist/lib/models.js

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
 import chalk from 'chalk';
-import { getVersionDir, getVersionHomePath, getBinaryPath } from './versions.js';
+import { getVersionDir, getVersionHomePath, getBinaryPath } from './installations/versions.js';
 import { getModelsCachePath } from './state.js';
 import { agentConfigDirName } from './agents.js';
 import { resolveRunDefaults } from './run-defaults.js';

package/dist/lib/monitors/config.d.ts

@@ -105,6 +105,18 @@ export interface MonitorConfig {
     devices?: string[];
     /** Execute the ACTION on this machine over SSH (placement), distinct from the owner that fires it. */
     runOn?: string;
+    /**
+     * Working directory for a `run` action, in the routines-portable form
+     * (`~/…`, or relative to the execution target's home). Optional: a monitor
+     * watches a source rather than owning a project, so `dispatchAction` defaults
+     * it to the target's home (`~`) when unset.
+     *
+     * Without this, every `run` action was blocked at readiness with
+     * `execution_context_missing` — `resolveJobExecutionContext` refuses an
+     * agent job carrying neither `project` nor `cwd` (`lib/routine-context.ts`),
+     * and a monitor had no field with which to supply one (RUSH-2681).
+     */
+    cwd?: string;
     /** Firehose guard: auto-pause the monitor if it fires more than `max` times per `per`. */
     rateLimit?: {
         max: number;

package/dist/lib/monitors/config.js

@@ -261,6 +261,9 @@ export function validateMonitor(config) {
     if (config.runOn !== undefined && (typeof config.runOn !== 'string' || config.runOn.trim() === '')) {
         errors.push('runOn must be a non-empty machine name (a registered host, device, capability tag, or user@host)');
     }
+    if (config.cwd !== undefined && (typeof config.cwd !== 'string' || config.cwd.trim() === '')) {
+        errors.push('cwd must be a non-empty path (home-relative or ~/…)');
+    }
     // ─── HYGIENE ─────────────────────────────────────────────────────────────────
     if (config.rateLimit !== undefined) {
         const rl = config.rateLimit;

package/dist/lib/monitors/dispatch.js

@@ -11,7 +11,7 @@
  * `webhook-out` POSTs the event.
  */
 import { executeJobDetached } from '../runner.js';
-import { readJob } from '../routines.js';
+import { readJob } from '../scheduling/routines.js';
 import { sendToOwner } from '../notify.js';
 /** Replace `{event}` in a prompt with the fired event summary. */
 export function injectEvent(prompt, event) {
@@ -29,19 +29,37 @@ export async function dispatchAction(monitor, event, meta) {
     if (action.type === 'run') {
         const job = {
             name: monitor.name,
+            // This job is not a routine — no definition, no yaml, never listed by
+            // `agents routines` — so it can never be a member of this device's routine
+            // activation manifest and MUST NOT be gated on it. Before this marker the
+            // gate refused every monitor `run` action with `wrong_owner` and an empty
+            // allowlist ("Job '<name>' can only run on: "), so no monitor action ever
+            // executed (RUSH-2681). The monitor's own `device:` pin already resolved
+            // exactly-once ownership before this dispatch.
+            dispatchedBy: 'monitor',
             agent: action.agent,
             mode: action.mode ?? 'auto',
             effort: action.effort ?? 'auto',
             timeout: action.timeout ?? '10m',
             enabled: true,
             prompt: injectEvent(action.prompt ?? '', event),
+            // A monitor watches a source; it owns no project, and until `cwd` existed
+            // it had no field able to supply one — so `resolveJobExecutionContext`
+            // blocked every `run` action with `execution_context_missing`
+            // (lib/routine-context.ts) once the eligibility gate above stopped
+            // swallowing them first. `~` is the execution TARGET's home, so it stays
+            // portable across a `runOn:` SSH hop.
+            cwd: monitor.cwd ?? '~',
             ...(monitor.variables ? { variables: monitor.variables } : {}),
             ...(monitor.version ? { version: monitor.version } : {}),
             ...(monitor.runOn ? { host: monitor.runOn } : {}),
         };
         try {
-            const meta = await executeJobDetached(job);
-            return { kind: 'run', ok: true, runId: meta.runId };
+            const runMeta = await executeJobDetached(job);
+            if (runMeta.status === 'skipped' || runMeta.status === 'blocked' || runMeta.status === 'failed') {
+                return { kind: 'run', ok: false, runId: runMeta.runId, error: runMeta.errorMessage ?? runMeta.status };
+            }
+            return { kind: 'run', ok: true, runId: runMeta.runId };
         }
         catch (err) {
             return { kind: 'run', ok: false, error: err.message };
@@ -55,8 +73,11 @@ export async function dispatchAction(monitor, event, meta) {
         // Inject the event into the routine's prompt so the fired routine sees it.
         const fired = { ...routine, prompt: injectEvent(routine.prompt ?? '', event) };
         try {
-            const meta = await executeJobDetached(fired);
-            return { kind: 'routine', ok: true, runId: meta.runId };
+            const runMeta = await executeJobDetached(fired);
+            if (runMeta.status === 'skipped' || runMeta.status === 'blocked' || runMeta.status === 'failed') {
+                return { kind: 'routine', ok: false, runId: runMeta.runId, error: runMeta.errorMessage ?? runMeta.status };
+            }
+            return { kind: 'routine', ok: true, runId: runMeta.runId };
         }
         catch (err) {
             return { kind: 'routine', ok: false, error: err.message };

package/dist/lib/monitors/engine.js

@@ -16,6 +16,7 @@ import { evaluateSource } from './sources/index.js';
 import { hasChanged, readState, writeState, recordFireTime, writeFireRecord, recordCheck, markDroughtNotified, } from './state.js';
 import { dispatchAction } from './dispatch.js';
 import { sendToOwner } from '../notify.js';
+import { readRunMeta } from '../scheduling/routines.js';
 /** How often the engine wakes to check which monitors are due. */
 const TICK_MS = 5_000;
 /** Default evaluation cadence for sources that carry no explicit interval. */
@@ -273,11 +274,20 @@ export class MonitorEngine {
         catch (err) {
             result = { kind: monitor.action.type, ok: false, error: err.message };
         }
+        // Best-effort snapshot of the run's status AT THIS INSTANT — the same
+        // synchronous view `dispatchAction` just returned from. For the async-race
+        // case (RUSH-2690) this reads 'running': the dispatched process is still
+        // in flight, `ok` was frozen on that transient state, and the real outcome
+        // is not known yet. Recorded so a future reconciliation pass can find
+        // exactly the fires whose `ok` needs revisiting; `resolveFireOutcome`
+        // (state.ts) never trusts this field — it re-reads the run fresh instead.
+        const runStatusAtFire = result.runId ? readRunMeta(monitor.name, result.runId)?.status : undefined;
         writeFireRecord(event, {
             ...(result.runId ? { runId: result.runId } : {}),
             action: result.kind,
             ok: result.ok,
             ...(result.error ? { error: result.error } : {}),
+            ...(runStatusAtFire ? { runStatusAtFire } : {}),
         });
         writeState(monitor.name, decision.value, decision.dedupeKey, { lastFiredAt: event.firedAt, fireTimes });
         this.logFn(result.ok ? 'INFO' : 'ERROR', `monitor '${monitor.name}' fired → ${result.kind}` +

package/dist/lib/monitors/sources/webhook.d.ts

@@ -8,7 +8,7 @@
  * synthesized JobConfig-shaped trigger.
  */
 import { type IncomingWebhook } from '../../triggers/webhook.js';
-import type { JobTrigger } from '../../routines.js';
+import type { JobTrigger } from '../../scheduling/routines.js';
 import type { MonitorSource, MonitorConfig } from '../config.js';
 import type { Observation } from './types.js';
 /** Push-only: nothing to snapshot on a poll tick. */

package/dist/lib/monitors/state.d.ts

@@ -10,6 +10,7 @@
  *   ~/.agents/.history/monitors/<name>/state.json      # last-seen hash/value + fire bookkeeping
  *   ~/.agents/.history/monitors/<name>/fires/<id>/…    # fire history
  */
+import { type RunMeta } from '../scheduling/routines.js';
 import type { MonitorEvent } from './config.js';
 /** Persisted last-seen state for one monitor. */
 export interface MonitorState {
@@ -103,6 +104,47 @@ export interface FireRecord extends MonitorEvent {
     action?: string;
     ok?: boolean;
     error?: string;
+    /**
+     * The dispatched run's status AT FIRE TIME, best-effort (RUSH-2690).
+     * `dispatchAction` (lib/monitors/dispatch.ts) only sees a synchronous
+     * snapshot: `executeJobDetached` writes `status: 'running'` before spawning
+     * and returns immediately — the real outcome (`completed`/`failed`/`timeout`)
+     * lands later, asynchronously, in `executeJobDetachedClaimed`'s own
+     * `settle()` on child exit/error (lib/runner.ts). So a fire recorded
+     * `runStatusAtFire: 'running'` had its `ok` frozen before the run actually
+     * finished — that is the signal a future reconciliation pass (a daemon tick
+     * that revisits `running`-at-fire records and patches `ok` for real) would
+     * scan for. Never used to gate `ok` itself; `resolveFireOutcome` re-reads the
+     * run fresh on every call instead of trusting this snapshot.
+     */
+    runStatusAtFire?: RunMeta['status'];
 }
 /** List a monitor's fire history, chronologically ascending. */
 export declare function listFires(name: string): FireRecord[];
+/** The reconciled outcome of one fire, resolved against the run's live status. */
+export interface ReconciledFireOutcome {
+    /** True fire outcome, correcting the frozen `ok` against the run's CURRENT status. */
+    ok: boolean;
+    /** The run's live terminal status, when a runId is present and resolvable. */
+    runStatus?: RunMeta['status'];
+}
+/**
+ * Reconcile a fire's frozen `ok` against its dispatched run's REAL, current
+ * status — the render-time fix for RUSH-2690.
+ *
+ * `writeFireRecord` (this module) persists `ok` once, at fire time, from
+ * `dispatchAction`'s synchronous return. For a `run`/`routine` action that
+ * return is a snapshot: `executeJobDetached` writes `status: 'running'` before
+ * spawning and hands that back immediately, so `dispatchAction`'s negative
+ * check (`skipped`/`blocked`/`failed`) never sees the async outcome that lands
+ * later via `settle()` — a run that goes on to fail, time out, or otherwise
+ * never produce output still reads `ok: true` in `agents monitors runs`
+ * forever, while `agents monitors logs` (which reads the run record fresh)
+ * shows the real status. Re-reading the run here, at DISPLAY time, closes that
+ * gap without touching the write path or the frozen historical record on disk.
+ *
+ * A fire with no `runId` (a `notify`/`webhook-out` action, or a `run`/`routine`
+ * dispatch that never got a runId at all) has nothing to reconcile against —
+ * its frozen `ok` is the only signal and is returned as-is.
+ */
+export declare function resolveFireOutcome(jobName: string, fire: FireRecord): ReconciledFireOutcome;

package/dist/lib/monitors/state.js

@@ -15,6 +15,7 @@ import * as path from 'path';
 import { createHash } from 'crypto';
 import { getMonitorsHistoryDir, ensureAgentsDir } from '../state.js';
 import { safeJoin } from '../paths.js';
+import { readRunMeta } from '../scheduling/routines.js';
 const MAX_STORED_VALUE = 4096;
 /** Per-monitor history root, with the (untrusted) name contained to one segment. */
 export function getMonitorHistoryDir(name) {
@@ -198,3 +199,32 @@ export function listFires(name) {
     }
     return fires;
 }
+/** Run statuses that read as a healthy fire: still in flight, or settled clean. */
+const OK_RUN_STATUSES = new Set(['running', 'completed']);
+/**
+ * Reconcile a fire's frozen `ok` against its dispatched run's REAL, current
+ * status — the render-time fix for RUSH-2690.
+ *
+ * `writeFireRecord` (this module) persists `ok` once, at fire time, from
+ * `dispatchAction`'s synchronous return. For a `run`/`routine` action that
+ * return is a snapshot: `executeJobDetached` writes `status: 'running'` before
+ * spawning and hands that back immediately, so `dispatchAction`'s negative
+ * check (`skipped`/`blocked`/`failed`) never sees the async outcome that lands
+ * later via `settle()` — a run that goes on to fail, time out, or otherwise
+ * never produce output still reads `ok: true` in `agents monitors runs`
+ * forever, while `agents monitors logs` (which reads the run record fresh)
+ * shows the real status. Re-reading the run here, at DISPLAY time, closes that
+ * gap without touching the write path or the frozen historical record on disk.
+ *
+ * A fire with no `runId` (a `notify`/`webhook-out` action, or a `run`/`routine`
+ * dispatch that never got a runId at all) has nothing to reconcile against —
+ * its frozen `ok` is the only signal and is returned as-is.
+ */
+export function resolveFireOutcome(jobName, fire) {
+    if (!fire.runId)
+        return { ok: fire.ok !== false };
+    const run = readRunMeta(jobName, fire.runId);
+    if (!run)
+        return { ok: fire.ok !== false };
+    return { ok: OK_RUN_STATUSES.has(run.status), runStatus: run.status };
+}

package/dist/lib/notify.d.ts

@@ -13,7 +13,7 @@
  * monitor daemon and the feed-dispatch loop call in here, and `process.exit()`
  * would take them down on a typo'd channel name, bypassing their try/catch.
  */
-import type { OpenBlock } from './feed.js';
+import type { OpenBlock } from './feed/feed.js';
 import type { Meta } from './types.js';
 import type { SendResult } from './channels/registry.js';
 export interface OwnerNotifyOptions {

package/dist/lib/observe-aliases.d.ts

@@ -6,12 +6,12 @@
  *
  *   inbox    → feed                  (needs-you default)
  *   timeline → feed --filter updates (agent progress stream)
- *   roster   → sessions --active     (live agent roster)
  *
+ * `roster` was removed — use `agents sessions --active`.
  * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
  * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
  */
-export type ObserveAlias = 'inbox' | 'timeline' | 'roster';
+export type ObserveAlias = 'inbox' | 'timeline';
 export declare const OBSERVE_ALIASES: readonly ObserveAlias[];
 export interface ObserveExpandResult {
     /** argv for the real command (no program name): e.g. ['feed', '--filter', 'updates'] */

package/dist/lib/observe-aliases.js

@@ -6,12 +6,12 @@
  *
  *   inbox    → feed                  (needs-you default)
  *   timeline → feed --filter updates (agent progress stream)
- *   roster   → sessions --active     (live agent roster)
  *
+ * `roster` was removed — use `agents sessions --active`.
  * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
  * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
  */
-export const OBSERVE_ALIASES = ['inbox', 'timeline', 'roster'];
+export const OBSERVE_ALIASES = ['inbox', 'timeline'];
 /** True when `rest` already carries a `--filter` / `--filter=…` flag. */
 export function hasFilterFlag(rest) {
     return rest.some((a) => a === '--filter' || a.startsWith('--filter='));
@@ -41,15 +41,6 @@ export function expandObserveAlias(alias, rest = []) {
                 note: 'agents timeline → agents feed --filter updates',
             };
         }
-        case 'roster': {
-            const argv = hasActiveFlag(tail)
-                ? ['sessions', ...tail]
-                : ['sessions', '--active', ...tail];
-            return {
-                argv,
-                note: 'agents roster → agents sessions --active',
-            };
-        }
         default:
             return null;
     }

package/dist/lib/output/git-output.js

@@ -1,7 +1,7 @@
 /**
- * Git / GitHub "output" collector — the shipped-work half of `agents output`.
+ * Git / GitHub "output" collector — the shipped-work half of `agents insights output`.
  *
- * `agents cost` answers "what did we burn?"; this answers "what did we ship?".
+ * `agents insights cost` answers "what did we burn?"; this answers "what did we ship?".
  * It counts commits (across every author identity, so multi-account totals stay
  * correct regardless of which `gh` login is active) and PRs opened / merged in a
  * time window. Pure `git`/`gh` over child_process — no server, no telemetry,

package/dist/lib/overdue.d.ts

@@ -11,7 +11,7 @@
  * Surfaced two ways: a desktop notification on daemon startup, and a
  * `agents routines catchup` command that runs them on demand.
  */
-import { type JobConfig } from './routines.js';
+import { type JobConfig } from './scheduling/routines.js';
 export interface OverdueJob {
     name: string;
     /** Most recent expected fire time per the cron expression. */

package/dist/lib/overdue.js

@@ -13,7 +13,7 @@
  */
 import * as fs from 'fs';
 import { Cron } from 'croner';
-import { listJobs, getLatestRun, resolveJobFilePath, isPastEndAt, isOneShotRoutine, jobRunsOnThisDevice } from './routines.js';
+import { listJobs, getLatestRun, resolveJobFilePath, isPastEndAt, isOneShotRoutine, jobRunsOnThisDevice } from './scheduling/routines.js';
 import { notifyDesktop } from './menubar/notify-desktop.js';
 // Tolerance between "expected fire" and "recorded run start" — accounts for
 // the small gap between the cron tick and when the runner writes meta.json.

package/dist/lib/permissions-registry.d.ts

@@ -0,0 +1,65 @@
+import type { AgentId, PermissionSet } from './types.js';
+/** Canonical tool (lowercased) -> Grok's lowercase tool vocabulary. */
+export declare const GROK_TOOL_BY_CANONICAL: Record<string, string | undefined>;
+/** Canonical tool -> Kiro CLI v3 capability id. */
+export declare const KIRO_CAPABILITY_BY_TOOL: Record<string, string | undefined>;
+/** Canonical tool -> OpenClaw tool id (tool-level granularity only). */
+export declare const CANONICAL_TO_OPENCLAW_TOOL: Record<string, string>;
+/** Canonical tool -> Antigravity's action namespace. */
+export declare const ANTIGRAVITY_ACTION_BY_TOOL: Record<string, string | undefined>;
+/**
+ * Strip JSON comments for JSONC parsing, only OUTSIDE string literals.
+ *
+ * A naive `//`-to-end-of-line regex destroys
+ * `"$schema": "https://opencode.ai/config.json"` — which every
+ * opencode-generated config carries — so the file then fails to parse and its
+ * permissions read back as absent, the very defect this registry exists to fix.
+ * Exported so `permissions.ts` shares this one implementation instead of
+ * keeping its own copy.
+ */
+export declare function stripJsonComments(content: string): string;
+/** The complete permissions contract for one agent. */
+export interface PermissionTarget {
+    /** Permissions file under a HOME root (a version home, or the real HOME). */
+    home(home: string): string;
+    /** Permissions file for a project checkout, when the harness reads one. */
+    project?: (cwd: string) => string;
+    /**
+     * Read `configPath` and project it to canonical form. Returns null when the
+     * file is absent, unreadable, or records no permissions — never throws.
+     */
+    toCanonical(configPath: string): PermissionSet | null;
+    /** One line naming what this harness's shape loses on the way back. */
+    lossyBecause: string;
+    /**
+     * Extra path suffixes this harness's config may use, for DETECTION only.
+     *
+     * `home()`/`project()` may probe the filesystem to pick between accepted
+     * spellings, which is correct when resolving a real root but meaningless for
+     * detection — `detectPermissionAgentFromPath` passes `''`, so the probe would
+     * resolve against `process.cwd()` and make the same input detect differently
+     * depending on where the CLI was run.
+     *
+     * Detection still calls `home('')`/`project('')`, since most targets are pure
+     * `path.join` and need no entry. A target whose resolver probes MUST list
+     * EVERY spelling it can return — that is what makes the probe's answer
+     * irrelevant rather than unreachable. `existingOr` (opencode) is the only
+     * probing resolver today; `permissions-registry.test.ts` pins the invariant
+     * for the whole table rather than leaving it as prose.
+     */
+    altSuffixes?: string[];
+}
+/**
+ * Single source of truth for where each allowlist-capable agent stores
+ * permissions and how to read them back. Keys MUST equal
+ * `capableAgents('allowlist')` — pinned by `permissions-registry.test.ts`.
+ */
+export declare const PERMISSION_TARGETS: Partial<Record<AgentId, PermissionTarget>>;
+/** The registry entry for `agent`, or undefined when it stores no permissions. */
+export declare function permissionTarget(agent: AgentId): PermissionTarget | undefined;
+/**
+ * Read `agent`'s permissions from `home` (a version home or the real HOME) and
+ * project them to canonical form. `scope: 'project'` reads the repo-local file
+ * for the harnesses that have one, and returns null for those that do not.
+ */
+export declare function readCanonicalPermissions(agent: AgentId, scope?: 'user' | 'project', cwd?: string, home?: string): PermissionSet | null;