@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/routine-activation.js

@@ -1,9 +1,3 @@
-/** Device-scoped routine activation.
- *
- * Definitions say what a routine does. This module owns the independent answer
- * to whether THIS device runs it: membership in the top-level `routines:` list
- * of `~/.agents/devices/<machine>/agents.yaml`.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
@@ -12,7 +6,6 @@ import { getUserAgentsDir, readMeta, updateMeta } from './state.js';
 export function normalizeRoutineNames(names) {
     return [...new Set([...names].map((name) => name.trim()).filter(Boolean))].sort();
 }
-/** null means this device has not materialized activation state yet. */
 export function enabledRoutineNames() {
     const names = readMeta().deviceRoutines;
     return Array.isArray(names) ? normalizeRoutineNames(names) : null;
@@ -26,11 +19,6 @@ export function replaceEnabledRoutines(names) {
     updateMeta((meta) => ({ ...meta, deviceRoutines: normalized }));
     return normalized;
 }
-/**
- * Add or remove one routine on this machine. `legacyEnabledNames` seeds the
- * manifest the first time an upgraded host changes activation, preserving every
- * other routine that was effectively enabled under the old definition fields.
- */
 export function setRoutineEnabledOnThisDevice(name, enabled, legacyEnabledNames = []) {
     const current = enabledRoutineNames() ?? normalizeRoutineNames(legacyEnabledNames);
     const next = new Set(current);
@@ -40,7 +28,6 @@ export function setRoutineEnabledOnThisDevice(name, enabled, legacyEnabledNames
         next.delete(name);
     return replaceEnabledRoutines(next);
 }
-/** Read-only fleet view from synced device documents. Never writes a peer file. */
 export function devicesWithRoutineEnabled(name) {
     const devicesDir = path.join(getUserAgentsDir(), 'devices');
     if (!fs.existsSync(devicesDir))
@@ -73,14 +60,6 @@ export function devicesWithRoutineEnabled(name) {
     }
     return devices.sort();
 }
-/**
- * Build the whole fleet's activation map in one pass over `devices/`.
- *
- * `devicesWithRoutineEnabled` answers this for a single routine and throws on a
- * corrupt peer file — the right contract for a command acting on one routine,
- * the wrong one for a listing, where a single unreadable device document would
- * blank out every row (and re-walking `devices/` per routine is quadratic).
- */
 export function routineDeviceIndex() {
     const byRoutine = new Map();
     const errors = [];
@@ -121,9 +100,6 @@ export function routineDeviceIndex() {
             continue;
         }
         materialized = true;
-        // Same normalization the writers use (`replaceEnabledRoutines`), so a device
-        // that lists a routine twice, or with stray whitespace, cannot make the index
-        // disagree with `enabledRoutineNames` about what that device enables.
         for (const name of normalizeRoutineNames(routines)) {
             const devices = byRoutine.get(name);
             if (devices)

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

@@ -1,133 +1,50 @@
-/**
- * Routine execution context + readiness resolution.
- *
- * A scheduled routine has to run *somewhere*. This module is the single,
- * target-aware answer to "which directory does this routine's run land in, and
- * is the chosen harness able to start there?" — computed for the eventual
- * execution TARGET, never from the daemon process's own cwd.
- *
- * Two layers, both pure of global state (every input is injected, so a test
- * exercises the real code path against real temp directories rather than a mock):
- *
- *  - {@link resolveRoutineExecutionContext} — resolve the working directory from
- *    the routine's singular `project` anchor and/or portable `cwd`, following the
- *    locked resolution table (see below), and verify the structural + filesystem
- *    readiness of that directory (existence, portability, writability, cloud
- *    portability). This layer owns the *context* readiness codes.
- *  - {@link evaluateRoutineReadiness} — take a resolved context and layer the
- *    *harness/target* readiness codes (agent installed, Codex workspace trust,
- *    live auth, target reachability) via injected probes.
- *
- * Resolution table (target `$HOME` = the execution device's home):
- *
- *  | project | cwd            | resolved dir            | readiness |
- *  |---------|----------------|-------------------------|-----------|
- *  | usable  | —              | project base            | continue  |
- *  | usable  | relative       | base + cwd (inside base)| continue if inside base + exists |
- *  | rootless| relative       | $HOME + cwd             | continue if exists |
- *  | —       | relative       | $HOME + cwd             | continue if exists |
- *  | —       | ~/…            | $HOME-relative          | continue if exists |
- *  | —       | abs under home | normalized to ~/…       | continue  |
- *  | —       | abs outside home| local-pinned only      | pause (cwd_not_portable) for host/fleet/cloud |
- *  | named+unusable | —       | no fallback             | pause (project_path_missing) |
- *  | —       | — (agent/workflow) | no implicit home     | pause (execution_context_missing) |
- *  | —       | — (command)    | $HOME                   | continue (housekeeping) |
- */
-/** Stable, machine-readable readiness codes. A routine is activated only when ready. */
 export type RoutineReadinessCode = 'project_not_found' | 'project_path_missing' | 'cwd_missing' | 'cwd_not_directory' | 'cwd_not_portable' | 'execution_context_missing' | 'cloud_context_unsupported' | 'workspace_not_writable' | 'codex_workspace_untrusted' | 'agent_unavailable' | 'agent_auth_failed' | 'target_unreachable' | 'placement_unsupported' | 'migration_conflict';
 export interface RoutineReadiness {
     code: RoutineReadinessCode;
-    /** Human-readable one-line explanation of the failing check. */
     message: string;
-    /** A single safe command that repairs the blocker, when one exists. */
     repair?: string;
 }
-/** Where the routine body executes — mirrors {@link HostStrategy} placement. */
 export type PlacementMode = 'local' | 'host' | 'fleet' | 'cloud';
-/**
- * What the caller resolved about the routine's singular `project` anchor.
- * `undefined` (the field on the input) means the routine names no project.
- */
 export type ProjectResolution = {
     defined: false;
-}
-/** Defined project; `base` is its portable base dir (`~/…` or absolute), or
- *  undefined for a rootless Linear-imported project with no checkout. */
- | {
+} | {
     defined: true;
     base?: string;
 };
 export type RoutineKind = 'agent' | 'workflow' | 'command';
-/** A filesystem probe against the execution TARGET. */
 export interface ContextFsProbe {
     exists(absPath: string): boolean;
     isDirectory(absPath: string): boolean;
     isWritable(absPath: string): boolean;
 }
 export interface ExecutionContextInput {
-    /** Routine name (for messages only). */
     name?: string;
-    /** Singular execution anchor (`JobConfig.project`). */
     project?: string;
-    /** Portable execution directory (`JobConfig.cwd`). */
     cwd?: string;
-    /** Exactly one of agent/workflow/command determines the fallback rules. */
     kind: RoutineKind;
-    /** Placement of the run — governs portability enforcement and cloud rules. */
     mode: PlacementMode;
-    /** Execution target's absolute `$HOME`. Local: `os.homedir()`; remote: the target home. */
     targetHome: string;
-    /** Resolution of the `project` anchor; omit when the routine names no project. */
     projectResolution?: ProjectResolution;
-    /**
-     * Filesystem probe for the target, present only when this process can inspect
-     * it (a local run, or add/edit/doctor invoked on the target box). Absent for a
-     * remote/cloud target we cannot reach — then only structural + portability
-     * checks run (existence is deferred, never assumed).
-     */
     probe?: ContextFsProbe;
 }
 export interface ResolvedExecutionContext {
     project?: string;
-    /** `config.cwd` echoed for the run record. */
     requestedCwd?: string;
-    /** Portable resolved cwd for the run record: `~/…` when under target home, else absolute. */
     resolvedCwd?: string;
-    /** The resolved cwd expanded to an absolute path on the target. Undefined when unresolved. */
     absoluteCwd?: string;
     targetHome: string;
     ready: boolean;
-    /** Present when `ready` is false. */
     readiness?: RoutineReadiness;
 }
-/**
- * True for a bare relative path (not absolute, not home-anchored) ON THE TARGET.
- *
- * `isAbsolute` is evaluated in the TARGET's own path flavour (see
- * {@link targetPath}), not this process's platform — a Windows-shaped absolute
- * cwd (`C:\Users\x\override`) dispatched from a POSIX daemon must still be
- * recognized as absolute, or it is misread as project-relative.
- */
 export declare function isBareRelative(home: string, p: string): boolean;
-/**
- * Resolve the working directory a routine's run lands in and verify its
- * structural + filesystem readiness for the given placement. Pure of global
- * state — every dependency (target home, project resolution, filesystem probe)
- * is injected.
- */
 export declare function resolveRoutineExecutionContext(input: ExecutionContextInput): ResolvedExecutionContext;
-/** Injected harness/target probes for {@link evaluateRoutineReadiness}. */
 interface HarnessReadinessProbes {
-    /** Is the resolved agent+version installed on the target? */
     agentInstalled?(): boolean;
-    /** Is the absolute execution dir a trusted Codex workspace? (Codex agent only.) */
     codexTrusted?(absoluteCwd: string): boolean;
-    /** Live auth verdict for the resolved account/version. `ok:false` → agent_auth_failed. */
     authOk?(): {
         ok: boolean;
         reason?: string;
     };
-    /** Is the execution target reachable? (host/fleet/cloud placement only.) */
     targetReachable?(): boolean;
 }
 export interface RoutineReadinessResult {
@@ -135,13 +52,6 @@ export interface RoutineReadinessResult {
     ready: boolean;
     readiness?: RoutineReadiness;
 }
-/**
- * Layer the harness/target readiness codes onto a resolved execution context.
- * Context blockers short-circuit (no point probing auth for a routine that has
- * no directory to run in). Every probe is optional and injected; an omitted
- * probe is treated as "not applicable / passes" so a caller only pays for the
- * checks it wires up.
- */
 export declare function evaluateRoutineReadiness(context: ResolvedExecutionContext, probes?: HarnessReadinessProbes, opts?: {
     agent?: string;
     version?: string;

package/dist/lib/routine-context.js

@@ -1,55 +1,7 @@
-/**
- * Routine execution context + readiness resolution.
- *
- * A scheduled routine has to run *somewhere*. This module is the single,
- * target-aware answer to "which directory does this routine's run land in, and
- * is the chosen harness able to start there?" — computed for the eventual
- * execution TARGET, never from the daemon process's own cwd.
- *
- * Two layers, both pure of global state (every input is injected, so a test
- * exercises the real code path against real temp directories rather than a mock):
- *
- *  - {@link resolveRoutineExecutionContext} — resolve the working directory from
- *    the routine's singular `project` anchor and/or portable `cwd`, following the
- *    locked resolution table (see below), and verify the structural + filesystem
- *    readiness of that directory (existence, portability, writability, cloud
- *    portability). This layer owns the *context* readiness codes.
- *  - {@link evaluateRoutineReadiness} — take a resolved context and layer the
- *    *harness/target* readiness codes (agent installed, Codex workspace trust,
- *    live auth, target reachability) via injected probes.
- *
- * Resolution table (target `$HOME` = the execution device's home):
- *
- *  | project | cwd            | resolved dir            | readiness |
- *  |---------|----------------|-------------------------|-----------|
- *  | usable  | —              | project base            | continue  |
- *  | usable  | relative       | base + cwd (inside base)| continue if inside base + exists |
- *  | rootless| relative       | $HOME + cwd             | continue if exists |
- *  | —       | relative       | $HOME + cwd             | continue if exists |
- *  | —       | ~/…            | $HOME-relative          | continue if exists |
- *  | —       | abs under home | normalized to ~/…       | continue  |
- *  | —       | abs outside home| local-pinned only      | pause (cwd_not_portable) for host/fleet/cloud |
- *  | named+unusable | —       | no fallback             | pause (project_path_missing) |
- *  | —       | — (agent/workflow) | no implicit home     | pause (execution_context_missing) |
- *  | —       | — (command)    | $HOME                   | continue (housekeeping) |
- */
 import * as path from 'path';
-// --- target-aware path helpers (do NOT use project-root.ts's local-HOME-bound
-// forms: resolution must root at the execution target's home, not this box's) ---
-/**
- * Path flavour of the EXECUTION TARGET, inferred from its own home string.
- *
- * The target home belongs to whichever machine will run the routine, which need
- * not be this one — a Windows box can schedule onto a Linux target. Joining with
- * the LOCAL separator therefore built `\home\user\svc` for a POSIX target (and
- * would build `C:/Users/x/svc` the other way), so these helpers key off the home
- * path's shape instead of `process.platform`. Same-platform behaviour is
- * unchanged; only the cross-platform case is fixed.
- */
 function targetPath(home) {
     return /^[A-Za-z]:[\\/]/.test(home) || home.includes('\\') ? path.win32 : path.posix;
 }
-/** Expand a leading `~`/`$HOME` against the target home; pass other values through. */
 function expandTargetHome(home, p) {
     if (p === '~' || p === '$HOME')
         return home;
@@ -60,7 +12,6 @@ function expandTargetHome(home, p) {
         return tp.join(home, p.slice('$HOME/'.length));
     return p;
 }
-/** Rewrite an absolute path under the target home to its portable `~/…` form; pass others through. */
 function toTargetPortable(home, abs) {
     const tp = targetPath(home);
     const rel = tp.relative(home, abs);
@@ -70,24 +21,9 @@ function toTargetPortable(home, abs) {
         return '~/' + rel.split(tp.sep).join('/');
     return abs;
 }
-/**
- * True for a bare relative path (not absolute, not home-anchored) ON THE TARGET.
- *
- * `isAbsolute` is evaluated in the TARGET's own path flavour (see
- * {@link targetPath}), not this process's platform — a Windows-shaped absolute
- * cwd (`C:\Users\x\override`) dispatched from a POSIX daemon must still be
- * recognized as absolute, or it is misread as project-relative.
- */
 export function isBareRelative(home, p) {
     return !targetPath(home).isAbsolute(p) && !p.startsWith('~') && !p.startsWith('$HOME');
 }
-/**
- * True when `child` is `base` or strictly beneath it (no `..` escape).
- *
- * Compares in the BASE's own path flavour (see {@link targetPath}) — both
- * arguments are target-side paths, and comparing a POSIX pair with Windows
- * semantics (or the reverse) answers about the wrong filesystem.
- */
 function isInside(baseAbs, childAbs) {
     const tp = targetPath(baseAbs);
     const rel = tp.relative(baseAbs, childAbs);
@@ -96,24 +32,14 @@ function isInside(baseAbs, childAbs) {
 function pause(ctx, readiness) {
     return { ...ctx, ready: false, readiness };
 }
-/**
- * Resolve the working directory a routine's run lands in and verify its
- * structural + filesystem readiness for the given placement. Pure of global
- * state — every dependency (target home, project resolution, filesystem probe)
- * is injected.
- */
 export function resolveRoutineExecutionContext(input) {
     const { project, cwd, kind, mode, targetHome, projectResolution, probe } = input;
     const requestedCwd = cwd;
     const base = { project, requestedCwd, targetHome };
     const hasProjectBinding = projectResolution?.defined === true;
-    // Finalize a resolved portable dir: run the cloud/portability/filesystem gates
-    // and return either a ready context or a paused one.
     const finalize = (portable, missingCode) => {
         const absoluteCwd = expandTargetHome(targetHome, portable);
         const ctx = { ...base, resolvedCwd: portable, absoluteCwd };
-        // Cloud: a filesystem-only cwd (no project/repo binding) has no provider
-        // repository to map onto. A project binding selects the provider repo.
         if (mode === 'cloud' && !hasProjectBinding) {
             return pause(ctx, {
                 code: 'cloud_context_unsupported',
@@ -146,7 +72,6 @@ export function resolveRoutineExecutionContext(input) {
         }
         return { ...ctx, ready: true };
     };
-    // 1. Explicit project anchor.
     if (project !== undefined) {
         if (!projectResolution || projectResolution.defined === false) {
             return pause(base, {
@@ -157,15 +82,11 @@ export function resolveRoutineExecutionContext(input) {
         }
         const projBase = projectResolution.base;
         if (projBase) {
-            // Usable base path.
             if (cwd === undefined) {
                 return finalize(projBase, 'project_path_missing');
             }
             if (isBareRelative(targetHome, cwd)) {
                 const baseAbs = expandTargetHome(targetHome, projBase);
-                // Target-side join: `path.resolve` would use this host's separator and,
-                // for a target home this host does not consider absolute, prepend the
-                // local process cwd.
                 const joinedAbs = targetPath(targetHome).resolve(baseAbs, cwd);
                 if (!isInside(baseAbs, joinedAbs)) {
                     return pause(base, {
@@ -175,42 +96,28 @@ export function resolveRoutineExecutionContext(input) {
                 }
                 return finalize(toTargetPortable(targetHome, joinedAbs), 'cwd_missing');
             }
-            // Absolute or home-anchored cwd alongside a project: fall through to the
-            // cwd-first handling below (the project base is not the anchor then).
         }
         else if (cwd === undefined) {
-            // Rootless project (Linear import), no cwd: there is nothing to run in.
             return pause(base, {
                 code: 'project_path_missing',
                 message: `project '${project}' has no checkout path — give it a cwd (anchored at the target home) or set the project's root`,
                 repair: `agents routines edit ${input.name ?? '<name>'} --cwd <path>`,
             });
         }
-        // Rootless project + a cwd, or usable project + a non-relative cwd: the cwd
-        // itself is the anchor. A bare relative cwd anchors at the target home.
     }
-    // 2. cwd without a (usable relative-anchoring) project.
     if (cwd !== undefined) {
         if (cwd.startsWith('~') || cwd.startsWith('$HOME')) {
             const abs = expandTargetHome(targetHome, cwd);
             return finalize(toTargetPortable(targetHome, abs), 'cwd_missing');
         }
-        // Absolute in EITHER path flavour — a Windows daemon resolving a POSIX
-        // target cwd (or the reverse) must not fall through to bare-relative join.
-        // Do not `path.resolve` on the local platform: on win32 that rewrites
-        // `/home/u/override` to `D:\home\u\override` and falsely flags
-        // cwd_not_portable (Windows CI, cross-platform schedule).
         const cwdIsAbsolute = targetPath(targetHome).isAbsolute(cwd) ||
             path.posix.isAbsolute(cwd) ||
             path.win32.isAbsolute(cwd);
         if (cwdIsAbsolute) {
             const resolved = cwd;
             if (isInside(targetHome, resolved)) {
-                // Normalize an absolute-under-home path to its portable form on save.
                 return finalize(toTargetPortable(targetHome, resolved), 'cwd_missing');
             }
-            // Absolute path outside the target home: only a local-pinned routine can
-            // use it; host/fleet/cloud placement cannot carry a non-portable path.
             if (mode === 'local') {
                 return finalize(resolved, 'cwd_missing');
             }
@@ -219,14 +126,9 @@ export function resolveRoutineExecutionContext(input) {
                 message: `absolute cwd '${cwd}' is outside the target home and cannot travel to ${mode} placement — use a home-relative path`,
             });
         }
-        // Bare relative cwd (no usable project base): anchor at the target home,
-        // in the target's own path flavour (see the joinedAbs note above).
         return finalize(toTargetPortable(targetHome, targetPath(targetHome).resolve(targetHome, cwd)), 'cwd_missing');
     }
-    // 3. Neither field.
     if (kind === 'command') {
-        // Command routines are deterministic housekeeping — the target home is a
-        // safe implicit cwd, so a version-check / notify routine keeps working.
         return finalize(toTargetPortable(targetHome, targetHome), 'cwd_missing');
     }
     return pause(base, {
@@ -235,13 +137,6 @@ export function resolveRoutineExecutionContext(input) {
         repair: `agents routines edit ${input.name ?? '<name>'} --project-anchor <name>  # or --cwd <path>`,
     });
 }
-/**
- * Layer the harness/target readiness codes onto a resolved execution context.
- * Context blockers short-circuit (no point probing auth for a routine that has
- * no directory to run in). Every probe is optional and injected; an omitted
- * probe is treated as "not applicable / passes" so a caller only pays for the
- * checks it wires up.
- */
 export function evaluateRoutineReadiness(context, probes = {}, opts = {}) {
     if (!context.ready) {
         return { context, ready: false, readiness: context.readiness };
@@ -253,8 +148,6 @@ export function evaluateRoutineReadiness(context, probes = {}, opts = {}) {
         });
     }
     if (probes.agentInstalled && !probes.agentInstalled()) {
-        // A pinned version names its exact miss — "no usable version" would send the
-        // operator hunting for a harness that IS installed, just not at the pin.
         const pinned = opts.version && opts.agent ? `${opts.agent}@${opts.version}` : undefined;
         return withBlocker(context, {
             code: 'agent_unavailable',

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

@@ -1,103 +1,24 @@
-/**
- * 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 type { Meta } from './types.js';
 import type { JobConfig, RunMeta } from './scheduling/routines.js';
-/**
- * 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 declare function routineFinishOwnerText(meta: Pick<RunMeta, 'jobName' | 'status' | 'exitCode' | 'errorMessage' | 'agent' | 'workflow' | 'command'>, host: string): string | null;
-/**
- * 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 declare function routineStartFailedOwnerText(config: Pick<JobConfig, 'name' | 'agent' | 'workflow' | 'command'>, error: string, host: string): string;
-/** One resolved owner destination to attempt, in plan order. */
 interface OwnerDest {
     channel: string;
     to: string;
 }
-/**
- * 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 declare function ownerFailureDeliveryPlan(meta: Meta): OwnerDest[];
-/** Outcome of one delivery attempt, for logging/telemetry. */
 interface OwnerDeliveryAttempt {
     channel: string;
     ok: boolean;
     error?: string;
 }
 interface OwnerDeliveryResult {
-    /** True once any channel in the plan accepted the message. */
     delivered: boolean;
-    /** The channel that delivered, when `delivered`. */
     channel?: string;
-    /** Every attempt made, in order — empty when no owner channel is configured. */
     attempts: OwnerDeliveryAttempt[];
 }
-/**
- * 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 declare function deliverOwnerFailure(text: string, meta: Meta): Promise<OwnerDeliveryResult>;
-/** Test-only: reset the dedup set so cases don't leak state into each other. */
 export declare function __resetOwnerFailureDedup(): void;
-/**
- * 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 declare function notifyOwnerRoutineFinish(meta: RunMeta): Promise<OwnerDeliveryResult>;
-/**
- * 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 declare function notifyOwnerRoutineStartFailed(config: JobConfig, error: string): Promise<OwnerDeliveryResult>;
 export {};