@phnx-labs/agents-cli 1.22.61 → 1.22.62

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.22.62
+
+- **Owner notifications fan out across the configured normal-severity channels (PHNX-3567).** `agents send --to owner`, deprecated `agents notify`, monitor notifications, and an important feed's owner sink now attempt every addressable entry named by `owner.policy.normal` in `humans.yaml`, instead of silently selecting only the first. Each Rush-backed destination that cannot deliver on a Linux worker forwards its explicit channel and target to a capable Mac, avoiding both shell quoting and policy re-expansion/duplicate sends. Partial failures stay visible while successful channels still deliver; legacy single-channel configs retain their old behavior. Source: `cli/src/lib/humans.ts`, `cli/src/lib/notify.ts`, `cli/src/lib/channels/owner-forward.ts`, `cli/src/lib/feed-broadcast.ts`.
+
 ## 1.22.61
 
 - **`agents harness` wizard: model catalog, connection test, and edit matrix (PHNX-2218/2220/2221/2222).** The create/edit wizard now picks the model from the host's own catalog (`getModelCatalog`) with a free-text escape hatch, gates the endpoint step to hosts that actually carry one, and runs a real pre-save connection test — `agents run <name> "say alive in one word" --headless --timeout 60s` classified into pass / auth / endpoint / model — behind a confirm with `--test`/`--no-test`, offering keep / edit / delete on failure rather than saving a broken harness silently. A resolver-sourced `harnessEditable` matrix disables (with a reason) any param the host's API format can't carry. Source: `apps/cli/src/commands/harness.ts`, `apps/cli/src/commands/harness-wizard.ts`, `apps/cli/src/commands/harness-hooks.ts`, `apps/cli/src/lib/harness-connection-test.ts`.

package/README.md

@@ -461,6 +461,12 @@ agents feed answer <key> --choice 0 # first answer wins; route over the recorded
 agents feed post --title "Halfway done" "CI green, watching merge"  # title + body
 ```
 
+Important posts can reach every owner channel named in
+`~/.agents/humans.yaml` under `owner.policy.normal` (for example iMessage and
+Slack). Owner delivery attempts every selected channel, reports partial
+failures, and safely forwards Rush-backed channels from headless workers to a
+capable Mac; ordinary milestone posts remain record-only unless configured.
+
 Top-level questions and waiting notifications publish one atomic open-block record per session, including the mailbox id, host, runtime, and every answer option. The default view collapses agents under the **outcome** they serve (Linear ticket, PR, worktree slug, or Unassigned) so a 1,100-agent fleet reads as dozens of deliverables. Answered, resumed, and stopped blocks clear automatically; Task subagents are excluded. The rendered reply command uses the same mailbox id with `agents message`, so the decision routes back to the agent that asked it.
 
 ### Auto-nudge stalls

package/dist/commands/feed.js

@@ -726,7 +726,9 @@ async function broadcastBlock(block, extras, meta, notify = false) {
 /** One line per sink that ran. Silent when nothing is configured. */
 function reportBroadcast(outcomes) {
     for (const o of outcomes) {
-        if (o.ok)
+        if (o.ok && o.error)
+            console.error(chalk.yellow(`  → ${o.name} partial: ${o.error}`));
+        else if (o.ok)
             console.log(chalk.gray(`  → ${o.name}`));
         else
             console.error(chalk.yellow(`  → ${o.name} failed: ${o.error}`));

package/dist/commands/monitors.js

@@ -425,8 +425,8 @@ function buildAction(options) {
     }
     if (options.notify !== undefined) {
         // --notify may be a bare flag (notify the owner) or carry a channel that
-        // overrides notify.owner.channel. Left unset, the send resolves the owner
-        // channel + target from notify.owner in agents.yaml (one source of truth).
+        // selects one channel. Left unset, the send fans out every addressable
+        // owner.policy.normal destination from humans.yaml (one source of truth).
         const channel = typeof options.notify === 'string' ? options.notify : undefined;
         chosen.push({ type: 'notify', ...(channel ? { notifyChannel: channel } : {}) });
     }
@@ -620,7 +620,7 @@ export function registerMonitorsCommands(program) {
         .option('--action-timeout <t>', 'Kill the --run action if it runs longer than this (e.g. 10m)')
         .option('--postcondition <cmd>', 'Shell command that must exit 0 after a --run/--routine action settles; otherwise the fire records as no-effect, not ok. {event} is replaced with the fired event summary')
         .option('--routine <name>', 'Fire an existing routine on change')
-        .option('--notify [channel]', 'Notify the owner (notify.owner); [channel] overrides the owner channel')
+        .option('--notify [channel]', 'Notify every normal-policy owner channel; [channel] selects one channel')
         .option('--webhook-out <url>', 'POST the event to this URL')
         // PLACEMENT / hygiene
         .option('--device <name>', 'OWNER (not body placement) — the single machine that evaluates + fires (exactly-once). See docs/concepts.md#placement.')

package/dist/commands/send.js

@@ -44,6 +44,8 @@ async function runSend(positionalText, opts, ownerMode) {
     const suffix = result.msgId ? chalk.dim(` (${result.msgId})`) : '';
     const dry = envelope.dryRun ? chalk.dim(' [dry-run]') : '';
     console.log(chalk.green(`Sent via ${result.channel} → ${result.id}`) + suffix + dry);
+    if (result.error)
+        console.error(chalk.yellow(`Partial delivery failure: ${result.error}`));
 }
 const SHARED_NOTES = `
   Planes (do not mix them up):
@@ -122,7 +124,8 @@ export function registerSendCommand(program) {
         notes: `
       DEPRECATED. notify ≡ send --to owner and still works, but new callers
       should use "agents feed post" (record + optional broadcast) instead.
-      Set notify.owner.{channel,to} in agents.yaml once per machine/fleet.
+      Set owner.channels + owner.policy.normal in humans.yaml once per fleet.
+      Every channel listed in the normal policy receives an owner-addressed send.
 
       ${SHARED_NOTES}
     `,

package/dist/lib/channels/owner-forward.d.ts

@@ -14,9 +14,10 @@
  * This mirrors the SSH reroute `agents message` (decideHostTaskRoute →
  * runOnPeer) and the sessions fan-out already use for work that lives on another
  * box: pick a reachable peer from the device registry and run the same `agents`
- * verb there. Here the verb is `agents send --to owner`, which resolves the
- * peer's own (fleet-synced) owner destination and delivers through its local
- * rush — so the owner is addressed once, from the one box that can reach them.
+ * verb there. Here the verb is `agents send --channel <channel> --to <target>`.
+ * Keeping the destination explicit and delivering through the peer's local rush
+ * destination explicit prevents a multi-channel owner policy from expanding a
+ * second time on the peer and duplicating already-successful channels.
  *
  * Best-effort seam: it never throws and never blocks the post. When no capable
  * peer is reachable it resolves `undefined` and the caller keeps its original
@@ -63,13 +64,17 @@ export declare function planOwnerForward(channel: string, meta: Meta, devices: D
 }): OwnerForwardPlan;
 /**
  * Deliver `text` to the owner FROM one peer over SSH. Runs the peer's own
- * `agents send --to owner --text <text> --json`, which resolves that box's
- * fleet-synced owner destination and delivers through its local provider.
+ * `agents send --channel <channel> --to <target> --text <text> --json`, which
+ * delivers the already-resolved destination through its local provider.
  * Resolves the parsed `SendResult`, or `undefined` when the peer is
  * unreachable / not a dialable device / answered with unparseable output —
  * every one of which means "try the next peer".
  */
-export type PeerOwnerSender = (machine: string, text: string) => Promise<SendResult | undefined>;
+export interface PeerOwnerEnvelope {
+    thread?: string;
+    from?: string;
+}
+export type PeerOwnerSender = (machine: string, text: string, channel: string, target: string, envelope?: PeerOwnerEnvelope) => Promise<SendResult | undefined>;
 /**
  * Try each capable peer in order and return the first successful delivery. A
  * peer that is unreachable or reports its own delivery failure is skipped and
@@ -79,10 +84,11 @@ export type PeerOwnerSender = (machine: string, text: string) => Promise<SendRes
  *
  * The transport (`send`) is injectable so the try-order / first-success / stop
  * orchestration is testable without a live SSH host; the default runs the real
- * `agents send --to owner` over SSH.
+ * explicit-destination `agents send` over SSH.
  */
-export declare function forwardOwnerNotifyToPeer(text: string, channel: string, meta: Meta, opts?: {
+export declare function forwardOwnerNotifyToPeer(text: string, channel: string, target: string, meta: Meta, opts?: {
     self?: string;
     devices?: DeviceProfile[];
     send?: PeerOwnerSender;
+    envelope?: PeerOwnerEnvelope;
 }): Promise<SendResult | undefined>;

package/dist/lib/channels/owner-forward.js

@@ -51,11 +51,15 @@ export function planOwnerForward(channel, meta, devices, self, opts = {}) {
         return { candidates: [], skip: 'no-capable-peer' };
     return { candidates };
 }
-async function sendOnPeer(machine, text) {
+async function sendOnPeer(machine, text, channel, target, envelope = {}) {
     const peer = await resolvePeerTarget(machine);
     if (!peer)
         return undefined;
-    const args = ['send', '--to', 'owner', '--text', text, '--json'];
+    const args = ['send', '--channel', channel, '--to', target, '--text', text, '--json'];
+    if (envelope.thread)
+        args.push('--thread', envelope.thread);
+    if (envelope.from)
+        args.push('--from', envelope.from);
     // Reuse the one injection-tested remote-command builder every `--device`
     // dispatch uses (posix `bash -lc` / Windows `-EncodedCommand`), rather than a
     // second hand-rolled quoting path on a security-sensitive seam. The env map is
@@ -83,9 +87,9 @@ async function sendOnPeer(machine, text) {
  *
  * The transport (`send`) is injectable so the try-order / first-success / stop
  * orchestration is testable without a live SSH host; the default runs the real
- * `agents send --to owner` over SSH.
+ * explicit-destination `agents send` over SSH.
  */
-export async function forwardOwnerNotifyToPeer(text, channel, meta, opts = {}) {
+export async function forwardOwnerNotifyToPeer(text, channel, target, meta, opts = {}) {
     // Cheap, I/O-free gate first: a box that already received a forward, or an
     // owner channel that isn't the macOS-only rush family, can never forward — so
     // a normal local success/failure never pays a device-registry disk read.
@@ -108,7 +112,7 @@ export async function forwardOwnerNotifyToPeer(text, channel, meta, opts = {}) {
         return undefined;
     const send = opts.send ?? sendOnPeer;
     for (const machine of plan.candidates) {
-        const result = await send(machine, text);
+        const result = await send(machine, text, channel, target, opts.envelope);
         if (result?.ok)
             return result;
     }

package/dist/lib/channels/registry.d.ts

@@ -33,6 +33,8 @@ export interface SendResult {
     attachments?: string[];
     /** Mailbox provider returns the enqueued message id. */
     msgId?: string;
+    /** Per-destination results when the owner policy selects multiple channels. */
+    deliveries?: SendResult[];
 }
 export interface ChannelProvider {
     /** Stable name used in `--channel` and as a `notify.transports` value. */

package/dist/lib/channels/send.js

@@ -1,6 +1,7 @@
 import { getOwnerNotifyFromHumans } from '../humans.js';
 import { registerBuiltinProviders } from './providers/index.js';
 import { resolveTransport } from './resolve.js';
+import { sendToOwner } from '../notify.js';
 const OWNER_ALIAS = 'owner';
 /** True when the destination token means “the configured owner”. */
 export function isOwnerAlias(to) {
@@ -112,6 +113,17 @@ export async function sendMessage(input, meta) {
     const resolved = resolveSendEnvelope(input, meta);
     if (!resolved.ok)
         return { error: resolved.error };
-    const result = await deliverEnvelope(resolved.envelope, meta);
+    const ownerPolicyRequest = resolved.envelope.ownerScoped === true
+        && !input.channel?.trim()
+        && (!input.to?.trim() || isOwnerAlias(input.to));
+    const result = ownerPolicyRequest
+        ? await sendToOwner(resolved.envelope.text, {
+            meta,
+            dryRun: resolved.envelope.dryRun,
+            thread: resolved.envelope.thread,
+            attachments: resolved.envelope.attachments,
+            from: resolved.envelope.from,
+        })
+        : await deliverEnvelope(resolved.envelope, meta);
     return { result, envelope: resolved.envelope };
 }

package/dist/lib/feed-broadcast.js

@@ -36,8 +36,8 @@
 import { spawnSync } from 'child_process';
 import { isOwnerAlias, readOwnerDest, resolveSendEnvelope, deliverEnvelope } from './channels/send.js';
 import { lookupTransport } from './channels/resolve.js';
-import { forwardOwnerNotifyToPeer } from './channels/owner-forward.js';
 import { registerBuiltinProviders } from './channels/providers/index.js';
+import { sendToOwner } from './notify.js';
 const LEVEL_RANK = { milestone: 0, important: 1 };
 /** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
 export function parseFeedPostLevel(raw) {
@@ -462,6 +462,10 @@ async function runChannelSink(sink, meta) {
     // for a name that is, in fact, registered.
     registerBuiltinProviders();
     const owner = isOwnerAlias(sink.channel);
+    if (owner) {
+        const result = await sendToOwner(sink.text ?? '', { meta });
+        return { name, ok: result.ok, ...(result.error ? { error: result.error } : {}) };
+    }
     const resolved = resolveSendEnvelope({
         text: sink.text ?? '',
         channel: owner ? undefined : sink.channel,
@@ -476,17 +480,6 @@ async function runChannelSink(sink, meta) {
     const result = await deliverEnvelope(resolved.envelope, meta);
     if (result.ok)
         return { name, ok: true };
-    // The owner sink failed locally. When this box structurally cannot reach the
-    // owner (the rush-backed channel is macOS-only, so a headless Linux worker can
-    // never ring the phone — PHNX-3303), hand the delivery to a capable fleet peer
-    // over SSH rather than stranding the important post. Only the `owner` alias
-    // forwards: it resolves the peer's own fleet-synced owner destination, so a
-    // non-owner channel sink with an explicit recipient stays local.
-    if (owner) {
-        const forwarded = await forwardOwnerNotifyToPeer(sink.text ?? '', resolved.envelope.channel, meta);
-        if (forwarded?.ok)
-            return { name, ok: true };
-    }
     return { name, ok: false, error: result.error };
 }
 /**

package/dist/lib/humans.d.ts

@@ -20,6 +20,15 @@ export declare function getOwnerNotifyFromHumans(): {
     channel: string;
     to: string;
 } | null;
+/**
+ * Return every addressable owner destination selected by the normal-severity
+ * policy, in policy order. A config without a policy keeps the historical
+ * single-channel behavior by selecting the first addressable channel.
+ */
+export declare function getOwnerNotifyDestinationsFromHumans(): Array<{
+    channel: string;
+    to: string;
+}>;
 /**
  * Read the owner block from humans.yaml. Returns null if missing.
  */

package/dist/lib/humans.js

@@ -51,19 +51,40 @@ export function writeHumans(config) {
  * policy is declared, the first addressable channel is the default.
  */
 export function getOwnerNotifyFromHumans() {
+    return getOwnerNotifyDestinationsFromHumans()[0] ?? null;
+}
+/**
+ * Return every addressable owner destination selected by the normal-severity
+ * policy, in policy order. A config without a policy keeps the historical
+ * single-channel behavior by selecting the first addressable channel.
+ */
+export function getOwnerNotifyDestinationsFromHumans() {
     const owner = readHumans()?.owner;
     const channels = owner?.channels ?? [];
     const preferredIds = owner?.policy?.normal ?? [];
-    const preferred = preferredIds
-        .map((id) => channels.find((entry) => entry.id === id))
-        .find((entry) => entry?.to);
-    const selected = preferred ?? channels.find((entry) => entry.to);
-    if (selected?.id && selected.to)
-        return { channel: selected.id, to: selected.to };
+    const selected = preferredIds.length > 0
+        ? preferredIds.map((id) => channels.find((entry) => entry.id === id))
+        : [channels.find((entry) => entry.to)];
+    const seen = new Set();
+    const destinations = selected
+        .filter((entry) => Boolean(entry?.id && entry.to))
+        .map((entry) => ({ channel: entry.id, to: entry.to }))
+        .filter((entry) => {
+        const key = `${entry.channel}\0${entry.to}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    if (destinations.length > 0)
+        return destinations;
+    const firstAddressable = channels.find((entry) => entry.id && entry.to);
+    if (firstAddressable?.to)
+        return [{ channel: firstAddressable.id, to: firstAddressable.to }];
     const migrated = owner?.notify;
     if (migrated?.channel && migrated.to)
-        return migrated;
-    return null;
+        return [migrated];
+    return [];
 }
 /**
  * Read the owner block from humans.yaml. Returns null if missing.

package/dist/lib/notify.d.ts

@@ -25,6 +25,9 @@ export interface OwnerNotifyOptions {
     target?: string;
     /** Resolve + build the delivery but do not actually send. */
     dryRun?: boolean;
+    thread?: string;
+    attachments?: string[];
+    from?: string;
 }
 export interface NotifyResult {
     ok: boolean;

package/dist/lib/notify.js

@@ -1,5 +1,5 @@
 import { readMeta } from './state.js';
-import { getOwnerNotifyFromHumans } from './humans.js';
+import { getOwnerNotifyDestinationsFromHumans } from './humans.js';
 import { registerBuiltinProviders } from './channels/providers/index.js';
 import { lookupTransport } from './channels/resolve.js';
 import { forwardOwnerNotifyToPeer } from './channels/owner-forward.js';
@@ -49,33 +49,75 @@ export function buildOpenClawNotifyArgs(text, opts) {
  */
 export async function sendToOwner(text, options = {}) {
     const meta = options.meta ?? readMeta();
-    const owner = getOwnerNotifyFromHumans() ?? meta.notify?.owner;
-    const channel = options.channel ?? owner?.channel;
-    const target = options.target ?? owner?.to;
-    if (!channel || !target) {
+    const canonical = getOwnerNotifyDestinationsFromHumans();
+    const legacy = meta.notify?.owner ? [meta.notify.owner] : [];
+    const configured = canonical.length > 0 ? canonical : legacy;
+    const destinations = options.target
+        ? [{ channel: options.channel ?? configured[0]?.channel, to: options.target }]
+        : options.channel
+            ? [configured.find((dest) => dest.channel === options.channel) ?? {
+                    channel: options.channel,
+                    to: configured[0]?.to,
+                }]
+            : configured;
+    const addressable = destinations.filter((dest) => Boolean(dest.channel && dest.to));
+    if (addressable.length === 0) {
         return {
             ok: false,
-            channel: channel ?? 'unknown',
-            id: target ?? '',
+            channel: options.channel ?? 'unknown',
+            id: options.target ?? '',
             error: 'No addressable owner channel configured in humans.yaml or legacy notify.owner',
         };
     }
     registerBuiltinProviders();
-    const { provider, error } = lookupTransport(channel, meta);
-    if (!provider) {
-        return { ok: false, channel, id: target, error };
+    const deliveries = [];
+    for (const { channel, to: target } of addressable) {
+        const { provider, error } = lookupTransport(channel, meta);
+        let result;
+        try {
+            result = provider
+                ? await provider.send(text, {
+                    target,
+                    ownerScoped: options.target === undefined,
+                    dryRun: options.dryRun,
+                    thread: options.thread,
+                    attachments: options.attachments,
+                    from: options.from,
+                })
+                : { ok: false, channel, id: target, error };
+        }
+        catch (err) {
+            result = { ok: false, channel, id: target, error: err.message };
+        }
+        // A dry-run never delivers, and an override target is an explicit recipient
+        // (not the fleet-wide owner) — neither should hop to a peer.
+        if (!result.ok && !options.dryRun && options.target === undefined) {
+            if (options.attachments?.length) {
+                result = {
+                    ...result,
+                    error: `${result.error ?? 'local delivery failed'}; owner attachments cannot be forwarded to another device`,
+                };
+            }
+            else {
+                result = await forwardOwnerNotifyToPeer(text, channel, target, meta, {
+                    envelope: { thread: options.thread, from: options.from },
+                }) ?? result;
+            }
+        }
+        deliveries.push(result);
     }
-    const local = await provider.send(text, {
-        target,
-        ownerScoped: options.target === undefined,
-        dryRun: options.dryRun,
-    });
-    // A dry-run never delivers, and an override target is an explicit recipient
-    // (not the fleet-wide owner) — neither should hop to a peer.
-    if (local.ok || options.dryRun || options.target !== undefined)
-        return local;
-    const forwarded = await forwardOwnerNotifyToPeer(text, channel, meta);
-    return forwarded ?? local;
+    if (deliveries.length === 1)
+        return deliveries[0];
+    const failures = deliveries.filter((result) => !result.ok);
+    return {
+        ok: deliveries.some((result) => result.ok),
+        channel: 'owner',
+        id: deliveries.map((result) => `${result.channel}:${result.id}`).join(','),
+        ...(failures.length > 0
+            ? { error: failures.map((result) => `${result.channel}: ${result.error ?? 'failed'}`).join('; ') }
+            : {}),
+        deliveries,
+    };
 }
 export async function notifyUrgentBlock(block, options = {}) {
     if (block.notifiedAt) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.61",
+  "version": "1.22.62",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",