@phnx-labs/agents-cli 1.21.0 → 1.21.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.21.1
+
+- **Feed posts require a title + body; phone `{message}` ends with a Sent-from footer.** `agents feed post --title "Short subject" "body text"` — title is the phone first line (~4–5 words), body follows after a blank line, then `Sent from <agent>/<session-chunk> on <host>` (like "Sent from my iPhone"). Em/en dashes in title/body are scrubbed to ASCII ` - `. Source: `apps/cli/src/lib/feed-broadcast.ts`, `feed-post.ts`, `commands/feed.ts`.
+
+- **Hook `timeout` in agents.yaml now accepts duration strings, not just bare seconds (#1555).**
+  A hook can be written `timeout: 5s` / `timeout: 2m` / `timeout: 1h30m` instead of only
+  `timeout: 30` — self-documenting at the call site. A bare number still means seconds, so
+  every existing manifest keeps working. `parseHookManifest` normalizes the value to a
+  seconds number once, so all harness serializers keep consuming a number; an unparseable
+  timeout is dropped with a warning rather than silently coerced. Source:
+  `apps/cli/src/lib/hooks.ts` (`normalizeHookTimeoutSeconds`, `parseHookManifest`),
+  `apps/cli/docs/hooks.md`.
+
+- **Owner notifications route through the one channel seam.** The feed urgent-block
+  dispatch and the monitor `notify` action now send through the registered channel
+  provider (`lookupTransport` → `ChannelProvider.send`) instead of shelling out to
+  `openclaw` directly. The recipient comes from `notify.owner` in agents.yaml — the
+  hardcoded owner chat id is gone, so changing `notify.owner` is honoured by every
+  path. A bare `--notify` on a monitor now targets `notify.owner`; `--notify <channel>`
+  overrides the owner channel. The monitor path also gains the provider's missing-binary
+  guard (a clean error instead of a raw ENOENT). A channel name that resolves to no
+  registered provider (a typo in `notify.owner.channel`, or `--notify <channel>`) fails
+  that one send with a clean error — it does not exit the monitor daemon or abort the
+  `agents feed --dispatch` loop. Source: `apps/cli/src/lib/notify.ts`,
+  `apps/cli/src/lib/monitors/dispatch.ts`, `apps/cli/src/lib/channels/resolve.ts`.
+
 ## 1.21.0
 
 - **A clone of your own DotAgents repo no longer hijacks project-layer rule resolution (RUSH-2037).**

package/README.md

@@ -341,7 +341,7 @@ agents feed --flat                  # one row per agent (legacy)
 agents feed --host mac-mini         # scope the view to one or more hosts
 agents feed --local                 # skip the SSH fan-out
 agents feed --json                  # blocks stamped with their outcome key
-agents feed post "halfway done"     # agent status post (auto session identity)
+agents feed post --title "Halfway done" "CI green, watching merge"  # title + body
 ```
 
 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.

package/dist/commands/feed.js

@@ -234,44 +234,44 @@ export function registerFeedCommand(program) {
     feed
         .command('post')
         .description('Post a status update to the fleet activity stream (for agents)')
-        .argument('<text...>', 'What just happened — one short human line')
+        .argument('<text...>', 'Body: what just happened (after --title)')
+        .requiredOption('--title <title>', 'Short subject, ~4-5 words (phone first line)')
         .option('--session <id>', 'Session id escape hatch (default: auto from env / pid registry)')
         .option('--attach <path-or-url...>', 'Attach an artifact (local file or URL); repeatable')
         .option('--level <level>', 'How loudly to broadcast: milestone (default) or important. Configured sinks with minLevel: important only fire on the latter.', 'milestone')
-        .option('--blocked', 'You are STUCK and need the user. Opens an answerable block and always broadcasts at important — do not also pass --level.')
+        .option('--blocked', 'You are STUCK and need the user. Opens an answerable block and always broadcasts at important - do not also pass --level.')
         .option('--option <label...>', 'With --blocked: an answer the user can pick; repeatable')
         .option('--default <answer>', 'With --blocked: a safe default policy may apply if nobody answers in time')
         .option('--json', 'Emit the written event as JSON')
         .addHelpText('after', `
 Examples:
-  # Inside an agents-cli run (session identity is already in the env):
-  agents feed post "CHANGELOG pushed; watching CI and mac-mini E2E"
-  agents feed post "cover render ready" --attach ./out/cover.png
-  agents feed post "ready for review" --json
+  # Title (subject) + body. Phone broadcasts put title first, body after a
+  # blank line, then a "Sent from agent/session on host" footer.
+  agents feed post --title "CHANGELOG pushed" "Watching CI and mac-mini E2E"
+  agents feed post --title "Cover ready" "render at ./out/cover.png" --attach ./out/cover.png
+  agents feed post --title "Ready for review" "PR opened, waiting on prix-cloud" --json
 
-  # Worth interrupting someone over — reaches sinks gated on minLevel: important:
-  agents feed post "release blocked: npm token expired" --level important
+  # Worth interrupting someone over - reaches sinks gated on minLevel: important:
+  agents feed post --title "npm token expired" "Cannot publish the release" --level important
 
-  # You are STUCK and cannot proceed. Opens an answerable block that stays in
-  # 'agents feed' until someone resolves it, and always reaches the owner —
-  # do NOT also pass --level:
-  agents feed post "force-push denied by git-guard on PR #1749" --blocked
-  agents feed post "publish to npm or wait for review?" --blocked --option publish --option wait
-  agents feed post "delete the stale preview env?" --blocked --default "leave it"
+  # Stuck: opens a needs-you block and always broadcasts at important:
+  agents feed post --title "Force-push denied" "git-guard blocked PR #1749" --blocked
+  agents feed post --title "Publish or wait?" "npm publish now or after review" --blocked --option publish --option wait
+  agents feed post --title "Delete preview env?" "stale preview still running" --blocked --default "leave it"
 
   # Exhaust self-serve FIRST. A block is for what you genuinely cannot do:
   # a credential only the user holds, a decision only they can make, an
   # approval only they can give. Not "should I do the obvious next step?".
 
   # Outside a run, pass the session explicitly:
-  agents feed post "manual note" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
+  agents feed post --title "Manual note" "context for the next agent" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
 
-Identity (session, agent, host, runtime, pid, launchId) is stamped automatically.
-Domain facts (tickets, PRs) are not CLI flags — the ticket is joined from the
-session index at post time, so a broadcast sink can comment on it without the
-agent having to remember it.
+Identity (session, agent, host, runtime, pid, launchId) is stamped automatically
+and rides the phone footer of feed.broadcast {message}. Domain facts (tickets,
+PRs) are not CLI flags - the ticket is joined from the session index at post
+time. No em-dashes in title/body - they are scrubbed on the way out.
 
-Configure where a post is mirrored under feed.broadcast in agents.yaml — see
+Configure where a post is mirrored under feed.broadcast in agents.yaml - see
 docs/06-observability.md.
 `)
         .action((textParts, opts, cmd) => {
@@ -279,6 +279,7 @@ docs/06-observability.md.
         // binds the flag on the parent, so a `feed post … --json` lands on
         // parent.opts().json — not the child. Read both.
         const flags = {
+            title: opts?.title ?? cmd?.opts?.()?.title,
             session: opts?.session ?? cmd?.opts?.()?.session,
             attach: opts?.attach ?? cmd?.opts?.()?.attach,
             level: opts?.level ?? cmd?.opts?.()?.level,
@@ -298,8 +299,12 @@ docs/06-observability.md.
             if (!flags.blocked && (flags.option?.length || flags.default)) {
                 throw new Error('--option/--default only apply with --blocked.');
             }
+            if (!flags.title?.trim()) {
+                throw new Error('Missing --title. Usage: agents feed post --title "Short subject" "body text"');
+            }
             const level = flags.blocked ? 'important' : parseFeedPostLevel(flags.level);
             const { event } = postFeedStatus({
+                title: flags.title,
                 text: Array.isArray(textParts) ? textParts.join(' ') : String(textParts ?? ''),
                 sessionId: flags.session,
                 attach: flags.attach,
@@ -312,12 +317,20 @@ docs/06-observability.md.
             let outcomes;
             if (flags.blocked) {
                 const block = buildDeclaredBlock(event, {
-                    text: event.detail ?? '',
+                    // Prefer title as the front-loaded ask on the phone; body is detail.
+                    text: event.title
+                        ? (event.detail ? `${event.title}: ${event.detail}` : event.title)
+                        : (event.detail ?? ''),
                     options: flags.option,
                     safeDefault: flags.default,
                 });
                 publishBlock(block);
-                outcomes = broadcastBlock(block, { project: event.project, agent: event.agent });
+                outcomes = broadcastBlock(block, {
+                    project: event.project,
+                    agent: event.agent,
+                    title: event.title,
+                    body: event.detail,
+                });
             }
             else {
                 outcomes = broadcastPostedEvent(event, level);
@@ -561,6 +574,7 @@ function broadcastPostedEvent(event, level) {
         return [];
     const ticket = getSessionById(event.sessionId)?.ticketId;
     const planned = planFeedBroadcast(config, {
+        title: event.title,
         text: event.detail ?? '',
         level,
         ticket,
@@ -675,7 +689,7 @@ function renderUpdatesView(updates) {
     }));
     console.log();
     if (updates.length === 0) {
-        console.log(chalk.gray('  No progress updates yet. Agents post them with `agents feed post "…"`.'));
+        console.log(chalk.gray('  No progress updates yet. Agents post them with `agents feed post --title "…" "…"`.'));
         return;
     }
     for (const ev of updates) {

package/dist/commands/monitors.js

@@ -57,7 +57,7 @@ function actionLabel(action) {
         case 'routine':
             return `routine ${action.routine ?? ''}`;
         case 'notify':
-            return `notify ${action.notifyChannel ?? 'telegram'}`;
+            return `notify ${action.notifyChannel ?? 'owner'}`;
         case 'webhook-out':
             return `webhook-out ${action.url ?? ''}`;
         default:
@@ -195,9 +195,11 @@ function buildAction(options) {
     if (options.routine)
         chosen.push({ type: 'routine', routine: options.routine });
     if (options.notify !== undefined) {
-        // --notify may be a bare flag (true) or carry a channel string.
-        const channel = typeof options.notify === 'string' ? options.notify : 'telegram';
-        chosen.push({ type: 'notify', notifyChannel: channel });
+        // --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).
+        const channel = typeof options.notify === 'string' ? options.notify : undefined;
+        chosen.push({ type: 'notify', ...(channel ? { notifyChannel: channel } : {}) });
     }
     if (options.webhookOut)
         chosen.push({ type: 'webhook-out', url: options.webhookOut });
@@ -310,7 +312,7 @@ export function registerMonitorsCommands(program) {
         .option('--effort <effort>', 'Reasoning effort for --run: low | medium | high | xhigh | max | auto')
         .option('--action-timeout <t>', 'Kill the --run action if it runs longer than this (e.g. 10m)')
         .option('--routine <name>', 'Fire an existing routine on change')
-        .option('--notify [channel]', 'Send a notification (default channel: telegram)')
+        .option('--notify [channel]', 'Notify the owner (notify.owner); [channel] overrides the owner channel')
         .option('--webhook-out <url>', 'POST the event to this URL')
         // PLACEMENT / hygiene
         .option('--device <name>', 'OWNER device — the single machine that evaluates + fires (exactly-once)')
@@ -573,7 +575,7 @@ export function registerMonitorsCommands(program) {
                 name,
                 source: { type: 'poll', command: 'echo hello', interval: '1m' },
                 condition: { mode: 'on-change' },
-                action: { type: 'notify', notifyChannel: 'telegram' },
+                action: { type: 'notify' },
             });
             fs.writeFileSync(monitorPath, template, 'utf-8');
             console.log(chalk.gray(`Created new monitor file: ${monitorPath}`));

package/dist/lib/activity.d.ts

@@ -89,6 +89,12 @@ export interface ActivityEvent {
     tool?: string;
     /** One-line human summary (plan title, PR command, sub-agent role, status text). */
     detail?: string;
+    /**
+     * Short subject for deliberate status posts (`feed post --title`). Phone
+     * broadcasts put this on the first line; `detail` is the body. Optional on
+     * older events that only carried `detail`.
+     */
+    title?: string;
     /** Extracted URL when the event has one (e.g. the opened PR). */
     url?: string;
     /** Auto-stamped process identity for deliberate posts (from pid registry / env). */

package/dist/lib/activity.js

@@ -141,6 +141,7 @@ function parseLine(line) {
             kind: parsed.kind,
             tool: parsed.tool,
             detail: parsed.detail,
+            title: typeof parsed.title === 'string' ? parsed.title : undefined,
             url: parsed.url,
             pid: typeof parsed.pid === 'number' ? parsed.pid : undefined,
             launchId: parsed.launchId,
@@ -398,6 +399,8 @@ export function formatProgressUpdate(ev, opts = {}) {
     ].filter((c) => Boolean(c));
     if (chips.length > 0)
         lines.push(`    ${chalk.gray(chips.join(' · '))}`);
+    if (ev.title)
+        lines.push(`    ${chalk.white.bold(ev.title)}`);
     if (ev.detail)
         lines.push(`    ${chalk.white(`"${ev.detail}"`)}`);
     if (ev.attachments?.length) {

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

@@ -24,7 +24,7 @@ export const openclawTelegramProvider = {
             return { ok: false, channel: name, id: opts.target, error: 'openclaw CLI not found on PATH' };
         }
         try {
-            await execFileAsync('openclaw', buildOpenClawNotifyArgs(text, { channel: 'telegram', target: opts.target }));
+            await execFileAsync('openclaw', buildOpenClawNotifyArgs(text, { target: opts.target }));
             return { ok: true, channel: name, id: opts.target };
         }
         catch (err) {

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

@@ -4,8 +4,25 @@
  *
  * 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. An unmapped-to-unregistered name dies loud.
+ * 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` / `agents notify` 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';
+export 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;

package/dist/lib/channels/resolve.js

@@ -1,12 +1,22 @@
 import { die } from '../format.js';
 import { resolveChannelProvider, listChannelProviders } from './registry.js';
-export function resolveTransport(channel, meta) {
+/** 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);
-    if (!provider) {
-        die(`No channel provider '${providerName}'` +
+    if (provider)
+        return { providerName, provider };
+    return {
+        providerName,
+        error: `No channel provider '${providerName}'` +
             (providerName === channel ? '' : ` (mapped from channel '${channel}' via notify.transports)`) +
-            `. Registered: ${listChannelProviders().join(', ')}.`);
-    }
+            `. Registered: ${listChannelProviders().join(', ')}.`,
+    };
+}
+/** Interactive-command resolution: an unregistered provider dies loud. */
+export function resolveTransport(channel, meta) {
+    const { provider, error } = lookupTransport(channel, meta);
+    if (!provider)
+        die(error);
     return provider;
 }

package/dist/lib/feed-broadcast.d.ts

@@ -16,7 +16,9 @@ export interface FeedSinkConfig {
 export type FeedBroadcastConfig = Record<string, FeedSinkConfig>;
 /** Everything a template may interpolate. Absent values skip templates that need them. */
 export interface FeedBroadcastContext {
-    /** The post text, verbatim. */
+    /** Short subject line (~4–5 words). Phone line 1. */
+    title?: string;
+    /** The post body, verbatim. Phone line after the blank line. */
     text: string;
     level: FeedPostLevel;
     /** Tracker id for the work, e.g. `RUSH-2081`. */
@@ -63,6 +65,8 @@ export declare function blockBroadcastContext(block: {
 }, extras?: {
     project?: string;
     agent?: string;
+    title?: string;
+    body?: string;
 }): FeedBroadcastContext;
 /**
  * Why a declared block reached nobody, or undefined when it got through.
@@ -87,10 +91,42 @@ export interface SinkOutcome {
     error?: string;
 }
 /**
- * A human-facing one-liner for a messaging sink: what project, what happened,
- * and the link to go read more. Leading with the project is deliberate — a
- * message that opens with an agent name tells the reader nothing about which of
- * their projects just moved.
+ * Short host label for a phone line — strip user@ and domain so
+ * `muqsit@mac-mini.tailnet.ts.net` reads as `mac-mini`.
+ */
+export declare function shortHost(host: string | undefined): string | undefined;
+/** First 8 hex chars of a session id for the footer (readable, not a full uuid). */
+export declare function shortSessionChunk(session: string | undefined): string | undefined;
+/**
+ * Scrub em/en dashes from outbound phone copy (house rule + iMessage readability).
+ * Collapses whitespace; does not invent meaning.
+ */
+export declare function scrubOutboundDashes(text: string): string;
+/**
+ * Footer like "Sent from my iPhone" — who posted, a session crumb, which box.
+ *
+ *   Sent from grok/a02da0e2 on mac-mini
+ *
+ * Agent name first; session chunk for disambiguation when many groks run;
+ * host last. Skip the uninformative default label `agent`.
+ */
+export declare function composeBroadcastFooter(ctx: FeedBroadcastContext): string | undefined;
+/**
+ * Human-facing body for a messaging sink (`{message}`).
+ *
+ * ```
+ * Title in a few words
+ *
+ * Body of what happened or the ask.
+ *
+ * Sent from grok/a02da0e2 on mac-mini
+ * agents focus a02da0e2          (blocks only)
+ * https://…                      (optional attach URL)
+ * ```
+ *
+ * Title first (scannable subject). Blank line. Body. Footer provenance so a
+ * fleet of agents is attributable without crowding the ask. Prefer `{message}`
+ * over bare `{text}` in messaging sinks.
  */
 export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): string;
 /**

package/dist/lib/feed-broadcast.js

@@ -50,8 +50,12 @@ export function parseFeedPostLevel(raw) {
 export function blockBroadcastContext(block, extras = {}) {
     const ask = block.questions?.[0]?.text?.trim() || 'agent is blocked';
     const links = [block.pr].filter((l) => !!l && /^https?:\/\//i.test(l));
+    // Prefer explicit title/body from the feed post; fall back to the ask as body.
+    const title = extras.title?.trim() || undefined;
+    const text = extras.body?.trim() || ask;
     return {
-        text: ask,
+        ...(title ? { title } : {}),
+        text,
         level: 'important',
         ticket: block.ticket,
         project: extras.project,
@@ -92,24 +96,118 @@ export function blockDeliveryFailure(blocked, outcomes) {
 }
 const PLACEHOLDER = /\{([a-z]+)\}/g;
 /**
- * A human-facing one-liner for a messaging sink: what project, what happened,
- * and the link to go read more. Leading with the project is deliberate — a
- * message that opens with an agent name tells the reader nothing about which of
- * their projects just moved.
+ * Short host label for a phone line — strip user@ and domain so
+ * `muqsit@mac-mini.tailnet.ts.net` reads as `mac-mini`.
+ */
+export function shortHost(host) {
+    if (!host?.trim())
+        return undefined;
+    let h = host.trim();
+    const at = h.lastIndexOf('@');
+    if (at !== -1)
+        h = h.slice(at + 1);
+    const dot = h.indexOf('.');
+    if (dot > 0)
+        h = h.slice(0, dot);
+    return h || undefined;
+}
+/** First 8 hex chars of a session id for the footer (readable, not a full uuid). */
+export function shortSessionChunk(session) {
+    if (!session?.trim())
+        return undefined;
+    const hex = session.replace(/-/g, '').toLowerCase();
+    const chunk = hex.replace(/[^a-f0-9]/g, '').slice(0, 8);
+    return chunk || undefined;
+}
+/**
+ * Scrub em/en dashes from outbound phone copy (house rule + iMessage readability).
+ * Collapses whitespace; does not invent meaning.
+ */
+export function scrubOutboundDashes(text) {
+    return text
+        .replace(/\u2014/g, ' - ')
+        .replace(/\u2013/g, ' - ')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
+/**
+ * Footer like "Sent from my iPhone" — who posted, a session crumb, which box.
+ *
+ *   Sent from grok/a02da0e2 on mac-mini
+ *
+ * Agent name first; session chunk for disambiguation when many groks run;
+ * host last. Skip the uninformative default label `agent`.
+ */
+export function composeBroadcastFooter(ctx) {
+    const agent = ctx.agent?.trim();
+    const agentLabel = agent && agent !== 'agent' ? agent : undefined;
+    const session = shortSessionChunk(ctx.session);
+    const host = shortHost(ctx.host);
+    let who;
+    if (agentLabel && session)
+        who = `${agentLabel}/${session}`;
+    else if (agentLabel)
+        who = agentLabel;
+    else if (session)
+        who = session;
+    if (who && host)
+        return `Sent from ${who} on ${host}`;
+    if (who)
+        return `Sent from ${who}`;
+    if (host)
+        return `Sent from host ${host}`;
+    return undefined;
+}
+/**
+ * Human-facing body for a messaging sink (`{message}`).
+ *
+ * ```
+ * Title in a few words
+ *
+ * Body of what happened or the ask.
+ *
+ * Sent from grok/a02da0e2 on mac-mini
+ * agents focus a02da0e2          (blocks only)
+ * https://…                      (optional attach URL)
+ * ```
+ *
+ * Title first (scannable subject). Blank line. Body. Footer provenance so a
+ * fleet of agents is attributable without crowding the ask. Prefer `{message}`
+ * over bare `{text}` in messaging sinks.
  */
 export function composeBroadcastMessage(ctx) {
-    const head = ctx.project ? `${ctx.project} · ${ctx.text}` : ctx.text;
+    const title = scrubOutboundDashes(ctx.title ?? '');
+    const body = scrubOutboundDashes(ctx.text ?? '');
+    // Title preferred; if an older post has no title, body alone still sends.
+    const head = title || body;
+    const mid = title && body && title !== body ? body : undefined;
+    const footer = composeBroadcastFooter(ctx);
     const link = ctx.links?.find((l) => /^https?:\/\//i.test(l));
-    // A block's second line is the command that unblocks it. The operator reading
-    // this on a phone should not have to go find the session — the one action they
-    // must take travels with the ask. A status post has no such action, so it keeps
-    // the link there instead.
-    const tail = [ctx.focus, link].filter(Boolean);
-    return tail.length ? `${head}\n${tail.join('\n')}` : head;
+    // Block focus and link trail after the "Sent from" footer so the human
+    // sentence stays at the top and the action/link are still one glance away.
+    const trail = [footer, ctx.focus, link].filter(Boolean);
+    const parts = [];
+    if (head)
+        parts.push(head);
+    if (mid) {
+        // Blank line between subject and body (title, then space, then message).
+        parts.push('');
+        parts.push(mid);
+    }
+    if (trail.length) {
+        // Blank line before the footer block (iPhone "Sent from my iPhone" spacing).
+        if (parts.length)
+            parts.push('');
+        parts.push(trail.join('\n'));
+    }
+    return parts.join('\n').trim();
 }
 /** The values a template may reference, resolved once per post. */
 function templateVars(ctx) {
     return {
+        title: ctx.title,
         text: ctx.text,
         ticket: ctx.ticket,
         project: ctx.project,

package/dist/lib/feed-post.d.ts

@@ -2,8 +2,15 @@ import { type ActivityEvent, type Attachment } from './activity.js';
 import { type PidSessionEntry } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export declare const STATUS_POST_MAX_CHARS = 500;
+/** Title is a phone subject line - about four or five words, not a paragraph. */
+export declare const STATUS_TITLE_MAX_CHARS = 60;
 export interface FeedPostInput {
-    /** Human-readable progress text (required). Domain-agnostic free text. */
+    /**
+     * Short subject (required for new posts). ~4–5 words. Phone broadcasts put
+     * this on the first line so a scan names the topic before the body.
+     */
+    title: string;
+    /** Body text (required). Domain-agnostic free text — what happened / the ask. */
     text: string;
     /** Override session id (escape hatch for scripts/tests). Prefer auto-resolve. */
     sessionId?: string;
@@ -92,9 +99,16 @@ export declare function buildAttachments(tokens: string[] | undefined, ctx: {
     sessionId: string;
     updateId: string;
 }): Attachment[];
+/**
+ * Collapse whitespace and strip em/en dashes (house rule: no em-dashes in
+ * agent-authored outbound copy — phones and plain text render them poorly).
+ */
+export declare function scrubDashes(text: string): string;
 export declare function normalizeStatusText(text: string): string;
+/** Normalize a short subject line for a post. */
+export declare function normalizeStatusTitle(title: string): string;
 /**
  * Append a `status.posted` milestone for the calling agent.
- * Throws if text is empty or session identity cannot be resolved.
+ * Throws if title/text is empty or session identity cannot be resolved.
  */
 export declare function postFeedStatus(input: FeedPostInput): FeedPostResult;

package/dist/lib/feed-post.js

@@ -1,13 +1,14 @@
 /**
  * Agent status posts — deliberate progress messages into the activity stream.
  *
- * Surface: `agents feed post <text>` (agent-callable; humans watch via
- * `agents feed` / `agents activity` / `agents events --module activity`).
+ * Surface: `agents feed post --title <subject> <body>` (agent-callable; humans
+ * watch via `agents feed` / `agents activity` / `agents events --module activity`).
  *
  * Identity is automatic: session id, agent, cwd, launch/pid/tmux provenance
  * are resolved from the process environment and the per-pid launch registry
- * (`lib/session/pid-registry.ts`). The agent only authors free-form text —
- * no domain-specific flags (tickets, URLs, tracks).
+ * (`lib/session/pid-registry.ts`). The agent authors a short title + body —
+ * no domain-specific flags (tickets, URLs, tracks). Phone `{message}` ends with
+ * a "Sent from agent/session on host" footer.
  *
  * Storage: append-only activity log as a `status.posted` milestone. Does NOT
  * open a feed block (blocks remain "needs you" state only).
@@ -23,6 +24,8 @@ import { isValidMailboxId } from './mailbox.js';
 import { listPidSessionEntries, readPidSessionEntry, } from './session/pid-registry.js';
 /** Soft cap so a runaway agent can't flood the activity lane with essays. */
 export const STATUS_POST_MAX_CHARS = 500;
+/** Title is a phone subject line - about four or five words, not a paragraph. */
+export const STATUS_TITLE_MAX_CHARS = 60;
 /**
  * Resolve who is posting. Order:
  *  1. Explicit --session flag
@@ -241,22 +244,46 @@ export function buildAttachments(tokens, ctx) {
     }
     return out;
 }
+/**
+ * Collapse whitespace and strip em/en dashes (house rule: no em-dashes in
+ * agent-authored outbound copy — phones and plain text render them poorly).
+ */
+export function scrubDashes(text) {
+    return text
+        .replace(/\u2014/g, ' - ') // em dash —
+        .replace(/\u2013/g, ' - ') // en dash –
+        .replace(/\s+/g, ' ')
+        .trim();
+}
 export function normalizeStatusText(text) {
-    const collapsed = text.replace(/\s+/g, ' ').trim();
+    const collapsed = scrubDashes(text);
     if (!collapsed)
         return '';
     if (collapsed.length <= STATUS_POST_MAX_CHARS)
         return collapsed;
     return `${collapsed.slice(0, STATUS_POST_MAX_CHARS - 1)}…`;
 }
+/** Normalize a short subject line for a post. */
+export function normalizeStatusTitle(title) {
+    const collapsed = scrubDashes(title);
+    if (!collapsed)
+        return '';
+    if (collapsed.length <= STATUS_TITLE_MAX_CHARS)
+        return collapsed;
+    return `${collapsed.slice(0, STATUS_TITLE_MAX_CHARS - 1)}…`;
+}
 /**
  * Append a `status.posted` milestone for the calling agent.
- * Throws if text is empty or session identity cannot be resolved.
+ * Throws if title/text is empty or session identity cannot be resolved.
  */
 export function postFeedStatus(input) {
+    const title = normalizeStatusTitle(input.title ?? '');
     const detail = normalizeStatusText(input.text);
+    if (!title) {
+        throw new Error('Title is empty. Usage: agents feed post --title "Short subject" "what just happened"');
+    }
     if (!detail) {
-        throw new Error('Status text is empty. Usage: agents feed post "what just happened"');
+        throw new Error('Status text is empty. Usage: agents feed post --title "Short subject" "what just happened"');
     }
     const identity = resolvePostIdentity(input);
     if (!identity) {
@@ -285,6 +312,7 @@ export function postFeedStatus(input) {
         cwd: identity.cwd,
         agent: identity.agent,
         tool: 'feed.post',
+        title,
         detail,
         ...(project ? { project } : {}),
         ...(identity.pid !== undefined ? { pid: identity.pid } : {}),

package/dist/lib/feed.js

@@ -255,7 +255,7 @@ export function clearBlockLifecycle(blockId, root) {
 export function buildDeclaredBlock(agent, input) {
     const text = input.text.trim().replace(/\s+/g, ' ');
     if (!text) {
-        throw new Error('Block text is empty. Usage: agents feed post "what you need from the user" --blocked');
+        throw new Error('Block text is empty. Usage: agents feed post --title "Short subject" "what you need from the user" --blocked');
     }
     const options = (input.options ?? [])
         .map((label) => label.trim())

package/dist/lib/hooks.d.ts

@@ -198,6 +198,19 @@ export declare function installHooksCentrally(source: string): Promise<{
  * User dir takes priority; deduplication preserves first occurrence.
  */
 export declare function listCentralHooks(): HookEntry[];
+/**
+ * Normalize a hook `timeout` from agents.yaml into a whole number of seconds.
+ *
+ * A bare number stays seconds (`timeout: 30` → 30) for backward compatibility.
+ * A Go-style duration string is parsed into seconds: `5s`, `2m`, `1h30m`,
+ * `90s`, `1h`. This intentionally does NOT reuse {@link parseTimeout} from
+ * routines.ts — that one returns milliseconds, has no seconds (`s`) unit, and
+ * floors at one minute, none of which fit hook timeouts (typically 5–600s).
+ *
+ * Returns the seconds value, or `null` when the input is not a positive number
+ * or a parseable duration string — the caller decides how to surface that.
+ */
+export declare function normalizeHookTimeoutSeconds(value: unknown): number | null;
 /**
  * Parse hook manifests. Reads system hooks from ~/.agents/.system/hooks.yaml
  * (npm-shipped defaults) and user hooks from the `hooks:` section of
@@ -205,7 +218,9 @@ export declare function listCentralHooks(): HookEntry[];
  * A user entry with `enabled: false` disables the system-shipped hook of
  * the same name without forking the system file.
  *
- * Hooks marked `enabled: false` are dropped from the returned map.
+ * Hooks marked `enabled: false` are dropped from the returned map. A hook
+ * `timeout` written as a duration string (`5s`, `2m`) is normalized to a
+ * seconds number here, so every downstream serializer keeps reading a number.
  */
 export declare function parseHookManifest(opts?: {
     warn?: boolean;

package/dist/lib/hooks.js

@@ -952,6 +952,44 @@ export function listCentralHooks() {
     }
     return results;
 }
+/**
+ * Normalize a hook `timeout` from agents.yaml into a whole number of seconds.
+ *
+ * A bare number stays seconds (`timeout: 30` → 30) for backward compatibility.
+ * A Go-style duration string is parsed into seconds: `5s`, `2m`, `1h30m`,
+ * `90s`, `1h`. This intentionally does NOT reuse {@link parseTimeout} from
+ * routines.ts — that one returns milliseconds, has no seconds (`s`) unit, and
+ * floors at one minute, none of which fit hook timeouts (typically 5–600s).
+ *
+ * Returns the seconds value, or `null` when the input is not a positive number
+ * or a parseable duration string — the caller decides how to surface that.
+ */
+export function normalizeHookTimeoutSeconds(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && value > 0 ? value : null;
+    }
+    if (typeof value === 'string') {
+        const s = value.trim();
+        if (s === '')
+            return null;
+        // A bare integer string means seconds, matching the bare-number form.
+        if (/^\d+$/.test(s)) {
+            const n = Number(s);
+            return n > 0 ? n : null;
+        }
+        const m = s.match(/^(?:(\d+)w)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/i);
+        if (!m)
+            return null;
+        const weeks = Number(m[1] || 0);
+        const days = Number(m[2] || 0);
+        const hours = Number(m[3] || 0);
+        const minutes = Number(m[4] || 0);
+        const seconds = Number(m[5] || 0);
+        const total = ((weeks * 7 + days) * 24 + hours) * 3600 + minutes * 60 + seconds;
+        return total > 0 ? total : null;
+    }
+    return null;
+}
 /**
  * Parse hook manifests. Reads system hooks from ~/.agents/.system/hooks.yaml
  * (npm-shipped defaults) and user hooks from the `hooks:` section of
@@ -959,7 +997,9 @@ export function listCentralHooks() {
  * A user entry with `enabled: false` disables the system-shipped hook of
  * the same name without forking the system file.
  *
- * Hooks marked `enabled: false` are dropped from the returned map.
+ * Hooks marked `enabled: false` are dropped from the returned map. A hook
+ * `timeout` written as a duration string (`5s`, `2m`) is normalized to a
+ * seconds number here, so every downstream serializer keeps reading a number.
  */
 export function parseHookManifest(opts = {}) {
     const warn = opts.warn !== false;
@@ -1026,6 +1066,26 @@ export function parseHookManifest(opts = {}) {
         if (def.enabled === false)
             delete merged[name];
     }
+    // Normalize each surviving hook's timeout to a seconds number, so the raw
+    // agents.yaml can express it as a duration string (`5s`, `2m`) while every
+    // downstream serializer keeps consuming a plain number. An unparseable value
+    // is dropped with a warning rather than silently coerced to a wrong duration.
+    for (const [name, def] of Object.entries(merged)) {
+        const raw = def.timeout;
+        if (raw === undefined)
+            continue;
+        const seconds = normalizeHookTimeoutSeconds(raw);
+        if (seconds === null) {
+            if (warn) {
+                console.warn(`[agents hooks] Hook '${name}' has an invalid timeout ${JSON.stringify(raw)}; ` +
+                    `expected seconds or a duration string like '5s', '2m', '1h30m'. Ignoring it.`);
+            }
+            delete def.timeout;
+        }
+        else {
+            def.timeout = seconds;
+        }
+    }
     return merged;
 }
 export function selectHookManifest(manifest, selected) {

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

@@ -80,7 +80,7 @@ export interface ActionConfig {
     timeout?: string;
     /** routine: name of an existing routine to fire. */
     routine?: string;
-    /** notify: channel for the notification (default `telegram`). */
+    /** notify: override the owner channel (defaults to `notify.owner.channel`). */
     notifyChannel?: string;
     /** webhook-out: URL to POST the event to. */
     url?: string;

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

@@ -5,8 +5,12 @@
  * action goes through the *same* detached spawn cron and webhook fires use
  * (executeJobDetached, lib/runner.ts) — a monitor never duplicates spawn logic,
  * it synthesizes a JobConfig and hands it to the one dispatch seam. `notify`
- * reuses the openclaw Telegram path (lib/notify.ts); `webhook-out` POSTs the event.
+ * routes the owner through the one channel seam (sendToOwner → lookupTransport,
+ * lib/notify.ts) — recipient from notify.owner, no hardcoded chat id, and an
+ * unresolvable channel comes back as `ok: false` instead of exiting the daemon;
+ * `webhook-out` POSTs the event.
  */
+import type { Meta } from '../types.js';
 import type { ActionConfig, MonitorConfig, MonitorEvent } from './config.js';
 /** Outcome of a dispatched action. */
 export interface DispatchResult {
@@ -25,4 +29,4 @@ export declare function injectEvent(prompt: string, event: MonitorEvent): string
  * use. `routine` fires an existing routine with the event injected. `notify` and
  * `webhook-out` are terminal side-effects.
  */
-export declare function dispatchAction(monitor: MonitorConfig, event: MonitorEvent): Promise<DispatchResult>;
+export declare function dispatchAction(monitor: MonitorConfig, event: MonitorEvent, meta?: Meta): Promise<DispatchResult>;

package/dist/lib/monitors/dispatch.js

@@ -5,14 +5,14 @@
  * action goes through the *same* detached spawn cron and webhook fires use
  * (executeJobDetached, lib/runner.ts) — a monitor never duplicates spawn logic,
  * it synthesizes a JobConfig and hands it to the one dispatch seam. `notify`
- * reuses the openclaw Telegram path (lib/notify.ts); `webhook-out` POSTs the event.
+ * routes the owner through the one channel seam (sendToOwner → lookupTransport,
+ * lib/notify.ts) — recipient from notify.owner, no hardcoded chat id, and an
+ * unresolvable channel comes back as `ok: false` instead of exiting the daemon;
+ * `webhook-out` POSTs the event.
  */
-import { execFile } from 'child_process';
-import { promisify } from 'util';
 import { executeJobDetached } from '../runner.js';
 import { readJob } from '../routines.js';
-import { buildOpenClawNotifyArgs } from '../notify.js';
-const execFileAsync = promisify(execFile);
+import { sendToOwner } from '../notify.js';
 /** Replace `{event}` in a prompt with the fired event summary. */
 export function injectEvent(prompt, event) {
     return prompt.replace(/\{event\}/g, event.summary);
@@ -24,7 +24,7 @@ export function injectEvent(prompt, event) {
  * use. `routine` fires an existing routine with the event injected. `notify` and
  * `webhook-out` are terminal side-effects.
  */
-export async function dispatchAction(monitor, event) {
+export async function dispatchAction(monitor, event, meta) {
     const action = monitor.action;
     if (action.type === 'run') {
         const job = {
@@ -63,16 +63,11 @@ export async function dispatchAction(monitor, event) {
         }
     }
     if (action.type === 'notify') {
-        const args = buildOpenClawNotifyArgs(event.summary, {
-            channel: action.notifyChannel ?? 'telegram',
+        const result = await sendToOwner(event.summary, {
+            ...(meta ? { meta } : {}),
+            ...(action.notifyChannel ? { channel: action.notifyChannel } : {}),
         });
-        try {
-            await execFileAsync('openclaw', args);
-            return { kind: 'notify', ok: true };
-        }
-        catch (err) {
-            return { kind: 'notify', ok: false, error: err.message };
-        }
+        return { kind: 'notify', ok: result.ok, ...(result.ok ? {} : { error: result.error }) };
     }
     // webhook-out
     if (!action.url)

package/dist/lib/notify.d.ts

@@ -1,9 +1,29 @@
+/**
+ * Owner notifier — the one seam for "ping the human" messages.
+ *
+ * Every human-facing owner notification (feed urgent-block dispatch, monitor
+ * `notify` action, `agents notify`) funnels through the single channel seam:
+ * `lookupTransport(channel, meta).provider.send(text, opts)`. The recipient comes
+ * from `notify.owner` in agents.yaml — never a hardcoded chat id — so changing the
+ * owner is honoured by every path at once. `notify.transports` picks the actual
+ * provider per host (rush telegram on zion, openclaw-telegram on mac-mini).
+ * Best-effort: a delivery failure is returned to the caller, never thrown, so a
+ * notification hiccup never blocks the agent. That is why this module resolves
+ * with `lookupTransport` and not the `die()`-capable `resolveTransport` — the
+ * monitor daemon and the feed-dispatch loop call in here, and `process.exit()`
+ * would take them down on a typo'd channel name, bypassing their try/catch.
+ */
 import type { OpenBlock } from './feed.js';
-export interface NotifyOptions {
+import type { Meta } from './types.js';
+import type { SendResult } from './channels/registry.js';
+export interface OwnerNotifyOptions {
+    /** Config source (defaults to `readMeta()`); lets callers/tests inject it. */
+    meta?: Meta;
+    /** Override the owner channel from `notify.owner.channel`. */
     channel?: string;
-    account?: string;
-    /** OpenClaw destination (Telegram chat id). Defaults to Muqsit's chat. */
+    /** Override the owner target from `notify.owner.to`. */
     target?: string;
+    /** Resolve + build the delivery but do not actually send. */
     dryRun?: boolean;
 }
 export interface NotifyResult {
@@ -12,6 +32,22 @@ export interface NotifyResult {
     error?: string;
 }
 export declare function formatUrgentBlockMessage(block: OpenBlock): string;
-/** Build openclaw argv for urgent notify (exported for tests). */
-export declare function buildOpenClawNotifyArgs(text: string, options?: Pick<NotifyOptions, 'channel' | 'account' | 'target'>): string[];
-export declare function notifyUrgentBlock(block: OpenBlock, options?: NotifyOptions): Promise<NotifyResult>;
+/**
+ * Build openclaw argv for a Telegram send (used by the openclaw-telegram
+ * provider and its tests). `target` is required — the recipient is always
+ * resolved by the caller, never defaulted to a hardcoded number here.
+ */
+export declare function buildOpenClawNotifyArgs(text: string, opts: {
+    target: string;
+    channel?: string;
+    account?: string;
+}): string[];
+/**
+ * Deliver a message to the configured owner through the one channel seam.
+ * `channel`/`target` default to `notify.owner.{channel,to}`; `notify.transports`
+ * selects the provider per host. A missing owner config or a delivery failure
+ * (e.g. openclaw not on PATH) returns a clean `SendResult` error — never a raw
+ * ENOENT — so callers surface a consistent, best-effort failure.
+ */
+export declare function sendToOwner(text: string, options?: OwnerNotifyOptions): Promise<SendResult>;
+export declare function notifyUrgentBlock(block: OpenBlock, options?: OwnerNotifyOptions): Promise<NotifyResult>;

package/dist/lib/notify.js

@@ -1,14 +1,6 @@
-/**
- * Urgent-block phone notifier.
- *
- * Reuses the OpenClaw Telegram gateway on the local mac-mini (Jeff/`default` bot)
- * instead of raw bot tokens. Notifies once per block (tracked by `notifiedAt`).
- * Best-effort: any openclaw failure is surfaced as a warning, not a hard error,
- * so a notification hiccup never blocks the agent.
- */
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-const execFileAsync = promisify(execFile);
+import { readMeta } from './state.js';
+import { registerBuiltinProviders } from './channels/providers/index.js';
+import { lookupTransport } from './channels/resolve.js';
 export function formatUrgentBlockMessage(block) {
     const q = block.questions[0];
     const header = q?.header ? `[${q.header}] ` : '';
@@ -18,11 +10,14 @@ export function formatUrgentBlockMessage(block) {
     const cost = block.costOfDelay ?? 'low';
     return `URGENT ${cls.toUpperCase()}${host}: ${header}${text} (cost: ${cost}, id: ${block.blockId})`;
 }
-/** Build openclaw argv for urgent notify (exported for tests). */
-export function buildOpenClawNotifyArgs(text, options = {}) {
-    const channel = options.channel ?? 'telegram';
-    const account = options.account ?? 'default';
-    const target = options.target ?? '6078999250';
+/**
+ * Build openclaw argv for a Telegram send (used by the openclaw-telegram
+ * provider and its tests). `target` is required — the recipient is always
+ * resolved by the caller, never defaulted to a hardcoded number here.
+ */
+export function buildOpenClawNotifyArgs(text, opts) {
+    const channel = opts.channel ?? 'telegram';
+    const account = opts.account ?? 'default';
     return [
         'message',
         'send',
@@ -31,11 +26,38 @@ export function buildOpenClawNotifyArgs(text, options = {}) {
         '--account',
         account,
         '--target',
-        target,
+        opts.target,
         '--message',
         text,
     ];
 }
+/**
+ * Deliver a message to the configured owner through the one channel seam.
+ * `channel`/`target` default to `notify.owner.{channel,to}`; `notify.transports`
+ * selects the provider per host. A missing owner config or a delivery failure
+ * (e.g. openclaw not on PATH) returns a clean `SendResult` error — never a raw
+ * ENOENT — so callers surface a consistent, best-effort failure.
+ */
+export async function sendToOwner(text, options = {}) {
+    const meta = options.meta ?? readMeta();
+    const owner = meta.notify?.owner;
+    const channel = options.channel ?? owner?.channel;
+    const target = options.target ?? owner?.to;
+    if (!channel || !target) {
+        return {
+            ok: false,
+            channel: channel ?? 'unknown',
+            id: target ?? '',
+            error: 'notify.owner.{channel,to} not set in agents.yaml',
+        };
+    }
+    registerBuiltinProviders();
+    const { provider, error } = lookupTransport(channel, meta);
+    if (!provider) {
+        return { ok: false, channel, id: target, error };
+    }
+    return provider.send(text, { target, dryRun: options.dryRun });
+}
 export async function notifyUrgentBlock(block, options = {}) {
     if (block.notifiedAt) {
         return { ok: true, skipped: true };
@@ -43,19 +65,6 @@ export async function notifyUrgentBlock(block, options = {}) {
     if (options.dryRun) {
         return { ok: true, skipped: true };
     }
-    // Check that openclaw is installed.
-    try {
-        await execFileAsync('which', ['openclaw']);
-    }
-    catch {
-        return { ok: false, error: 'openclaw CLI not found on PATH' };
-    }
-    const text = formatUrgentBlockMessage(block);
-    try {
-        await execFileAsync('openclaw', buildOpenClawNotifyArgs(text, options));
-        return { ok: true };
-    }
-    catch (err) {
-        return { ok: false, error: err.message };
-    }
+    const result = await sendToOwner(formatUrgentBlockMessage(block), options);
+    return result.ok ? { ok: true } : { ok: false, error: result.error };
 }

package/dist/lib/types.d.ts

@@ -284,6 +284,12 @@ export type HookCache = string | HookCacheConfig;
 export interface ManifestHook {
     script: string;
     events: string[];
+    /**
+     * Seconds before the hook is killed (default 600). In agents.yaml this may be
+     * written as a bare number (seconds) or a duration string (`5s`, `2m`,
+     * `1h30m`); `parseHookManifest` normalizes it to a seconds number here, so
+     * consumers always see a number.
+     */
     timeout?: number;
     matcher?: string;
     /** @deprecated Use the agent capability table; field is ignored. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.21.0",
+  "version": "1.21.1",
   "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",