@phnx-labs/agents-cli 1.20.93 → 1.21.1

package/dist/commands/sync.d.ts

@@ -2,8 +2,8 @@
  * `agents sync` — synchronize central resources into an installed agent version.
  *
  * Forms:
- *   agents sync                                         # umbrella: fetch config repos -> reconcile all (secrets/sessions opt-in)
- *   agents sync --repos|--secrets|--sessions            # umbrella: fetch only those, then reconcile
+ *   agents sync                                         # umbrella: fetch config repos -> reconcile all (secrets opt-in)
+ *   agents sync --repos|--secrets                       # umbrella: fetch only those, then reconcile
  *   agents sync --cloud                                 # umbrella: fetch all, skip reconcile
  *   agents sync --local                                 # umbrella: reconcile all, no fetch
  *   agents sync system                                  # one repo: git pull --rebase (pull-only mirror)

package/dist/commands/sync.js

@@ -2,8 +2,8 @@
  * `agents sync` — synchronize central resources into an installed agent version.
  *
  * Forms:
- *   agents sync                                         # umbrella: fetch config repos -> reconcile all (secrets/sessions opt-in)
- *   agents sync --repos|--secrets|--sessions            # umbrella: fetch only those, then reconcile
+ *   agents sync                                         # umbrella: fetch config repos -> reconcile all (secrets opt-in)
+ *   agents sync --repos|--secrets                       # umbrella: fetch only those, then reconcile
  *   agents sync --cloud                                 # umbrella: fetch all, skip reconcile
  *   agents sync --local                                 # umbrella: reconcile all, no fetch
  *   agents sync system                                  # one repo: git pull --rebase (pull-only mirror)
@@ -47,7 +47,7 @@ import { getSystemAgentsDir, getUserAgentsDir, getEnabledExtraRepos } from '../l
 export function registerSyncCommand(program) {
     addHostOption(program.command('sync [agentSpec] [repo]'))
         .summary('Make this machine current, or sync resources into one agent')
-        .description('With an [agentSpec], syncs resources (commands, skills, hooks, rules, MCPs, plugins, etc.) into that installed agent version — previews changes and lets you pick. e.g. "claude", "claude@2.1.142", a selector: @latest / @oldest / @pinned (= @default), or @all for every installed version.\n\nAppend a [repo] (or pass --repo) to scope the sync to a single DotAgent repo — system / user / project / <alias>. e.g. "agents sync claude@all system" reconciles only the system repo\'s resources into every installed Claude.\n\nGive a DotAgent repo name ALONE — "agents sync system" / "agents sync user" / "agents sync <alias>" — to git-sync that one repo: refuse if the tree is dirty, else git pull --rebase against origin. The user repo and extra aliases also push local commits up; the system repo is a pull-only mirror.\n\nWith NO agent, runs the umbrella verb: fetch the config repos then reconcile them into every installed agent. Secrets and sessions are opt-in — add --secrets to pull secret bundles or --sessions to sync transcripts (sessions are also queryable live via "agents sessions --host <machine>"). Also: --cloud (fetch only), --local (reconcile only).')
+        .description('With an [agentSpec], syncs resources (commands, skills, hooks, rules, MCPs, plugins, etc.) into that installed agent version — previews changes and lets you pick. e.g. "claude", "claude@2.1.142", a selector: @latest / @oldest / @pinned (= @default), or @all for every installed version.\n\nAppend a [repo] (or pass --repo) to scope the sync to a single DotAgent repo — system / user / project / <alias>. e.g. "agents sync claude@all system" reconciles only the system repo\'s resources into every installed Claude.\n\nGive a DotAgent repo name ALONE — "agents sync system" / "agents sync user" / "agents sync <alias>" — to git-sync that one repo: refuse if the tree is dirty, else git pull --rebase against origin. The user repo and extra aliases also push local commits up; the system repo is a pull-only mirror.\n\nWith NO agent, runs the umbrella verb: fetch the config repos then reconcile them into every installed agent. Secrets are opt-in — add --secrets to pull secret bundles. Session transcripts are queryable live via "agents sessions --host <machine>", or moved with "agents sessions export/import". Also: --cloud (fetch only), --local (reconcile only).')
         .option('--agent <agent>', 'Agent identifier (legacy form; prefer the positional spec)')
         .option('--agent-version <version>', 'Version to sync into (legacy form; prefer "agent@version")')
         .option('--repo <name>', 'Scope the sync to a single DotAgent repo: system / user / project / <alias> (also accepted as a positional)')
@@ -60,7 +60,6 @@ export function registerSyncCommand(program) {
         // Umbrella verb (no agent given): make this machine current.
         .option('--repos', 'Umbrella: git-pull ~/.agents + enabled ~/.agents-* extras', false)
         .option('--secrets', 'Umbrella: pull encrypted secret bundles from the remote', false)
-        .option('--sessions', 'Umbrella: sync session transcripts across machines', false)
         .option('--cloud', 'Umbrella: fetch all remote state but skip the local reconcile', false)
         .option('--local', "Umbrella: reconcile resources into installed agents only (no fetch)", false)
         .action(async (agentSpec, repo, opts) => {
@@ -206,7 +205,7 @@ async function runUmbrella(opts, quiet, outLog, errLog) {
     // Interactive bare `agents sync` (a TTY, no --yes, no scope flag) drops into
     // the two-checklist picker: which repos to sync from, which agents to sync
     // into. Any explicit flag or --yes keeps the non-interactive umbrella below.
-    const anyExplicitFlag = !!(opts.repos || opts.secrets || opts.sessions || opts.cloud || opts.local);
+    const anyExplicitFlag = !!(opts.repos || opts.secrets || opts.cloud || opts.local);
     if (!quiet && !opts.yes && !anyExplicitFlag && isInteractiveTerminal()) {
         await runInteractiveReconcile(opts, outLog, errLog);
         return;
@@ -214,7 +213,6 @@ async function runUmbrella(opts, quiet, outLog, errLog) {
     const flags = {
         repos: opts.repos,
         secrets: opts.secrets,
-        sessions: opts.sessions,
         cloud: opts.cloud,
         local: opts.local,
     };
@@ -238,9 +236,6 @@ async function runUmbrella(opts, quiet, outLog, errLog) {
             if (result.secrets) {
                 parts.push(result.secrets.skipped ? 'secrets skipped' : `secrets ${result.secrets.pulled} pulled`);
             }
-            if (result.sessions) {
-                parts.push(result.sessions.ran ? `sessions ${result.sessions.merged} merged` : 'sessions off');
-            }
             if (result.reconciled)
                 parts.push('reconciled');
             outLog(chalk.green(`✓ sync: ${parts.join(' · ') || 'nothing to do'}`));

package/dist/commands/watchdog.js

@@ -24,6 +24,9 @@ import { setHelpSections } from '../lib/help.js';
 import { parseDuration } from '../lib/hooks/cache.js';
 import { getRuntimeStateDir } from '../lib/state.js';
 import { setJobEnabled } from '../lib/routines.js';
+import { getActiveSessions } from '../lib/session/active.js';
+import { mailboxIdForActiveSession } from '../lib/mailbox-target.js';
+import { gcMailbox } from '../lib/mailbox-gc.js';
 import { ensureWatchdogRoutine, isWatchdogRoutineEnabled, watchdogRoutineExists, WATCHDOG_ROUTINE_NAME, WATCHDOG_ROUTINE_SCHEDULE, } from '../lib/watchdog/routine.js';
 import { runWatchdogTick, writePolicySentinel, DEFAULT_THRESHOLDS, } from '../lib/watchdog/runner.js';
 /** Default state dir the runner and these subcommands share. */
@@ -58,6 +61,21 @@ function humanMs(ms) {
         return `${Math.round(ms / 60_000)}m`;
     return `${Math.round(ms / 1000)}s`;
 }
+/**
+ * Run the mailbox liveness sweep against the same session set the tick just used.
+ * Idempotent and cheap: archiving a message twice is a no-op, and GC only scans
+ * directories. Failures are swallowed so a mailbox-root problem cannot break the
+ * watchdog tick.
+ */
+async function runMailboxGc(sessions) {
+    const activeBoxIds = new Set(sessions.map(mailboxIdForActiveSession).filter((id) => !!id));
+    try {
+        gcMailbox(activeBoxIds);
+    }
+    catch {
+        // GC is best-effort housekeeping; the next tick will retry.
+    }
+}
 function colorForOutcome(o) {
     if (o.injected)
         return chalk.green;
@@ -118,7 +136,7 @@ export function registerWatchdogCommand(program) {
         // path is the daemon routine, which runs `agents watchdog --nudge` — so the
         // routine's enabled state IS the on/off switch, not a flag read here.
         const computeWillInject = () => opts.nudge === true;
-        const tickOnce = async (willInject) => runWatchdogTick({
+        const tickOnce = async (willInject, sessions) => runWatchdogTick({
             nudge: willInject,
             nudgeText: opts.text,
             smart: opts.smart === true,
@@ -126,10 +144,13 @@ export function registerWatchdogCommand(program) {
             thresholds,
             allowGhosttyFocus: opts.allowGhosttyFocus === true,
             stateDir: stateDir(),
+            sessions,
         });
         if (!opts.watch) {
             const willInject = computeWillInject();
-            const result = await tickOnce(willInject);
+            const sessions = await getActiveSessions();
+            const result = await tickOnce(willInject, sessions);
+            await runMailboxGc(sessions);
             if (opts.json)
                 console.log(JSON.stringify(result, null, 2));
             else
@@ -146,7 +167,9 @@ export function registerWatchdogCommand(program) {
         while (true) {
             // Re-evaluated each tick: picks up enable/disable flips mid-run.
             const willInject = computeWillInject();
-            const result = await tickOnce(willInject);
+            const sessions = await getActiveSessions();
+            const result = await tickOnce(willInject, sessions);
+            await runMailboxGc(sessions);
             if (opts.json)
                 console.log(JSON.stringify(result));
             else

package/dist/index.js

@@ -94,11 +94,12 @@ if (IS_DEV_BUILD) {
 // module on each invocation (which loaded the whole ~50-module tree before the
 // first byte of output), the registry maps a command name to a thunk that
 // imports only what that command needs. See src/lib/startup/command-registry.ts.
-import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadDrive, loadFactory, loadUsage, loadCost, loadPerf, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadHq, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
+import { COMMAND_LOADERS, LAZY_COMMAND_NAMES, loadView, loadInspect, loadFeedback, loadCommands, loadHooks, loadSkills, loadRules, loadMemory, loadPermissions, loadMcp, loadCli, loadSubagents, loadPlugins, loadWorkflows, loadWorktree, loadVersions, loadImport, loadExport, loadPackages, loadRoutines, loadMonitors, loadProjects, loadRun, loadFork, loadDefaults, loadSet, loadModels, loadPrune, loadTrash, loadRestore, loadDoctor, loadApply, loadStatus, loadProfiles, loadHarness, loadSecrets, loadLogin, loadWallet, loadHelper, loadMenubar, loadBeta, loadSync, loadLock, loadRefreshRules, loadFactory, loadUsage, loadCost, loadPerf, loadOutput, loadBudget, loadAlias, loadMine, loadPty, loadTmux, loadWatchdog, loadBrowser, loadComputer, loadHosts, loadLogs, loadEvents, loadAudit, loadWebhook, loadFunnel, loadSsh, loadPull, loadPush, loadRepo, loadSetup, loadUninstall, loadShare, loadSend, loadFeed, loadActivity, loadMailboxes, } from './lib/startup/command-registry.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { renderWhatsNew } from './lib/whats-new.js';
 import { getCliLaunch } from './lib/cli-entry.js';
 import { emit, emitFriction, redactArgs } from './lib/events.js';
+import { die } from './lib/format.js';
 // Transparent shim delegate: the generated Windows `.cmd` shims invoke
 // `agents __shim <agent>[@version] <raw args>`. Intercept here, before commander
 // parses anything, so the agent's own flags (`--help`, `--version`, etc.) pass
@@ -281,7 +282,6 @@ Run and dispatch:
   run <agent|profile> [prompt]    Run an agent. Omit prompt for interactive mode.
   defaults                        Configure run defaults by agent/version selector
   teams                           Coordinate multiple agents on shared work
-  hq                              JSON bridge for the interactive Agents HQ floor
   routines                        Run agents on a cron schedule (scheduler auto-starts)
   webhook                         Receive signed GitHub/Linear webhooks for trigger routines
   funnel                          Expose a webhook receiver through Tailscale Funnel
@@ -301,14 +301,13 @@ Diagnostics:
   perf                            Latency rollups (hooks, commands, runs) from the disposable perf warehouse
 
 Config sync:
-  drive                           Sync session history across machines via rsync
   pull                            Clone or pull the system repo at ~/.agents/.system/
   repo init --path <dir>          Scaffold your own editable repo from a template
   repo add <path|gh:user/repo>    Merge an extra repo after the system repo
   lock [--frozen]                 Write/verify agents.lock (SHA-256 of resolved resources); --frozen fails on drift
 
 Beta features:
-  beta                            Enable preview features (factory, drive, and more)
+  beta                            Enable preview features (factory and more)
 
 Automation tips:
   Pass explicit names/IDs         Avoid pickers: agents sessions <id> --markdown
@@ -721,6 +720,21 @@ function registerResourcesTombstoneCommand(p) {
         await program.parseAsync(['node', 'agents', ...args]);
     });
 }
+/**
+ * Removed `hq` command — the JSON bridge for the interactive Agents HQ floor
+ * (`agents hq floor --json`). No UI ever consumed it (apps/factory has zero
+ * references) and it had no external users, so it is gone with no replacement.
+ * Kept as a hidden tombstone so a stale invocation gets a clear message and a
+ * non-zero exit instead of commander's raw "unknown command".
+ */
+function registerHqTombstoneCommand(p) {
+    p.command('hq', { hidden: true })
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(() => {
+        die('"agents hq" was removed (internal Agents HQ floor bridge, no longer used).');
+    });
+}
 /**
  * Hidden `agents _internal <sub>` namespace for machine-to-machine calls that
  * are not user-facing. The first subcommand is `friction`, used by shell guard
@@ -840,6 +854,9 @@ async function registerEagerForRequest(name) {
             registerResourcesTombstoneCommand(program);
             await reg(loadView);
             return true;
+        case 'hq':
+            registerHqTombstoneCommand(program);
+            return true;
         case '_internal':
             registerInternalCommand(program);
             return true;
@@ -912,7 +929,6 @@ async function registerAllEagerCommands() {
     await reg(loadSync);
     await reg(loadLock);
     await reg(loadRefreshRules);
-    await reg(loadDrive);
     await reg(loadFactory);
     await reg(loadUsage);
     await reg(loadCost);
@@ -932,7 +948,7 @@ async function registerAllEagerCommands() {
     await reg(loadAudit);
     await reg(loadWebhook);
     await reg(loadFunnel);
-    await reg(loadHq);
+    registerHqTombstoneCommand(program);
     await reg(loadFeed);
     await reg(loadActivity);
     await reg(loadMailboxes);

package/dist/lib/activity.d.ts

@@ -1,3 +1,4 @@
+import type { ActorKind } from './actor.js';
 import type { EventRecord } from './events.js';
 /** Recognizable milestone events, ordered first in any activity lane. */
 export type MilestoneEvent = 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created'
@@ -80,16 +81,28 @@ export interface ActivityEvent {
     project?: string;
     /** Agent that produced the event (claude, codex, ...). */
     agent?: string;
+    /** Resolved actor id shared with the operational event stream. */
+    actor?: string;
+    /** Resolved actor kind shared with the operational event stream. */
+    kind?: ActorKind | 'unknown';
     /** Tool that triggered the event (Bash, Task, ExitPlanMode, feed.post, ...). */
     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). */
     pid?: number;
     /** Spawn-time join key (`AGENT_LAUNCH_ID`) when known. */
     launchId?: string;
+    /** Session that spawned this session (`AGENTS_PARENT_SESSION_ID`) when known. */
+    parentSessionId?: string;
     /** Factory terminal id when the launch inherited one. */
     terminalId?: string;
     /** `$TMUX_PANE` at launch when recorded. */

package/dist/lib/activity.js

@@ -25,6 +25,7 @@ import { relTime, truncate } from './format.js';
 import { getActivityDir, getUserAgentsDir } from './state.js';
 import { normalizeHost } from './machine-id.js';
 import { projectKeyFromCwd } from './project-key.js';
+import { stampProvenance } from './event-provenance.js';
 /** The set of milestone events, for tier classification and ordering. */
 export const MILESTONE_EVENTS = [
     'plan.created',
@@ -109,6 +110,7 @@ export function appendActivityEvent(event, root) {
     const dir = root ?? getActivityDir();
     fs.mkdirSync(dir, { recursive: true });
     const record = {
+        ...stampProvenance(),
         v: event.v ?? 1,
         tier: event.tier ?? tierForEvent(event.event),
         ...event,
@@ -135,11 +137,15 @@ function parseLine(line) {
             cwd: parsed.cwd,
             project: parsed.project,
             agent: parsed.agent,
+            actor: parsed.actor,
+            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,
+            parentSessionId: parsed.parentSessionId,
             terminalId: parsed.terminalId,
             tmuxPane: parsed.tmuxPane,
             category: typeof parsed.category === 'string' ? parsed.category : undefined,
@@ -268,10 +274,12 @@ export function activityEventToRecord(ev) {
         level: 'info',
         caller: ev.tool === 'feed.post' ? 'agent' : 'hook',
         session: ev.sessionId,
-        osUser: ev.agent ?? 'agent',
+        osUser: 'unknown',
         transport: 'local',
         // payload
         agent: ev.agent,
+        actor: ev.actor ?? 'unknown',
+        kind: ev.kind ?? 'unknown',
         sessionId: ev.sessionId,
         cwd: ev.cwd,
         module: 'activity',
@@ -281,6 +289,7 @@ export function activityEventToRecord(ev) {
         tier: ev.tier,
         ...(ev.project ? { project: ev.project } : {}),
         ...(ev.launchId ? { launchId: ev.launchId } : {}),
+        ...(ev.parentSessionId ? { parentSessionId: ev.parentSessionId } : {}),
         ...(ev.terminalId ? { terminalId: ev.terminalId } : {}),
         ...(ev.tmuxPane ? { tmuxPane: ev.tmuxPane } : {}),
         ...(ev.attachments?.length ? { attachments: ev.attachments } : {}),
@@ -390,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) {
@@ -1521,8 +1532,17 @@ def main():
         cwd = payload.get("cwd") or os.environ.get("AGENTS_CWD")
         if cwd:
             record["cwd"] = cwd
-        agent = os.environ.get("AGENTS_AGENT_NAME") or "claude"
+        agent = os.environ.get("AGENTS_AGENT_NAME") or "unknown"
         record["agent"] = agent
+        record["actor"] = os.environ.get("AGENTS_ACTOR") or "unknown"
+        actor_kind = os.environ.get("AGENTS_ACTOR_KIND")
+        record["kind"] = actor_kind if actor_kind in ("human", "agent") else "unknown"
+        launch_id = os.environ.get("AGENT_LAUNCH_ID")
+        if launch_id:
+            record["launchId"] = launch_id
+        parent_session_id = os.environ.get("AGENTS_PARENT_SESSION_ID")
+        if parent_session_id:
+            record["parentSessionId"] = parent_session_id
 
     try:
         os.makedirs(activity_dir, exist_ok=True)

package/dist/lib/auto-dispatch.d.ts

@@ -43,7 +43,12 @@ export interface PlannedDispatch {
     title: string;
     delegateName: string;
 }
-/** Path to the shared factory project registry (written by the factory UI). */
+/**
+ * Path to the shared factory project registry (written by the factory UI).
+ * `AGENTS_FACTORY_PROJECTS_PATH` overrides it, mirroring `AGENTS_PROJECTS_DIR`
+ * (`state.ts`) — that seam is what lets `projects import --from-factory` be
+ * tested end-to-end against a real fixture file instead of a mock.
+ */
 export declare function factoryProjectsPath(): string;
 /** Read the project registry rows this module cares about. */
 export declare function readAutoDispatchProjects(): AutoDispatchProject[];

package/dist/lib/auto-dispatch.js

@@ -16,9 +16,14 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { homedir } from 'os';
-/** Path to the shared factory project registry (written by the factory UI). */
+/**
+ * Path to the shared factory project registry (written by the factory UI).
+ * `AGENTS_FACTORY_PROJECTS_PATH` overrides it, mirroring `AGENTS_PROJECTS_DIR`
+ * (`state.ts`) — that seam is what lets `projects import --from-factory` be
+ * tested end-to-end against a real fixture file instead of a mock.
+ */
 export function factoryProjectsPath() {
-    return path.join(homedir(), '.agents', 'factory', 'projects.json');
+    return process.env.AGENTS_FACTORY_PROJECTS_PATH ?? path.join(homedir(), '.agents', 'factory', 'projects.json');
 }
 /** Read the project registry rows this module cares about. */
 export function readAutoDispatchProjects() {

package/dist/lib/beta.d.ts

@@ -8,7 +8,7 @@
  * checks.
  */
 import type { BetaFeatureName } from './types.js';
-export declare const ALL_BETA_FEATURES: readonly ["drive", "factory", "session-sync", "projects"];
+export declare const ALL_BETA_FEATURES: readonly ["factory", "projects"];
 export declare function getEnabledBetaFeatures(): BetaFeatureName[];
 export declare function isBetaEnabled(feature: BetaFeatureName): boolean;
 export declare function getBetaConfigLocation(): {

package/dist/lib/beta.js

@@ -10,7 +10,7 @@
 import * as path from 'path';
 import { getAgentsDir, getOptionalUserAgentsDir, readMeta, writeMeta } from './state.js';
 import { readManifest, writeManifest } from './manifest.js';
-export const ALL_BETA_FEATURES = ['drive', 'factory', 'session-sync', 'projects'];
+export const ALL_BETA_FEATURES = ['factory', 'projects'];
 function isBetaFeatureName(value) {
     return typeof value === 'string' && ALL_BETA_FEATURES.includes(value);
 }

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/daemon.d.ts

@@ -16,6 +16,19 @@ import { getAgentsBinPath } from './cli-entry.js';
  * broker is hosting, and never clobber a reachable (healthy) broker.
  */
 export declare function shouldTakeOverBroker(isHosting: boolean, brokerReachable: boolean): boolean;
+/**
+ * What a gate re-evaluation must do with the routines scheduler. The daemon
+ * re-evaluates `scheduler.enabled` on every SIGHUP reload so flipping the key
+ * takes effect without a daemon restart (and `routines add`'s reload signal on
+ * a re-enabled box boots the scheduler — the reload is truthful, not a no-op).
+ *
+ *   running + enabled   → reload (the normal SIGHUP path)
+ *   running + !enabled  → stop  (gate flipped off since boot)
+ *   !running + enabled  → boot  (gate flipped on since boot)
+ *   !running + !enabled → none  (stay dark)
+ */
+export type SchedulerGateTransition = 'reload' | 'stop' | 'boot' | 'none';
+export declare function schedulerGateTransition(running: boolean, enabled: boolean): SchedulerGateTransition;
 /** Read the stored daemon PID from disk. Returns null if not present or invalid. */
 export declare function readDaemonPid(): number | null;
 /** Write the daemon PID to the pid file. */