@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/routine-notify-owner.js

@@ -1,30 +1,3 @@
-/**
- * Owner phone notification on routine FAILURE (RUSH-2288).
- *
- * The desktop lifecycle notifications (routine-notify.ts) never leave the
- * machine, so a failed scheduled routine on a headless fleet box was invisible
- * until someone happened to look. The per-routine prompt pattern (a prompt that
- * ends by shelling `agents send --to owner`) does not close the gap either: when the
- * routine's OWN agent fails to spawn (`auth_failed`) that prompt never runs, so
- * the one failure most worth surfacing is the one that goes unheard.
- *
- * So the DAEMON delivers on failure, from the SAME owner channel stack `agents
- * send --to owner` uses (humans.yaml owner channels, or the legacy `notify.owner`),
- * calling the channel providers IN-PROCESS — no shelling out to `ssh mac-mini
- * agents send --to owner`. When the primary owner channel cannot deliver from this box it
- * walks the remaining configured owner channels as fallbacks (OpenClaw, a second
- * channel, …). Telegram is never used.
- *
- * Only failures notify. A green routine of any kind stays silent — this is an
- * ADDITIONAL failures-only lane, and the desktop thresholds (which still ping a
- * green agent/workflow finish on the local screen) are unchanged. Delivery is
- * deduped per job+runId so a run is announced to the owner at most once.
- *
- * The message BUILDERS (`routineFinishOwnerText` / `routineStartFailedOwnerText`)
- * are pure and unit-tested; `notifyOwnerRoutineFinish` /
- * `notifyOwnerRoutineStartFailed` are the daemon glue that reads config and
- * delivers.
- */
 import * as os from 'os';
 import { routineKind } from './routine-notify.js';
 import { readMeta } from './state.js';
@@ -32,9 +5,7 @@ import { getOwnerFromHumans } from './humans.js';
 import { readOwnerDest } from './channels/send.js';
 import { registerBuiltinProviders } from './channels/providers/index.js';
 import { lookupTransport } from './channels/resolve.js';
-/** Transports that are Telegram in any form — never delivered to (owner rule). */
 const TELEGRAM_TRANSPORTS = new Set(['telegram', 'openclaw-telegram']);
-/** Human label for the routine body ("agent claude", "workflow deploy", "command"). */
 function routineLabel(r) {
     const kind = routineKind(r);
     if (kind === 'command')
@@ -43,7 +14,6 @@ function routineLabel(r) {
         return `workflow ${r.workflow}`;
     return `agent ${r.agent ?? 'unknown'}`;
 }
-/** The failure reason line for a terminal run: timeout / error message / exit code. */
 function failureReason(meta) {
     if (meta.status === 'timeout')
         return 'Timed out';
@@ -51,36 +21,14 @@ function failureReason(meta) {
         return meta.errorMessage;
     return `Exited with code ${meta.exitCode ?? '?'}`;
 }
-/**
- * Owner-phone text for a routine FINISH, or null when the run did NOT fail. Only
- * `failed` and `timeout` are failures worth an owner ping — a `completed` run
- * (any kind) is silent, and `running`/`missed` never reach this path from the
- * daemon's finish hook. The text is a short, phone-sized pointer: what failed,
- * why, and on which box (so the owner knows where to look), well under the
- * `user-message-guard` length ceiling.
- */
 export function routineFinishOwnerText(meta, host) {
     if (meta.status !== 'failed' && meta.status !== 'timeout')
         return null;
     return `Routine failed: ${meta.jobName}\n${failureReason(meta)}\n${routineLabel(meta)} · ${host}`;
 }
-/**
- * Owner-phone text for a routine that failed to even START (the daemon's
- * pre-spawn catch — `executeJobDetached` threw before a child existed, e.g.
- * `auth_failed`). Never null: a broken start is always a failure worth the ping,
- * for every routine kind, and it is exactly the case the per-routine `agents
- * notify` prompt can never cover because that prompt never ran.
- */
 export function routineStartFailedOwnerText(config, error, host) {
     return `Routine failed to start: ${config.name}\n${error}\n${routineLabel(config)} · ${host}`;
 }
-/**
- * True when a channel would deliver over Telegram. Checks, in order:
- * 1. the channel id itself (`telegram`);
- * 2. the humans.yaml `transport` field on the channel entry (when provided);
- * 3. `notify.transports[id]` remapping (or the id as the default transport name).
- * Any of those landing on a Telegram-delivering provider is excluded.
- */
 function isTelegramChannel(channelId, meta, humansTransport) {
     if (channelId.trim().toLowerCase() === 'telegram')
         return true;
@@ -90,18 +38,6 @@ function isTelegramChannel(channelId, meta, humansTransport) {
     const transport = meta.notify?.transports?.[channelId] ?? channelId;
     return TELEGRAM_TRANSPORTS.has(transport.trim().toLowerCase());
 }
-/**
- * Ordered owner delivery plan for a failure ping: the primary owner destination
- * (the same one `agents send --to owner` resolves) first, then every other configured
- * owner channel as a fallback. Deduped by (channel, to). Telegram channels and
- * intrusive channels (a voice call is too much for a routine failure) are
- * excluded entirely — so an owner whose ONLY channel is Telegram gets an empty
- * plan and no ping, which is the intended "silence beats Telegram" outcome.
- *
- * The same filters apply to the primary and the fallback list — a policy that
- * points normal severity at a voice channel must not auto-call the owner on
- * every routine failure.
- */
 export function ownerFailureDeliveryPlan(meta) {
     const plan = [];
     const seen = new Set();
@@ -123,24 +59,14 @@ export function ownerFailureDeliveryPlan(meta) {
         seen.add(key);
         plan.push({ channel: c, to: t });
     };
-    // Primary = the destination `agents send --to owner` would resolve (humans policy →
-    // first addressable → legacy notify.owner). Same filters as the fallbacks.
     const primary = readOwnerDest(meta);
     if (primary)
         push(primary.channel, primary.to);
-    // Fallbacks = the remaining configured owner channels, in declared order.
     for (const ch of ownerChannels) {
         push(ch.id, ch.to);
     }
     return plan;
 }
-/**
- * Deliver `text` to the owner over the failure plan, in-process, trying each
- * channel until one accepts. Uses the non-dying `lookupTransport` (never
- * `resolveTransport`, which `die()`s the process) so a daemon survives a bad
- * channel name. Best-effort by contract: the daemon wraps this in try/catch, but
- * it also never throws for a delivery failure — it returns the attempt log.
- */
 export async function deliverOwnerFailure(text, meta) {
     const plan = ownerFailureDeliveryPlan(meta);
     const attempts = [];
@@ -169,21 +95,8 @@ export async function deliverOwnerFailure(text, meta) {
     }
     return { delivered: false, attempts };
 }
-/**
- * Per-process dedup of failure pings, keyed by job+runId (finishes) or the
- * synthetic start-failed key. A run is announced to the owner at most once even
- * if the finish hook fires twice or a later sweep re-finalizes the same record.
- * Bounded so a long-lived daemon never grows it without limit.
- */
 const notifiedFailures = new Set();
 const MAX_DEDUP_KEYS = 1000;
-/**
- * Claim a dedup key for an in-flight delivery. Returns false when this
- * job+runId was already delivered (or is already in flight). Callers MUST
- * {@link releaseFailureKey} when delivery fails so a later tick can retry —
- * claiming before send without a release would suppress permanent failures
- * forever (RUSH-2288 review).
- */
 function claimFailureKey(key) {
     if (notifiedFailures.has(key))
         return false;
@@ -192,26 +105,17 @@ function claimFailureKey(key) {
     notifiedFailures.add(key);
     return true;
 }
-/** Drop a key so a failed delivery can be retried on the next finish hook. */
 function releaseFailureKey(key) {
     notifiedFailures.delete(key);
 }
-/** Test-only: reset the dedup set so cases don't leak state into each other. */
 export function __resetOwnerFailureDedup() {
     notifiedFailures.clear();
 }
-/** A green run / deduped skip attempted no channel. */
 const NO_DELIVERY = { delivered: false, attempts: [] };
-/**
- * Daemon glue: on a routine FINISH, ping the owner IFF the run failed. Green
- * runs return early (no ping). Deduped per job+runId — claimed for the
- * in-flight window so two finish hooks don't double-text, released when no
- * channel accepted so a later sweep can retry. Best-effort.
- */
 export async function notifyOwnerRoutineFinish(meta) {
     const text = routineFinishOwnerText(meta, os.hostname());
     if (!text)
-        return NO_DELIVERY; // green / non-terminal → silent
+        return NO_DELIVERY;
     const key = `${meta.jobName} ${meta.runId}`;
     if (!claimFailureKey(key))
         return NO_DELIVERY;
@@ -220,12 +124,6 @@ export async function notifyOwnerRoutineFinish(meta) {
         releaseFailureKey(key);
     return result;
 }
-/**
- * Daemon glue: on a pre-spawn failure (no run record, so no finish hook and no
- * runId), ping the owner. Not deduped — a pre-spawn failure is one scheduled
- * fire on the cron cadence (never a per-second storm), and each such fire is a
- * distinct failure the owner should hear about. Best-effort.
- */
 export async function notifyOwnerRoutineStartFailed(config, error) {
     const text = routineStartFailedOwnerText(config, error, os.hostname());
     return deliverOwnerFailure(text, readMeta());

package/dist/lib/routine-notify.d.ts

@@ -1,87 +1,17 @@
-/**
- * Routine lifecycle desktop notifications (RUSH-2030).
- *
- * The daemon fires a branded notification when a scheduled routine starts and
- * when it finishes (success or failure), routed through the MenubarHelper
- * companion (notify-desktop.ts) so it carries the agents-cli mark.
- *
- * Anti-spam threshold (Acceptance Criteria #4 — "define a sensible threshold so
- * users are not spammed"):
- *   - Agent / workflow routines: notify on BOTH start and finish. These are the
- *     runs whose output a user actually wants surfaced.
- *   - Command routines (deterministic housekeeping — version checks, `git pull`,
- *     notify shims that can fire every minute): notify only on FAILURE. A green
- *     housekeeping run is noise; a broken one is worth a ping. No start ping.
- *   - "Notable output" is folded into the single finish notification rather than
- *     sent as a third message: on failure the error reason, on success the first
- *     line of the run's report (the user-facing result) when the routine produced
- *     one. One start + one finish per run — never a stream.
- *
- * The pure builders (`routineStartNotification` / `routineFinishNotification`)
- * return `null` when the threshold says "don't notify", and are unit-tested; the
- * `notifyRoutine*` wrappers do the filesystem read + dispatch for the daemon.
- */
 import type { JobConfig, RunMeta } from './scheduling/routines.js';
 import { type DesktopNotification } from './menubar/notify-desktop.js';
 type RoutineKind = 'agent' | 'workflow' | 'command';
-/** Which flavor of routine a config/meta describes — drives the notify threshold. */
 export declare function routineKind(r: Pick<JobConfig, 'agent' | 'workflow' | 'command'>): RoutineKind;
-/**
- * The harness a routine runs on, for the notification's right-hand avatar, or
- * undefined when none owns it. A command routine is deterministic housekeeping
- * with no agent, so it gets no avatar. An agent routine names its own harness.
- * A workflow routine has no `agent` field (the schema omits it — routines.ts
- * `JobConfig.agent` and the validation that rejects setting both), and it runs
- * via `agents run <workflow>`, which delegates to claude under the hood — so its
- * avatar is the Claude mark, matching `effectiveAgent` on the finish path
- * (runner.ts). Start and finish banners therefore show the same avatar.
- */
 export declare function routineAgent(r: Pick<JobConfig, 'agent' | 'workflow' | 'command'>): string | undefined;
-/** "1m 20s" / "45s" / "2h 3m" from a millisecond duration, or null when unknown. */
 export declare function formatDuration(ms: number | undefined): string | null;
-/**
- * First non-empty line of a run report, trimmed to a notification-sized snippet.
- * This is the "notable output" surfaced on a successful finish — the routine's
- * own user-facing result. Returns null for an empty/whitespace report so the
- * caller falls back to a plain "Completed" body.
- */
 export declare function notableSnippet(report: string | null | undefined, maxLen?: number): string | null;
-/**
- * Notification for a routine START, or null when the threshold suppresses it
- * (command-mode housekeeping). Clicking opens the runs folder
- * (~/.agents/.history/runs).
- */
 export declare function routineStartNotification(config: Pick<JobConfig, 'name' | 'agent' | 'workflow' | 'command'>): DesktopNotification | null;
-/**
- * Notification for a routine that failed to even START — `executeJobDetached`
- * threw before the child was spawned, so no run record and no finish will ever
- * exist. The daemon fires the START notification unconditionally, so this closes
- * the "exactly one start + one finish" invariant: the orphaned start gets its
- * matching failure banner (RUSH-2030). Unlike a green finish this is never
- * suppressed — a broken start is worth a ping for every routine kind, including
- * command housekeeping. Clicking opens the runs folder (~/.agents/.history/runs)
- * since there is no run report to open.
- */
 export declare function routineStartFailedNotification(config: Pick<JobConfig, 'name' | 'agent' | 'workflow' | 'command'>, error: string): DesktopNotification;
-/**
- * Notification for a routine FINISH, or null when the threshold suppresses it
- * (a successful command-mode housekeeping run). Success carries the report's
- * first line when present (the notable output); failure carries the reason.
- * Clicking opens the run report/log when one is available, else the runs folder
- * (~/.agents/.history/runs).
- */
 export declare function routineFinishNotification(meta: Pick<RunMeta, 'jobName' | 'status' | 'exitCode' | 'errorMessage' | 'duration' | 'agent' | 'workflow' | 'command'>, opts?: {
     report?: string | null;
     artifactPath?: string | null;
 }): DesktopNotification | null;
-/** Daemon glue: fire the START notification for a triggered routine. Best-effort. */
 export declare function notifyRoutineStart(config: JobConfig): void;
-/**
- * Daemon glue: fire the "failed to start" notification when a routine trigger
- * threw before spawning a child. Pairs with the unconditional START ping so a
- * pre-spawn failure never leaves an orphaned "Routine started". Best-effort.
- */
 export declare function notifyRoutineStartFailed(config: JobConfig, error: string): void;
-/** Daemon glue: fire the FINISH notification for a completed run. Best-effort. */
 export declare function notifyRoutineFinish(meta: RunMeta): void;
 export {};

package/dist/lib/routine-notify.js

@@ -1,31 +1,7 @@
-/**
- * Routine lifecycle desktop notifications (RUSH-2030).
- *
- * The daemon fires a branded notification when a scheduled routine starts and
- * when it finishes (success or failure), routed through the MenubarHelper
- * companion (notify-desktop.ts) so it carries the agents-cli mark.
- *
- * Anti-spam threshold (Acceptance Criteria #4 — "define a sensible threshold so
- * users are not spammed"):
- *   - Agent / workflow routines: notify on BOTH start and finish. These are the
- *     runs whose output a user actually wants surfaced.
- *   - Command routines (deterministic housekeeping — version checks, `git pull`,
- *     notify shims that can fire every minute): notify only on FAILURE. A green
- *     housekeeping run is noise; a broken one is worth a ping. No start ping.
- *   - "Notable output" is folded into the single finish notification rather than
- *     sent as a third message: on failure the error reason, on success the first
- *     line of the run's report (the user-facing result) when the routine produced
- *     one. One start + one finish per run — never a stream.
- *
- * The pure builders (`routineStartNotification` / `routineFinishNotification`)
- * return `null` when the threshold says "don't notify", and are unit-tested; the
- * `notifyRoutine*` wrappers do the filesystem read + dispatch for the daemon.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getRunDir } from './scheduling/routines.js';
 import { notifyDesktop } from './menubar/notify-desktop.js';
-/** Which flavor of routine a config/meta describes — drives the notify threshold. */
 export function routineKind(r) {
     if (r.command)
         return 'command';
@@ -33,16 +9,6 @@ export function routineKind(r) {
         return 'workflow';
     return 'agent';
 }
-/**
- * The harness a routine runs on, for the notification's right-hand avatar, or
- * undefined when none owns it. A command routine is deterministic housekeeping
- * with no agent, so it gets no avatar. An agent routine names its own harness.
- * A workflow routine has no `agent` field (the schema omits it — routines.ts
- * `JobConfig.agent` and the validation that rejects setting both), and it runs
- * via `agents run <workflow>`, which delegates to claude under the hood — so its
- * avatar is the Claude mark, matching `effectiveAgent` on the finish path
- * (runner.ts). Start and finish banners therefore show the same avatar.
- */
 export function routineAgent(r) {
     const kind = routineKind(r);
     if (kind === 'command')
@@ -51,7 +17,6 @@ export function routineAgent(r) {
         return 'claude';
     return r.agent?.trim() || undefined;
 }
-/** Human label for the routine body ("agent claude", "workflow deploy", "command"). */
 function routineLabel(r) {
     if (r.command)
         return 'command';
@@ -59,7 +24,6 @@ function routineLabel(r) {
         return `workflow ${r.workflow}`;
     return `agent ${r.agent ?? 'unknown'}`;
 }
-/** "1m 20s" / "45s" / "2h 3m" from a millisecond duration, or null when unknown. */
 export function formatDuration(ms) {
     if (ms === undefined || !Number.isFinite(ms) || ms < 0)
         return null;
@@ -74,12 +38,6 @@ export function formatDuration(ms) {
     const remMin = min % 60;
     return remMin ? `${hr}h ${remMin}m` : `${hr}h`;
 }
-/**
- * First non-empty line of a run report, trimmed to a notification-sized snippet.
- * This is the "notable output" surfaced on a successful finish — the routine's
- * own user-facing result. Returns null for an empty/whitespace report so the
- * caller falls back to a plain "Completed" body.
- */
 export function notableSnippet(report, maxLen = 140) {
     if (!report)
         return null;
@@ -91,15 +49,9 @@ export function notableSnippet(report, maxLen = 140) {
         return null;
     return firstLine.length > maxLen ? `${firstLine.slice(0, maxLen - 1).trimEnd()}…` : firstLine;
 }
-/** Encode a click action that opens a file (report/log) in the default app. */
 function openAction(filePath) {
     return filePath ? `open:${filePath}` : undefined;
 }
-/**
- * Notification for a routine START, or null when the threshold suppresses it
- * (command-mode housekeeping). Clicking opens the runs folder
- * (~/.agents/.history/runs).
- */
 export function routineStartNotification(config) {
     if (routineKind(config) === 'command')
         return null;
@@ -111,16 +63,6 @@ export function routineStartNotification(config) {
         agent: routineAgent(config),
     };
 }
-/**
- * Notification for a routine that failed to even START — `executeJobDetached`
- * threw before the child was spawned, so no run record and no finish will ever
- * exist. The daemon fires the START notification unconditionally, so this closes
- * the "exactly one start + one finish" invariant: the orphaned start gets its
- * matching failure banner (RUSH-2030). Unlike a green finish this is never
- * suppressed — a broken start is worth a ping for every routine kind, including
- * command housekeeping. Clicking opens the runs folder (~/.agents/.history/runs)
- * since there is no run report to open.
- */
 export function routineStartFailedNotification(config, error) {
     return {
         title: 'Routine failed',
@@ -130,18 +72,11 @@ export function routineStartFailedNotification(config, error) {
         agent: routineAgent(config),
     };
 }
-/**
- * Notification for a routine FINISH, or null when the threshold suppresses it
- * (a successful command-mode housekeeping run). Success carries the report's
- * first line when present (the notable output); failure carries the reason.
- * Clicking opens the run report/log when one is available, else the runs folder
- * (~/.agents/.history/runs).
- */
 export function routineFinishNotification(meta, opts = {}) {
     const kind = routineKind(meta);
     const ok = meta.status === 'completed';
     if (kind === 'command' && ok)
-        return null; // green housekeeping is noise
+        return null;
     const action = openAction(opts.artifactPath) ?? 'routines:list';
     if (ok) {
         const snippet = notableSnippet(opts.report);
@@ -154,7 +89,6 @@ export function routineFinishNotification(meta, opts = {}) {
             agent: routineAgent(meta),
         };
     }
-    // failed | timeout
     const reason = meta.status === 'timeout'
         ? 'Timed out'
         : meta.errorMessage
@@ -168,7 +102,6 @@ export function routineFinishNotification(meta, opts = {}) {
         agent: routineAgent(meta),
     };
 }
-/** Read a finished run's report text + the best artifact to open on click. */
 function loadRunArtifacts(meta) {
     try {
         const runDir = getRunDir(meta.jobName, meta.runId);
@@ -189,21 +122,14 @@ function loadRunArtifacts(meta) {
         return { report: null, artifactPath: null };
     }
 }
-/** Daemon glue: fire the START notification for a triggered routine. Best-effort. */
 export function notifyRoutineStart(config) {
     const n = routineStartNotification(config);
     if (n)
         notifyDesktop(n);
 }
-/**
- * Daemon glue: fire the "failed to start" notification when a routine trigger
- * threw before spawning a child. Pairs with the unconditional START ping so a
- * pre-spawn failure never leaves an orphaned "Routine started". Best-effort.
- */
 export function notifyRoutineStartFailed(config, error) {
     notifyDesktop(routineStartFailedNotification(config, error));
 }
-/** Daemon glue: fire the FINISH notification for a completed run. Best-effort. */
 export function notifyRoutineFinish(meta) {
     const { report, artifactPath } = loadRunArtifacts(meta);
     const n = routineFinishNotification(meta, { report, artifactPath });

package/dist/lib/routine-process-cleanup.d.ts

@@ -5,6 +5,5 @@ interface RoutineProcessCleanupOptions {
     owns?: (meta: RunMeta) => Promise<boolean> | boolean;
     terminate?: (pid: number) => void;
 }
-/** Reap process groups whose durable run record is already terminal. */
 export declare function reapTerminalRoutineProcesses(opts?: RoutineProcessCleanupOptions): Promise<number[]>;
 export {};

package/dist/lib/routine-process-cleanup.js

@@ -3,7 +3,6 @@ import * as path from 'path';
 import { execFileBounded } from './exec-bounded.js';
 import { isAlive, killTree } from './platform/index.js';
 import { getRunsDir } from './state.js';
-/** Bound the identity probe: a `ps`/`powershell` spawn on the heartbeat tick must never freeze the daemon's event loop. */
 const IDENTITY_PROBE_TIMEOUT_MS = 5_000;
 async function processMatchesRun(meta) {
     if (!meta.pid || !meta.spawnedAt)
@@ -33,7 +32,6 @@ async function processMatchesRun(meta) {
         + Number(fields[3] ?? 0) * 86400;
     return Math.abs((Date.now() - seconds * 1000) - meta.spawnedAt) < 30_000;
 }
-/** Reap process groups whose durable run record is already terminal. */
 export async function reapTerminalRoutineProcesses(opts = {}) {
     const runsDir = opts.runsDir ?? getRunsDir();
     const alive = opts.alive ?? isAlive;
@@ -44,7 +42,7 @@ export async function reapTerminalRoutineProcesses(opts = {}) {
         jobs = await fsp.readdir(runsDir, { withFileTypes: true });
     }
     catch {
-        return []; // runs dir absent — nothing to reap
+        return [];
     }
     const reaped = [];
     for (const job of jobs) {
@@ -76,7 +74,6 @@ export async function reapTerminalRoutineProcesses(opts = {}) {
                 reaped.push(meta.pid);
             }
             catch {
-                // Corrupt or concurrently-replaced records are left untouched.
             }
         }
     }

package/dist/lib/routine-readiness.d.ts

@@ -1,37 +1,7 @@
-/**
- * Activation readiness for a routine, composed from the target-aware execution
- * context ({@link resolveJobExecutionContext}) plus the harness/target checks a
- * caller can perform on this box (agent installed). This is the gate `add`,
- * `edit`, `doctor`, and `resume` all run before activating a routine: ready →
- * active, any proven blocker → saved paused with a stable code + repair command.
- *
- * Structural context readiness is synchronous for the scheduler. Interactive
- * add/edit/doctor/resume additionally call the live variant below, which probes
- * authentication and Codex's native workspace-trust record before activation.
- */
 import type { JobConfig } from './scheduling/routines.js';
 import { type RoutineReadinessResult, type RoutineReadiness } from './routine-context.js';
 import { type AuthVerdict } from './auth-health.js';
-/**
- * Fire-time auth preflight: read the daemon-warmed auth-health cache for the
- * exact (agent, version) a routine has resolved to run, and return an
- * `agent_auth_failed` blocker when that account is provably signed out — so the
- * daemon records a terminal `blocked` run (with the re-login repair) instead of
- * spawning a doomed run that 401s and burns a session (PHNX-3415).
- *
- * Cache-only (no network, no prompt — the daemon refreshes the cache
- * periodically and `fleet ping` writes it), and fails OPEN on a missing or
- * non-blocking verdict so a stale/absent probe never wedges a routine. It is
- * checked AFTER version rotation resolves the account (`launch.chain[0]`), so it
- * judges the identity the run will actually use, never a rotated-past dead pin.
- */
 export declare function fireTimeAuthReadiness(agent: string, version: string): RoutineReadiness | null;
-/**
- * Evaluate whether a routine is ready to activate on this box. `probeAgent`
- * defaults to "is a version of the routine's agent resolvable" via
- * {@link resolveVersion}; pass a stub in tests to exercise the availability path
- * without an installed harness.
- */
 export declare function evaluateActivationReadiness(config: JobConfig, deps?: {
     probeAgent?: (agent: string) => boolean;
 }): RoutineReadinessResult;
@@ -40,55 +10,22 @@ interface RemoteProjectDefinition {
     root?: string;
     defaultPath?: string;
 }
-/** Parse the target HOME sentinel and the project catalog returned by one SSH call. */
 export declare function parseRemoteProjectSnapshot(stdout: string): {
     home: string;
     projects: RemoteProjectDefinition[];
 } | undefined;
-/** Build a target-native probe that creates and removes a file in the workspace. */
 export declare function buildRemoteWorkspaceProbe(cwd: string, windows: boolean): string;
-/** A successful probe must contain the exact requested postcondition, not merely exit zero. */
 export declare function probeOutputHasSentinel(stdout: string, sentinel: string): boolean;
-/**
- * ONE decision the local ({@link evaluateActivationReadinessLive}) and host
- * ({@link evaluateHostActivationReadiness}) readiness paths share, so both reach
- * the SAME answer for the same box (PHNX-4116). `row` is that box's probe verdict
- * for the routine's agent — ABSENT when the box could not probe (a worker's
- * setup-token box, or a headed box that spent its hourly usage-endpoint budget,
- * both drop `no_evidence` in `probeLocalFleetAuth`). `launchable` is whether the
- * box holds a launchable signed-in credential, from the SAME
- * `collectRunCandidates`/`isLaunchableSignedIn` the run router uses — so a
- * token-backed routine on a box that cannot probe stays activatable, a box with
- * no credential at all fails `unconfigured`, and a server rejection (`revoked` —
- * the only present-but-not-accepted verdict these force-probed paths produce)
- * blocks regardless of a token on disk.
- */
 export declare function decideRoutineAuthReadiness(row: {
     verdict: AuthVerdict;
 } | undefined, launchable: boolean): {
     ok: boolean;
     reason?: string;
 };
-/**
- * Decide a host-placed routine's auth readiness from the REMOTE box's `devices
- * ping --local --json` payload (PHNX-4116). Pure over the payload TEXT so it is
- * unit-tested without SSH: it finds this agent's probe row (ABSENT when the box
- * dropped its `no_evidence` row) and reads the box's per-agent launchability the
- * ping now carries, then runs {@link decideRoutineAuthReadiness} — so a host box
- * that could not probe but holds a token is ready, exactly as the local path
- * decides for the same box. Returns null when the payload cannot be parsed; the
- * caller treats that as a probe failure, never as "no credential".
- */
 export declare function decideHostAuthFromPing(stdout: string, agent: string): {
     ok: boolean;
     reason?: string;
 } | null;
-/**
- * Interactive setup/repair readiness. Unlike the scheduler's deterministic
- * structural gate, this completes a real local auth request and reads Codex's
- * native trust record before add/edit/resume can activate the definition.
- */
 export declare function evaluateActivationReadinessLive(config: JobConfig): Promise<RoutineReadinessResult>;
-/** Resolve and probe the actual SSH target used by a host-placed routine. */
 export declare function evaluateHostActivationReadiness(config: JobConfig): Promise<RoutineReadinessResult>;
 export {};