@phnx-labs/agents-cli 1.22.120 → 1.22.121

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

@@ -1,91 +1,21 @@
-/**
- * Forward an owner notification to a capable fleet peer over SSH (PHNX-3303).
- *
- * The owner's delivery provider for the rush-backed channels (imessage /
- * telegram / slack / discord via the `rush` CLI) is macOS-only and
- * keychain-bound, so a headless Linux worker structurally CANNOT ring the
- * owner's phone: `agents feed post --level important` records the post but the
- * owner sink fails with `rush CLI not found on PATH`, and the important post
- * reaches nobody. `probeOwnerSink` (owner-sink.ts) already reports this as the
- * `owner-sink-unreachable` doctor finding; this module is the runtime answer to
- * it — instead of stranding the failure, hand the delivery to a reachable macOS
- * peer that DOES have the provider.
- *
- * 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 --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
- * clean local error, exactly as before.
- */
 import type { Meta } from '../types.js';
 import type { SendResult } from './registry.js';
 import type { DeviceProfile } from '../devices/registry.js';
-/**
- * Env marker set on the forwarded `agents send` so a box that received a
- * forwarded owner notify never forwards it onward. `agents send` does not route
- * through this module today, so this is defense-in-depth against a future
- * consumer wiring forwarding into the send path and creating a fan-out loop.
- */
 export declare const OWNER_FORWARD_GUARD_ENV = "AGENTS_OWNER_NO_FORWARD";
-/** Why forwarding did not run, so a caller/test can assert the decision. */
 type OwnerForwardSkip = 'guarded' | 'not-rush-backed' | 'no-capable-peer';
 interface OwnerForwardPlan {
-    /** Ordered machine ids to try — capable (macOS), reachable, self excluded. */
     candidates: string[];
-    /** Set when forwarding does not apply; the caller keeps its local error. */
     skip?: OwnerForwardSkip;
 }
-/**
- * True when the resolved owner transport is the macOS-only rush family — the
- * one case a Linux/headless box structurally cannot deliver and a peer can.
- * `openclaw-telegram` and the local `desktop`/`mailbox` providers are NOT
- * rush-backed, so a failure there is not a wrong-OS problem and is left as-is.
- * Mirrors the same `RUSH_CHANNELS.includes(transport)` gate in owner-sink.ts.
- */
 export declare function isRushBackedTransport(channel: string, meta: Meta): boolean;
-/**
- * Decide which peers can deliver the owner notification, in try order. Pure —
- * no I/O — so the channel gate, the recursion guard, self-exclusion, and the
- * capability/ordering rules are unit-testable without a live tailnet.
- *
- * Only macOS peers are candidates: the rush owner transport is macOS-only, so a
- * Linux/Windows peer could not deliver it either. The configured
- * `interactive.host` (the box the operator sits at, where rush is signed in) is
- * tried first when it is among the candidates.
- */
 export declare function planOwnerForward(channel: string, meta: Meta, devices: DeviceProfile[], self: string, opts?: {
     guarded?: boolean;
 }): OwnerForwardPlan;
-/**
- * Deliver `text` to the owner FROM one peer over SSH. Runs the peer's own
- * `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".
- */
 interface PeerOwnerEnvelope {
     thread?: string;
     from?: string;
 }
 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
- * the next is tried; the first `ok:true` wins and stops the sweep so the owner's
- * phone rings once. Resolves `undefined` when forwarding does not apply or no
- * peer delivered — the caller then keeps its original local error.
- *
- * 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
- * explicit-destination `agents send` over SSH.
- */
 export declare function forwardOwnerNotifyToPeer(text: string, channel: string, target: string, meta: Meta, opts?: {
     self?: string;
     devices?: DeviceProfile[];

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

@@ -3,36 +3,12 @@ import { machineId, normalizeHost } from '../machine-id.js';
 import { RUSH_CHANNELS } from './providers/rush.js';
 import { resolvePeerTarget, sshCapture } from '../session/remote/remote-list.js';
 import { buildRemoteAgentsInvocation, stripClixml } from '../hosts/remote-cmd.js';
-/**
- * Env marker set on the forwarded `agents send` so a box that received a
- * forwarded owner notify never forwards it onward. `agents send` does not route
- * through this module today, so this is defense-in-depth against a future
- * consumer wiring forwarding into the send path and creating a fan-out loop.
- */
 export const OWNER_FORWARD_GUARD_ENV = 'AGENTS_OWNER_NO_FORWARD';
-/** Per-peer SSH deadline for a one-shot owner delivery. */
 const PEER_SEND_TIMEOUT_MS = 15_000;
-/**
- * True when the resolved owner transport is the macOS-only rush family — the
- * one case a Linux/headless box structurally cannot deliver and a peer can.
- * `openclaw-telegram` and the local `desktop`/`mailbox` providers are NOT
- * rush-backed, so a failure there is not a wrong-OS problem and is left as-is.
- * Mirrors the same `RUSH_CHANNELS.includes(transport)` gate in owner-sink.ts.
- */
 export function isRushBackedTransport(channel, meta) {
     const transport = meta.notify?.transports?.[channel] ?? channel;
     return RUSH_CHANNELS.includes(transport);
 }
-/**
- * Decide which peers can deliver the owner notification, in try order. Pure —
- * no I/O — so the channel gate, the recursion guard, self-exclusion, and the
- * capability/ordering rules are unit-testable without a live tailnet.
- *
- * Only macOS peers are candidates: the rush owner transport is macOS-only, so a
- * Linux/Windows peer could not deliver it either. The configured
- * `interactive.host` (the box the operator sits at, where rush is signed in) is
- * tried first when it is among the candidates.
- */
 export function planOwnerForward(channel, meta, devices, self, opts = {}) {
     if (opts.guarded)
         return { candidates: [], skip: 'guarded' };
@@ -60,10 +36,6 @@ async function sendOnPeer(machine, text, channel, target, envelope = {}) {
         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
-    // the loop guard, exported the same way every remote invocation exports env.
     const remoteCmd = buildRemoteAgentsInvocation(args, undefined, peer.os, { [OWNER_FORWARD_GUARD_ENV]: '1' });
     const capture = await sshCapture(peer.target, remoteCmd, PEER_SEND_TIMEOUT_MS);
     if (capture.code !== 0)
@@ -78,21 +50,7 @@ async function sendOnPeer(machine, text, channel, target, envelope = {}) {
     }
     return 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
- * the next is tried; the first `ok:true` wins and stops the sweep so the owner's
- * phone rings once. Resolves `undefined` when forwarding does not apply or no
- * peer delivered — the caller then keeps its original local error.
- *
- * 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
- * explicit-destination `agents send` over SSH.
- */
 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.
     if (process.env[OWNER_FORWARD_GUARD_ENV] === '1')
         return undefined;
     if (!isRushBackedTransport(channel, meta))
@@ -104,7 +62,7 @@ export async function forwardOwnerNotifyToPeer(text, channel, target, meta, opts
             devices = Object.values(await loadDevices());
         }
         catch {
-            return undefined; // no registry, nothing to forward to
+            return undefined;
         }
     }
     const plan = planOwnerForward(channel, meta, devices, self);

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

@@ -1,23 +1,3 @@
-/**
- * Owner-delivery-sink reachability probe (RUSH-2262).
- *
- * The feed/notify owner-delivery lane (`agents send --to owner`, `agents feed post
- * --level important` / `--blocked`) reaches the owner through the channel
- * providers registered for each configured channel in humans.yaml.
- *
- * Transport capabilities differ by channel and platform:
- *   - **imessage:** macOS only (osascript → Messages.app). Linux boxes rely on
- *     the peer-forward in owner-forward.ts to reach a macOS peer.
- *   - **slack:** requires a `SLACK_BOT_TOKEN` in env or the `webhooks` secrets
- *     bundle. Platform-independent.
- *   - **telegram / discord:** requires the Rush daemon (removed); only
- *     openclaw-telegram is available as a Telegram alternative.
- *
- * `agents send --to owner --dry-run` is NOT this probe: dry-run short-circuits
- * before the capability check. Resolvability (does the envelope build?) and
- * reachability (can this box actually deliver?) are different questions; this
- * answers the second.
- */
 import { platform } from 'os';
 import { readOwnerDest } from './send.js';
 import { RUSH_CHANNELS, resolveSlackToken } from './providers/rush.js';
@@ -42,6 +22,5 @@ export async function probeOwnerSink(meta) {
         }
         return { configured: true, reachable: false, channel, transport, reason: 'slack-no-token' };
     }
-    // telegram / discord — daemon removed, no direct transport.
     return { configured: true, reachable: false, channel, transport, reason: 'channel-unsupported' };
 }

package/dist/lib/channels/providers/desktop.d.ts

@@ -1,46 +1,9 @@
 import type { ChannelProvider } from '../registry.js';
-/**
- * Split one message into the notification's title and body.
- *
- * A broadcast sink hands us `composeBroadcastMessage`'s shape — a title line, a
- * blank line, then the body (and a `Sent from …` footer) — so honouring the first
- * newline puts the scannable head in the title and the rest in the body, which is
- * how the existing daemon notifications already read. (Desktop is a plain sink, so
- * the message carries no URLs to split off.)
- *
- * Notification banners show roughly two lines before an ellipsis, so a long
- * single-line message is split at the title boundary rather than truncated away:
- * the head becomes the title and the remainder still arrives in the body.
- */
 export declare function splitDesktopMessage(text: string): {
     title: string;
     body: string;
 };
-/**
- * Which native notifier this platform wires, or undefined when it wires none.
- *
- * macOS always ships `osascript`, and `notifyDesktop` prefers the branded
- * MenubarHelper when installed and degrades to osascript otherwise — either way
- * something delivers. Linux depends on `notify-send`, which is NOT guaranteed
- * (a headless box typically lacks it), so the platform answer alone is not proof
- * there — see `desktopDeliverable`. Every other platform has no wired notifier at
- * all (`notifyDesktop` is a documented no-op), so sending there must fail loud.
- *
- * Pure and platform-injectable so the gate is testable without spawning.
- */
 export declare function desktopNotifier(platform?: NodeJS.Platform): string | undefined;
-/**
- * Whether a notification sent right now would actually arrive.
- *
- * On Linux the notifier is a separate binary that is frequently absent, and
- * `notifyDesktop` spawns it detached — an ENOENT surfaces asynchronously and is
- * swallowed. Reporting `ok` off the platform name alone would therefore mark an
- * undelivered notification as delivered, which is the same silent failure this
- * provider exists to remove, just relocated. So probe for the binary.
- *
- * macOS needs no probe: `osascript` is part of the OS, so the degrade path is
- * always available even when MenubarHelper is not installed.
- */
 export declare function desktopDeliverable(platform?: NodeJS.Platform): {
     ok: true;
 } | {

package/dist/lib/channels/providers/desktop.js

@@ -1,43 +1,8 @@
-/**
- * Desktop provider — the local machine's native notification centre.
- *
- * The only channel with no external dependency: no network, no login, no vendor
- * CLI. On the Mac the operator is sitting at it works when every other channel is
- * dead, which is exactly when a blocked agent most needs to reach them.
- *
- * Delivery reuses `notifyDesktop` (lib/menubar/notify-desktop.ts), so a message
- * sent here is attributed to MenubarHelper.app and carries the agents-cli mark —
- * the same path that produces the "agents-cli / <title> / <body>" entries already
- * in Notification Center.
- *
- * WHY THIS ISN'T A THIN PASSTHROUGH: `notifyDesktop` is deliberately
- * fire-and-forget — it spawns detached and swallows every failure so a hiccup can
- * never take the daemon down. A channel provider cannot inherit that: a sink that
- * always reports `ok: true` would make an undelivered notification look delivered,
- * which is the precise class of silent failure this whole subsystem exists to
- * kill. So the provider resolves *deliverability* up front — is there a notifier
- * on this platform at all — and fails loud when there is not. It reports what it
- * can actually know: on a platform with no notifier, nothing will arrive.
- */
 import * as os from 'os';
 import { spawnSync } from 'child_process';
 import { notifyDesktop } from '../../menubar/notify-desktop.js';
 const NAME = 'desktop';
-/** Longest title before macOS truncates it in the banner. Keeps the ask readable. */
 const TITLE_MAX = 64;
-/**
- * Split one message into the notification's title and body.
- *
- * A broadcast sink hands us `composeBroadcastMessage`'s shape — a title line, a
- * blank line, then the body (and a `Sent from …` footer) — so honouring the first
- * newline puts the scannable head in the title and the rest in the body, which is
- * how the existing daemon notifications already read. (Desktop is a plain sink, so
- * the message carries no URLs to split off.)
- *
- * Notification banners show roughly two lines before an ellipsis, so a long
- * single-line message is split at the title boundary rather than truncated away:
- * the head becomes the title and the remainder still arrives in the body.
- */
 export function splitDesktopMessage(text) {
     const trimmed = text.trim();
     const newline = trimmed.indexOf('\n');
@@ -50,25 +15,11 @@ export function splitDesktopMessage(text) {
     if (trimmed.length <= TITLE_MAX) {
         return { title: trimmed, body: '' };
     }
-    // Break on the last word boundary inside the limit so the title doesn't end
-    // mid-word; fall back to a hard cut when there is no space to break on.
     const head = trimmed.slice(0, TITLE_MAX);
     const cut = head.lastIndexOf(' ');
     const at = cut > TITLE_MAX / 2 ? cut : TITLE_MAX;
     return { title: trimmed.slice(0, at).trim(), body: trimmed.slice(at).trim() };
 }
-/**
- * Which native notifier this platform wires, or undefined when it wires none.
- *
- * macOS always ships `osascript`, and `notifyDesktop` prefers the branded
- * MenubarHelper when installed and degrades to osascript otherwise — either way
- * something delivers. Linux depends on `notify-send`, which is NOT guaranteed
- * (a headless box typically lacks it), so the platform answer alone is not proof
- * there — see `desktopDeliverable`. Every other platform has no wired notifier at
- * all (`notifyDesktop` is a documented no-op), so sending there must fail loud.
- *
- * Pure and platform-injectable so the gate is testable without spawning.
- */
 export function desktopNotifier(platform = os.platform()) {
     if (platform === 'darwin')
         return 'menubar-or-osascript';
@@ -76,18 +27,6 @@ export function desktopNotifier(platform = os.platform()) {
         return 'notify-send';
     return undefined;
 }
-/**
- * Whether a notification sent right now would actually arrive.
- *
- * On Linux the notifier is a separate binary that is frequently absent, and
- * `notifyDesktop` spawns it detached — an ENOENT surfaces asynchronously and is
- * swallowed. Reporting `ok` off the platform name alone would therefore mark an
- * undelivered notification as delivered, which is the same silent failure this
- * provider exists to remove, just relocated. So probe for the binary.
- *
- * macOS needs no probe: `osascript` is part of the OS, so the degrade path is
- * always available even when MenubarHelper is not installed.
- */
 export function desktopDeliverable(platform = os.platform()) {
     const notifier = desktopNotifier(platform);
     if (!notifier) {
@@ -104,18 +43,7 @@ export function desktopDeliverable(platform = os.platform()) {
 export const desktopProvider = {
     name: NAME,
     async send(text, opts) {
-        // `target` is meaningless for a local notification — the recipient is whoever
-        // is at this machine — but it is echoed for --json parity with every other
-        // provider, and `agents send --to owner` still requires notify.owner.to to be set.
         const id = opts.target || os.hostname();
-        // Order matters, and CI caught it: validate the CALLER first, then honour
-        // dry-run, and only then probe the platform.
-        //
-        // An empty message is a caller error on every platform, so it must not be
-        // masked by "this box has no notifier" — the specific, actionable error wins.
-        // And `--dry-run` means "resolve + build but do not send", so it must not
-        // depend on the ability to send; the sibling rush provider likewise returns
-        // ok for a dry run before its own `which rush` check (providers/rush.ts).
         const { title, body } = splitDesktopMessage(text);
         if (!title) {
             return { ok: false, channel: NAME, id, error: 'refusing to send an empty notification' };

package/dist/lib/channels/providers/index.d.ts

@@ -1,2 +1 @@
-/** Register all built-in providers once (idempotent). */
 export declare function registerBuiltinProviders(): void;

package/dist/lib/channels/providers/index.js

@@ -1,15 +1,10 @@
-/**
- * Provider barrel — importing this registers every built-in channel provider.
- * "App" providers register themselves the same way (registerChannelProvider),
- * so nothing here is privileged over an extension.
- */
 import { registerChannelProvider } from '../registry.js';
 import { mailboxProvider } from './mailbox.js';
 import { rushProviders } from './rush.js';
 import { openclawTelegramProvider } from './openclaw-telegram.js';
 import { desktopProvider } from './desktop.js';
+import { sessionProvider } from './session.js';
 let registered = false;
-/** Register all built-in providers once (idempotent). */
 export function registerBuiltinProviders() {
     if (registered)
         return;
@@ -19,4 +14,5 @@ export function registerBuiltinProviders() {
         registerChannelProvider(p);
     registerChannelProvider(openclawTelegramProvider);
     registerChannelProvider(desktopProvider);
+    registerChannelProvider(sessionProvider);
 }

package/dist/lib/channels/providers/mailbox.js

@@ -1,10 +1,3 @@
-/**
- * Mailbox channel provider — delivers to an agent's file-based mailbox.
- *
- * The mailbox is one channel among many. This provider is a thin wrapper over
- * the same `enqueue` seam that `agents message` uses (commands/message.ts), so
- * both callers share one spool at ~/.agents/.history/mailbox/<id>/.
- */
 import { mailboxDir, enqueue, isValidMailboxId } from '../../mailbox.js';
 export const mailboxProvider = {
     name: 'mailbox',

package/dist/lib/channels/providers/openclaw-telegram.js

@@ -1,11 +1,3 @@
-/**
- * OpenClaw Telegram provider — the mac-mini path.
- *
- * A DISTINCT provider from the rush-backed `telegram` (not a fallback): it
- * reuses the existing openclaw argv builder (lib/notify.ts). Hosts that have
- * openclaw on PATH (mac-mini) can map `transports.telegram: openclaw-telegram`;
- * hosts with a live rush daemon (zion) map `transports.telegram: telegram`.
- */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { buildOpenClawNotifyArgs } from '../../notify.js';

package/dist/lib/channels/providers/rush.d.ts

@@ -1,9 +1,7 @@
 import type { ChannelProvider } from '../registry.js';
 export type RushChannel = 'telegram' | 'imessage' | 'slack' | 'discord';
 export declare const RUSH_CHANNELS: RushChannel[];
-/** Build the osascript argv for sending an iMessage. */
 export declare function buildImessageOsascriptArgs(text: string, phone: string): string[];
 export declare function resolveSlackToken(): string | undefined;
-/** Build the Slack chat.postMessage payload (exported for tests). */
 export declare function buildSlackPayload(channel: string, text: string, thread?: string): Record<string, string>;
 export declare const rushProviders: ChannelProvider[];

package/dist/lib/channels/providers/rush.js

@@ -1,27 +1,11 @@
-/**
- * Channel providers formerly backed by the Rush daemon's live gateways.
- *
- * The desktop-era `rush message send` (iMessage) and `rush send --channel`
- * (Slack/Telegram/Discord) commands were removed with the daemon in the
- * thin-client trim (PHNX-3839/3933). This module now delivers directly:
- *
- *   - **imessage:** `osascript` → Messages.app (macOS only; Linux boxes
- *     rely on the peer-forward in owner-forward.ts to reach a macOS peer).
- *   - **slack:** Slack Web API `chat.postMessage` via `fetch()`, reading
- *     `SLACK_BOT_TOKEN` from env or the `webhooks` secrets bundle.
- *   - **telegram / discord:** error — no direct transport; openclaw-telegram
- *     is available as a separate provider for Telegram.
- */
 import { execFile } from 'child_process';
 import { platform } from 'os';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
 export const RUSH_CHANNELS = ['telegram', 'imessage', 'slack', 'discord'];
-// ── iMessage via osascript ──────────────────────────────────────────────
 function escapeAppleScript(s) {
     return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
-/** Build the osascript argv for sending an iMessage. */
 export function buildImessageOsascriptArgs(text, phone) {
     const escapedText = escapeAppleScript(text);
     const escapedPhone = escapeAppleScript(phone);
@@ -51,17 +35,11 @@ async function sendImessage(text, opts) {
         return { ok: false, channel, id: opts.target, error: err.message };
     }
 }
-// ── Slack via Web API ───────────────────────────────────────────────────
 export function resolveSlackToken() {
-    // 1. Environment variable (set by `secrets exec` or the daemon).
     if (process.env.SLACK_BOT_TOKEN) {
         return process.env.SLACK_BOT_TOKEN;
     }
-    // 2. Secrets bundle — the webhook receiver bundle carries SLACK_BOT_TOKEN
-    //    when a Slack app is configured for this fleet.
     try {
-        // Dynamic import to avoid a hard dependency on the secrets subsystem in
-        // contexts where it is unavailable (CI, containers without a secrets store).
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const { readAndResolveBundleEnvSync } = require('../../secrets-client.js');
         const { env } = readAndResolveBundleEnvSync('webhooks', { caller: 'slack-provider', agentOnly: true });
@@ -70,11 +48,9 @@ export function resolveSlackToken() {
         }
     }
     catch {
-        // Bundle missing, store locked, or secrets CLI not available — not fatal.
     }
     return undefined;
 }
-/** Build the Slack chat.postMessage payload (exported for tests). */
 export function buildSlackPayload(channel, text, thread) {
     const payload = { channel, text };
     if (thread)
@@ -114,7 +90,6 @@ async function sendSlack(text, opts) {
         return { ok: false, channel, id: opts.target, error: err.message };
     }
 }
-// ── Unsupported (daemon-era only) ───────────────────────────────────────
 function unsupportedProvider(name) {
     return {
         name,
@@ -130,7 +105,6 @@ function unsupportedProvider(name) {
         },
     };
 }
-// ── Provider registry ───────────────────────────────────────────────────
 const PROVIDERS = {
     imessage: { name: 'imessage', send: sendImessage },
     slack: { name: 'slack', send: sendSlack },

package/dist/lib/channels/providers/session.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelProvider } from '../registry.js';
+export declare const sessionProvider: ChannelProvider;

package/dist/lib/channels/providers/session.js

@@ -0,0 +1,26 @@
+import { injectIntoTerminal } from '../../terminal/index.js';
+import { resolveLiveInjectTarget } from '../../session/inject-target.js';
+const NAME = 'session';
+export const sessionProvider = {
+    name: NAME,
+    async send(text, opts) {
+        const id = opts.target;
+        const fail = (error) => ({ ok: false, channel: NAME, id, error });
+        if (!text.trim())
+            return fail('refusing to type an empty message into a session');
+        if (opts.attachments?.length)
+            return fail('the session channel types text only; --attach is not supported');
+        if (opts.thread)
+            return fail('the session channel has no threads; drop --thread');
+        if (opts.from)
+            return fail('the session channel types the text verbatim; drop --from');
+        const resolved = await resolveLiveInjectTarget(id);
+        if (!resolved.target) {
+            return fail(resolved.hint ? `${resolved.reason}\n${resolved.hint}` : resolved.reason ?? 'session not addressable');
+        }
+        if (opts.dryRun)
+            return { ok: true, channel: NAME, id };
+        const res = await injectIntoTerminal(resolved.target, text, { enter: true });
+        return res.ok ? { ok: true, channel: NAME, id } : fail(res.error ?? 'injection failed');
+    },
+};

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

@@ -1,49 +1,22 @@
-/**
- * Channel-provider registry for `agents send`.
- *
- * One primitive, many channels. A provider knows how to deliver a message over
- * exactly one channel — the agent mailbox, a rush-daemon gateway (telegram /
- * imessage / slack / discord), openclaw, or a future "app". Providers register
- * themselves at module load; the command layer only ever calls
- * `resolveChannelProvider(name).send(...)` — no channel is special-cased above
- * this seam, so new channels (apps) slot in without touching the command.
- */
 export interface SendOptions {
-    /** Channel-specific recipient id: a chat id, a mailbox/agent id, a Slack C0…, etc. */
     target: string;
-    /** Channel thread id / timestamp (slack/telegram threads). */
     thread?: string;
-    /** Absolute paths to file attachments. */
     attachments?: string[];
-    /** Sender label (used by the mailbox provider). */
     from?: string;
-    /** Destination was resolved through the verified owner alias. */
     ownerScoped?: boolean;
-    /** Resolve + build the delivery but do not actually send. */
     dryRun?: boolean;
 }
 export interface SendResult {
     ok: boolean;
-    /** Channel/provider name as surfaced back to the caller. */
     channel: string;
-    /** Resolved recipient id, echoed for --json parity with `rush send`. */
     id: string;
     error?: string;
-    /** Echoed attachment paths (rush shape parity). */
     attachments?: string[];
-    /** Mailbox provider returns the enqueued message id. */
     msgId?: string;
-    /**
-     * The exact body handed to the provider for THIS destination. Set by the owner
-     * fan-out (`sendToOwner`) so a per-destination compose is observable — Slack
-     * carries the `mrkdwn` labeled-link variant, iMessage the plain one (PHNX-3698).
-     */
     body?: 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. */
     name: string;
     send(text: string, opts: SendOptions): Promise<SendResult>;
 }

package/dist/lib/channels/registry.js

@@ -1,13 +1,3 @@
-/**
- * Channel-provider registry for `agents send`.
- *
- * One primitive, many channels. A provider knows how to deliver a message over
- * exactly one channel — the agent mailbox, a rush-daemon gateway (telegram /
- * imessage / slack / discord), openclaw, or a future "app". Providers register
- * themselves at module load; the command layer only ever calls
- * `resolveChannelProvider(name).send(...)` — no channel is special-cased above
- * this seam, so new channels (apps) slot in without touching the command.
- */
 const REGISTRY = new Map();
 export function registerChannelProvider(p) {
     REGISTRY.set(p.name, p);

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

@@ -1,29 +1,10 @@
-/**
- * Transport resolution: map a user-facing channel name to the provider that
- * actually delivers it, using `notify.transports` from agents.yaml.
- *
- * Default is name-identity (`--channel slack` -> `slack` provider) — NOT a
- * fallback to a different transport. Only telegram is dual-homed (rush vs
- * openclaw-telegram); config picks.
- *
- * Two entry points, deliberately: `lookupTransport` *returns* the failure, for
- * long-lived callers (the monitor daemon, the feed-dispatch loop) that must
- * survive a bad channel name; `resolveTransport` `die()`s on it, for the
- * interactive `agents send` command path where exiting with a
- * loud message is the right answer. Never give a daemon the dying one.
- */
 import type { Meta } from '../types.js';
 import { type ChannelProvider } from './registry.js';
 interface TransportLookup {
-    /** Provider name after applying the `notify.transports` mapping. */
     providerName: string;
-    /** Registered provider, or undefined when `providerName` resolves to nothing. */
     provider?: ChannelProvider;
-    /** Why resolution failed — set exactly when `provider` is undefined. */
     error?: string;
 }
-/** Resolve a channel to its provider, returning the failure instead of exiting. */
 export declare function lookupTransport(channel: string, meta: Meta): TransportLookup;
-/** Interactive-command resolution: an unregistered provider dies loud. */
 export declare function resolveTransport(channel: string, meta: Meta): ChannelProvider;
 export {};

package/dist/lib/channels/resolve.js

@@ -1,6 +1,5 @@
 import { die } from '../format.js';
 import { resolveChannelProvider, listChannelProviders } from './registry.js';
-/** Resolve a channel to its provider, returning the failure instead of exiting. */
 export function lookupTransport(channel, meta) {
     const providerName = meta.notify?.transports?.[channel] ?? channel;
     const provider = resolveChannelProvider(providerName);
@@ -13,7 +12,6 @@ export function lookupTransport(channel, meta) {
             `. Registered: ${listChannelProviders().join(', ')}.`,
     };
 }
-/** Interactive-command resolution: an unregistered provider dies loud. */
 export function resolveTransport(channel, meta) {
     const { provider, error } = lookupTransport(channel, meta);
     if (!provider)