@pellux/goodvibes-agent 0.1.39 → 0.1.41

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.41 - 2026-05-31
+
+- c108e13 Add live daemon capability audit
+
+## 0.1.40 - 2026-05-31
+
+- 329dc13 Add routine schedule delivery targets
+
 ## 0.1.39 - 2026-05-31
 
 - c98de19 Add routine schedule reconciliation

package/README.md

@@ -16,6 +16,7 @@ bun add -g @pellux/goodvibes-agent
 goodvibes-agent --help
 goodvibes-agent status
 goodvibes-agent capabilities
+goodvibes-agent capabilities daemon
 ```
 
 If Bun reports untrusted lifecycle dependencies, trust only the package and dependencies required by this package:
@@ -44,7 +45,7 @@ bun run publish:check
 
 Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator workspace. It is the Agent-first fullscreen surface for setup, status, knowledge, local memory/skills, work-plan/approval review, automation observability, and explicit build delegation to GoodVibes TUI.
 
-Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps.
+Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps. Use `goodvibes-agent capabilities daemon` or `/capabilities daemon` for a live read-only audit of the GoodVibes daemon method catalog and isolated Agent Knowledge route coverage.
 
 Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated runtime profiles from them.
 
@@ -68,19 +69,28 @@ Local Agent behavior is editable from the TUI:
 /personas use research
 /routines create --name "Evening Review" --description "Review open work before shutdown" --steps "Check work plan, approvals, and Agent Knowledge status before summarizing." --enabled true
 /routines start evening-review
-/schedule promote-routine evening-review --cron "0 17 * * 1-5" --timezone America/Chicago --yes
+/schedule promote-routine evening-review --cron "0 17 * * 1-5" --timezone America/Chicago --delivery-surface slack --yes
 /schedule receipts
 /schedule reconcile
 /agent-skills create --name "Morning Brief" --description "Daily briefing flow" --procedure "Check tasks, approvals, calendar, and unread state before summarizing." --enabled true
 /skills local list
 ```
 
-Starting a routine records local usage and prints its steps; it does not spawn background agents or daemon automation jobs. Promotion to a daemon schedule is separate and explicit: it calls the public `schedules.create` route on the externally managed daemon only after `--yes`, records a redacted local receipt, and the generated scheduled prompt keeps Agent Knowledge isolated from default Knowledge/Wiki and HomeGraph. Use `/schedule reconcile` to compare those local receipts against live externally owned daemon schedules through public `schedules.list`.
+Starting a routine records local usage and prints its steps; it does not spawn background agents or daemon automation jobs. Promotion to a daemon schedule is separate and explicit: it calls the public `schedules.create` route on the externally managed daemon only after `--yes`, can include explicit delivery targets such as `--delivery-surface slack`, records a redacted local receipt, and the generated scheduled prompt keeps Agent Knowledge isolated from default Knowledge/Wiki and HomeGraph. Use `/schedule reconcile` to compare those local receipts against live externally owned daemon schedules through public `schedules.list`.
 
 ## Daemon Prerequisite
 
 Start or restart the daemon from GoodVibes TUI or the daemon host before launching Agent. Agent status and companion/knowledge routes connect to that external daemon, normally on `http://127.0.0.1:3421`.
 
+To verify what the running daemon can expose for the Agent/OpenClaw/Hermes capability benchmark:
+
+```sh
+goodvibes-agent capabilities daemon
+goodvibes-agent capabilities daemon --json
+```
+
+This audit checks `/api/control-plane/methods` and `/api/goodvibes-agent/knowledge/status`. It does not query default Knowledge/Wiki or HomeGraph.
+
 Agent intentionally blocks daemon lifecycle commands:
 
 ```sh

package/docs/operator-capability-benchmark.md

@@ -15,6 +15,9 @@ Use the live benchmark from the package:
 goodvibes-agent capabilities
 goodvibes-agent capabilities --json
 goodvibes-agent capabilities hermes
+goodvibes-agent capabilities daemon
+goodvibes-agent capabilities daemon --json
+goodvibes-agent capabilities daemon knowledge
 ```
 
 Inside the TUI:
@@ -23,6 +26,7 @@ Inside the TUI:
 /capabilities
 /capabilities openclaw
 /capabilities knowledge
+/capabilities daemon
 ```
 
 ## Research Baseline
@@ -43,19 +47,29 @@ Primary sources used for the benchmark:
 - Hermes Voice: https://hermes-agent.nousresearch.com/docs/user-guide/features/voice-mode/
 - Hermes API Server: https://hermes-agent.nousresearch.com/docs/user-guide/features/api-server/
 - Hermes Profiles: https://hermes-agent.nousresearch.com/docs/user-guide/profiles/
+- GoodVibes daemon: `@pellux/goodvibes-sdk@0.33.35` public operator contract plus `/api/goodvibes-agent/knowledge/*`
+
+The benchmark measures two different GoodVibes layers:
+
+- daemon capability: what the externally owned GoodVibes daemon can already expose through public operator routes;
+- Agent usability: what GoodVibes Agent makes configurable, visible, safe, and usable from day one.
+
+If the daemon already has a route but Agent lacks a good setup/workspace/CLI surface, the gap is treated as an Agent product gap rather than a missing platform capability.
+
+Use `goodvibes-agent capabilities daemon` for the live read-only daemon audit. It checks the public control-plane method catalog and the isolated Agent Knowledge status route. It intentionally does not call default `/api/knowledge/*`, HomeGraph, or Home Assistant routes.
 
 ## Capability Targets
 
 | Area | OpenClaw/Hermes Baseline | GoodVibes Agent Position |
 | --- | --- | --- |
 | Terminal operator UI | Interactive CLI/TUI, commands, sessions | Near-fork GoodVibes TUI compositor/input/fullscreen foundation |
-| Always-on gateway | Gateway/service owns channels, sessions, tools, events | External GoodVibes daemon, never Agent-owned lifecycle |
+| Always-on gateway | Gateway/service owns channels, sessions, tools, events | External GoodVibes daemon exposes sessions, companion chat, channels, remote peers, approvals, automation, schedules, artifacts, MCP, providers, voice, media, web search, and isolated Agent Knowledge; Agent never owns daemon lifecycle |
 | Channels | WhatsApp, Telegram, Slack, Discord, Signal, iMessage, web chat | GoodVibes daemon channel and companion surfaces with Agent-side policy, a Channels operator workspace, and per-channel readiness/risk labels |
-| Knowledge/memory | Durable memory, semantic search, wiki/claim layers | Isolated Agent Knowledge routes with workspace ask/search/ingest/review flows plus local memory/skills/personas/routines |
+| Knowledge/memory | Durable memory, semantic search, wiki/claim layers | Isolated `/api/goodvibes-agent/knowledge/*` routes with workspace ask/search/ingest/review flows plus local memory/skills/personas/routines |
 | Skills/procedural memory | Skills directories, registries, skill lifecycle | Local Agent skills with review/stale/source/provenance fields |
-| Scheduling | Natural-language cron, run/pause/resume/edit/remove, delivery | Local routines can be explicitly promoted to external daemon `schedules.create` with `--yes`; redacted local promotion receipts are reviewable and can be reconciled with live `schedules.list`; hidden model scheduling and local scheduler spawns are blocked |
-| Tools/MCP | Broad toolsets, MCP, browser, media, terminal, files | GoodVibes SDK tools with Agent policy guards and MCP/provider integrations |
-| Voice/media/canvas/nodes | Voice, TTS, mobile nodes, live canvas, browser automation | GoodVibes media/voice/browser/node primitives with an Agent workspace for setup, image input, browser posture, MCP, and remote/node inspection |
+| Scheduling | Natural-language cron, run/pause/resume/edit/remove, delivery | Local routines can be explicitly promoted to external daemon `schedules.create` with `--yes` and optional explicit delivery targets; redacted local promotion receipts are reviewable and can be reconciled with live `schedules.list`; hidden model scheduling and local scheduler spawns are blocked |
+| Tools/MCP | Broad toolsets, MCP, browser, media, terminal, files | GoodVibes daemon exposes MCP, artifacts, web search, providers, media, multimodal, and channel tool routes; Agent adds policy guards and operator setup surfaces |
+| Voice/media/canvas/nodes | Voice, TTS, mobile nodes, live canvas, browser automation | GoodVibes daemon exposes voice, media, multimodal, artifacts, and remote/node routes; Agent workspace makes setup and posture visible without daemon ownership |
 | Build/code work | Direct terminal/file/code tools and subagents | Explicit delegation to GoodVibes TUI; local WRFC/spawn fanout blocked |
 | Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; starter templates seed local personas/skills/routines; starter JSON can be exported/imported for local custom lanes; `/agent-profile guide` brings starter authoring into the Agent workspace; daemon remains external |
 | Security | DM pairing, approvals, sandboxing, allowlists | Daemon approvals, auth diagnostics, secret refs, confirmation gates, model-tool policy |
@@ -66,7 +80,7 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 
 - Capability surfaces are discoverable through `goodvibes-agent capabilities`, `/capabilities`, onboarding, and the operator workspace.
 - Agent Knowledge isolation is a release gate, not a convention.
-- Routine-to-schedule promotion preserves Agent Knowledge isolation and uses only public external daemon schedule routes.
+- Routine-to-schedule promotion preserves Agent Knowledge isolation, uses only public external daemon schedule routes, supports explicit delivery targets, and stores redacted receipts.
 - Model-visible tools are policy-gated for serial, non-secret, non-destructive use.
 - Personal assistant state is Agent-local unless an explicit Agent Knowledge ingest route is used.
 - Build work is delegated to the product that owns coding execution instead of turning the personal operator into a second coding TUI.
@@ -78,7 +92,7 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 - Artifact and multimodal Agent Knowledge ingest affordances once Agent-specific routes are stable.
 - Visual starter-template editing inside the fullscreen Agent workspace after the command-guided authoring path.
 - Artifact and multimodal Agent Knowledge ingestion when the isolated Agent route accepts artifact-backed media.
-- Live schedule recovery/status correlation for promoted routines.
+- Deeper live run/delivery history and delivery error surfacing for promoted routines.
 - Delegation receipts and artifact review inside the operator workspace.
 - Approval center with route risk labels and saved policy presets.
 - Intent-gated tool exposure so the model sees fewer irrelevant tools per turn while retaining broad capability coverage.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "private": false,
   "description": "Near-fork GoodVibes operator assistant with the GoodVibes TUI shell, renderer, input, fullscreen workspace, and daemon-connected Agent product brain.",
   "type": "module",

package/src/agent/routine-schedule-promotion.ts

@@ -17,6 +17,8 @@ export const ROUTINE_SCHEDULE_LIST_METHOD = 'schedules.list';
 type ScheduleCreateInput = OperatorMethodInput<'schedules.create'>;
 type ScheduleCreateOutput = OperatorMethodOutput<'schedules.create'>;
 type ScheduleListOutput = OperatorMethodOutput<'schedules.list'>;
+type ScheduleDeliveryInput = NonNullable<ScheduleCreateInput['delivery']>;
+type ScheduleDeliveryTargetInput = ScheduleDeliveryInput['targets'] extends readonly (infer T)[] ? T : never;
 
 export interface AgentDaemonConfigReader {
   get(key: string): unknown;
@@ -35,9 +37,46 @@ export interface RoutineScheduleSpec {
   readonly value: string;
 }
 
+export type RoutineScheduleDeliveryKind = 'webhook' | 'surface' | 'integration' | 'link';
+
+export type RoutineScheduleDeliverySurfaceKind =
+  | 'tui'
+  | 'web'
+  | 'slack'
+  | 'discord'
+  | 'ntfy'
+  | 'webhook'
+  | 'telegram'
+  | 'google-chat'
+  | 'signal'
+  | 'whatsapp'
+  | 'imessage'
+  | 'msteams'
+  | 'bluebubbles'
+  | 'mattermost'
+  | 'matrix'
+  | 'service';
+
+export interface RoutineScheduleDeliveryTargetSpec {
+  readonly kind: RoutineScheduleDeliveryKind;
+  readonly surfaceKind?: RoutineScheduleDeliverySurfaceKind;
+  readonly address?: string;
+  readonly routeId?: string;
+  readonly label?: string;
+}
+
+export interface RoutineScheduleReceiptDeliveryTarget {
+  readonly kind: RoutineScheduleDeliveryKind;
+  readonly surfaceKind?: RoutineScheduleDeliverySurfaceKind;
+  readonly address?: string;
+  readonly routeId?: string;
+  readonly label?: string;
+}
+
 export interface ParsedRoutineSchedulePromotionArgs {
   readonly routineId: string | null;
   readonly schedule: RoutineScheduleSpec | null;
+  readonly deliveryTargets: readonly RoutineScheduleDeliveryTargetSpec[];
   readonly name?: string;
   readonly timezone?: string;
   readonly provider?: string;
@@ -110,6 +149,7 @@ export interface RoutineScheduleReceipt {
     readonly createIfMissing?: boolean;
   };
   readonly deliveryMode?: string;
+  readonly deliveryTargets?: readonly RoutineScheduleReceiptDeliveryTarget[];
   readonly failureKind?: RoutineSchedulePromotionFailure['kind'];
   readonly failureError?: string;
 }
@@ -176,6 +216,24 @@ interface RoutineScheduleReceiptStoreFile {
 }
 
 const RECEIPT_STORE_VERSION = 1;
+const DELIVERY_SURFACE_KINDS: readonly RoutineScheduleDeliverySurfaceKind[] = [
+  'tui',
+  'web',
+  'slack',
+  'discord',
+  'ntfy',
+  'webhook',
+  'telegram',
+  'google-chat',
+  'signal',
+  'whatsapp',
+  'imessage',
+  'msteams',
+  'bluebubbles',
+  'mattermost',
+  'matrix',
+  'service',
+];
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -222,6 +280,99 @@ function normalizeProviderModel(provider: string | undefined, model: string | un
   };
 }
 
+function isDeliverySurfaceKind(value: string): value is RoutineScheduleDeliverySurfaceKind {
+  return DELIVERY_SURFACE_KINDS.includes(value as RoutineScheduleDeliverySurfaceKind);
+}
+
+function parseSurfaceDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const [surfaceKind = '', routeId, label] = raw.split(':');
+  if (!isDeliverySurfaceKind(surfaceKind)) {
+    return `Unsupported delivery surface "${surfaceKind}".`;
+  }
+  return {
+    kind: 'surface',
+    surfaceKind,
+    routeId: routeId?.trim() || undefined,
+    label: label?.trim() || undefined,
+  };
+}
+
+function parseRouteDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const [routeId = '', label] = raw.split(':');
+  const normalizedRouteId = routeId.trim();
+  if (!normalizedRouteId) return '--delivery-route requires a route id.';
+  return {
+    kind: 'surface',
+    routeId: normalizedRouteId,
+    label: label?.trim() || undefined,
+  };
+}
+
+function parseWebhookDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const normalized = raw.trim();
+  if (!normalized) return '--delivery-webhook requires a URL.';
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') return '--delivery-webhook must be an http(s) URL.';
+  } catch {
+    return '--delivery-webhook must be a valid URL.';
+  }
+  return {
+    kind: 'webhook',
+    address: normalized,
+  };
+}
+
+function parseLinkDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const normalized = raw.trim();
+  if (!normalized) return '--delivery-link requires a URL or label.';
+  return {
+    kind: 'link',
+    address: normalized,
+  };
+}
+
+function validateDeliveryTargets(targets: readonly RoutineScheduleDeliveryTargetSpec[]): string | null {
+  const kinds = new Set(targets.map((target) => target.kind));
+  return kinds.size > 1 ? 'Use one delivery target kind per routine promotion command.' : null;
+}
+
+function deliveryModeFromTargets(targets: readonly RoutineScheduleDeliveryTargetSpec[]): ScheduleDeliveryInput['mode'] {
+  const first = targets[0];
+  return first ? first.kind : 'none';
+}
+
+function toDeliveryTargetInput(target: RoutineScheduleDeliveryTargetSpec): ScheduleDeliveryTargetInput {
+  return {
+    kind: target.kind,
+    surfaceKind: target.surfaceKind,
+    address: target.address,
+    routeId: target.routeId,
+    label: target.label,
+  };
+}
+
+function redactedDeliveryAddress(address: string | undefined): string | undefined {
+  if (!address) return undefined;
+  try {
+    const url = new URL(address);
+    return `${url.protocol}//${url.host}/...`;
+  } catch {
+    return '[redacted]';
+  }
+}
+
+function redactedDeliveryTargets(delivery: ScheduleDeliveryInput | undefined): readonly RoutineScheduleReceiptDeliveryTarget[] | undefined {
+  if (!delivery) return undefined;
+  return delivery.targets.map((target) => ({
+    kind: target.kind as RoutineScheduleDeliveryKind,
+    surfaceKind: typeof target.surfaceKind === 'string' && isDeliverySurfaceKind(target.surfaceKind) ? target.surfaceKind : undefined,
+    address: redactedDeliveryAddress(typeof target.address === 'string' ? target.address : undefined),
+    routeId: typeof target.routeId === 'string' ? target.routeId : undefined,
+    label: typeof target.label === 'string' ? target.label : undefined,
+  }));
+}
+
 function readReceipt(value: unknown): RoutineScheduleReceipt | null {
   if (!isRecord(value)) return null;
   const id = readString(value, 'id')?.trim();
@@ -234,6 +385,23 @@ function readReceipt(value: unknown): RoutineScheduleReceipt | null {
     : null;
   const scheduleValue = readString(value, 'scheduleValue')?.trim();
   const target = isRecord(value.target) ? value.target : {};
+  const deliveryTargets = Array.isArray(value.deliveryTargets)
+    ? value.deliveryTargets.map((target): RoutineScheduleReceiptDeliveryTarget | null => {
+      if (!isRecord(target)) return null;
+      const kind = target.kind === 'webhook' || target.kind === 'surface' || target.kind === 'integration' || target.kind === 'link'
+        ? target.kind
+        : null;
+      if (!kind) return null;
+      const surfaceKind = readString(target, 'surfaceKind') ?? undefined;
+      return {
+        kind,
+        surfaceKind: surfaceKind && isDeliverySurfaceKind(surfaceKind) ? surfaceKind : undefined,
+        address: readString(target, 'address') ?? undefined,
+        routeId: readString(target, 'routeId') ?? undefined,
+        label: readString(target, 'label') ?? undefined,
+      };
+    }).filter((target): target is RoutineScheduleReceiptDeliveryTarget => target !== null)
+    : undefined;
   if (!id || !createdAt || !routineId || !routineName || !status || !scheduleKind || !scheduleValue) return null;
   return {
     id,
@@ -260,6 +428,7 @@ function readReceipt(value: unknown): RoutineScheduleReceipt | null {
       createIfMissing: readBoolean(target, 'createIfMissing'),
     },
     deliveryMode: readString(value, 'deliveryMode') ?? undefined,
+    deliveryTargets,
     failureKind: value.failureKind === 'confirmation_required'
       || value.failureKind === 'auth_required'
       || value.failureKind === 'daemon_unavailable'
@@ -482,6 +651,7 @@ function buildReceipt(
     enabled: preview.payload.enabled !== false,
     target: targetSummary(preview.payload),
     deliveryMode: deliveryMode(preview.payload),
+    deliveryTargets: redactedDeliveryTargets(preview.payload.delivery),
     failureKind: result.ok ? undefined : result.kind,
     failureError: result.ok ? undefined : result.error,
   };
@@ -539,6 +709,7 @@ export class RoutineScheduleReceiptStore {
 export function parseRoutineSchedulePromotionArgs(args: readonly string[]): ParsedRoutineSchedulePromotionArgs {
   let routineId: string | null = null;
   let schedule: RoutineScheduleSpec | null = null;
+  const deliveryTargets: RoutineScheduleDeliveryTargetSpec[] = [];
   let name: string | undefined;
   let timezone: string | undefined;
   let provider: string | undefined;
@@ -593,6 +764,58 @@ export function parseRoutineSchedulePromotionArgs(args: readonly string[]): Pars
       };
       continue;
     }
+    if (optionName === '--delivery-surface' || optionName === '--deliver-surface') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseSurfaceDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-route' || optionName === '--deliver-route') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseRouteDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-webhook' || optionName === '--deliver-webhook') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseWebhookDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-link' || optionName === '--deliver-link') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseLinkDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
     if (raw.startsWith('--')) {
       errors.push(`Unknown option: ${raw}`);
       continue;
@@ -606,7 +829,9 @@ export function parseRoutineSchedulePromotionArgs(args: readonly string[]): Pars
 
   if (!routineId) errors.push('Routine id or name is required.');
   if (!schedule) errors.push('Schedule is required: use --cron <expr>, --every <interval>, or --at <iso-time>.');
-  return { routineId, schedule, name, timezone, provider, model, enabled, yes, errors };
+  const deliveryError = validateDeliveryTargets(deliveryTargets);
+  if (deliveryError) errors.push(deliveryError);
+  return { routineId, schedule, deliveryTargets, name, timezone, provider, model, enabled, yes, errors };
 }
 
 export function resolveAgentDaemonConnection(
@@ -669,8 +894,8 @@ export function buildRoutineSchedulePayload(
       createIfMissing: true,
     },
     delivery: {
-      mode: 'none',
-      targets: [],
+      mode: deliveryModeFromTargets(parsed.deliveryTargets),
+      targets: parsed.deliveryTargets.map(toDeliveryTargetInput),
       fallbackTargets: [],
       includeSummary: true,
       includeTranscript: false,
@@ -873,6 +1098,8 @@ export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPr
     : preview.payload.kind === 'every'
       ? String(preview.payload.every)
       : String(preview.payload.at);
+  const delivery = preview.payload.delivery;
+  const deliveryTargetCount = delivery?.targets.length ?? 0;
   return [
     'Daemon schedule preview for Agent routine',
     `  routine: ${preview.routineName} (${preview.routineId})`,
@@ -880,6 +1107,7 @@ export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPr
     `  name: ${String(preview.payload.name ?? '(daemon default)')}`,
     `  schedule: ${preview.payload.kind} ${schedule}`,
     `  enabled: ${preview.payload.enabled === false ? 'no' : 'yes'}`,
+    `  delivery: ${delivery?.mode ?? 'none'}${deliveryTargetCount > 0 ? ` (${deliveryTargetCount} target${deliveryTargetCount === 1 ? '' : 's'})` : ''}`,
     '  target: external daemon service/main conversation route',
     '  policy: isolated Agent Knowledge only; no default wiki/HomeGraph fallback; no WRFC unless explicitly delegated',
     '  next: rerun with --yes to create this daemon schedule',
@@ -938,6 +1166,7 @@ export function formatRoutineScheduleReceipt(receipt: RoutineScheduleReceipt): s
     receipt.model ? `  model: ${receipt.model}` : '',
     `  target: ${receipt.target.kind ?? 'unknown'}${receipt.target.surfaceKind ? `/${receipt.target.surfaceKind}` : ''}`,
     receipt.deliveryMode ? `  delivery: ${receipt.deliveryMode}` : '',
+    ...(receipt.deliveryTargets ?? []).map((target) => `  delivery target: ${target.kind}${target.surfaceKind ? `/${target.surfaceKind}` : ''}${target.routeId ? ` route=${target.routeId}` : ''}${target.address ? ` address=${target.address}` : ''}${target.label ? ` label=${target.label}` : ''}`),
     receipt.failureKind ? `  failure: ${receipt.failureKind}` : '',
     receipt.failureError ? `  error: ${receipt.failureError}` : '',
   ].filter((line): line is string => Boolean(line)).join('\n');

package/src/cli/capabilities-command.ts

@@ -5,16 +5,51 @@ import {
   filterOperatorCapabilities,
   renderOperatorCapabilityBenchmark,
 } from '../operator/capability-benchmark.ts';
+import {
+  fetchLiveDaemonCapabilityAudit,
+  filterDaemonCapabilityAuditAreas,
+  renderDaemonCapabilityAudit,
+  renderDaemonCapabilityFailure,
+} from '../operator/daemon-capability-audit.ts';
+import { resolveAgentDaemonConnection } from '../agent/routine-schedule-promotion.ts';
+
+interface CapabilityCommandArgs {
+  readonly mode: 'benchmark' | 'daemon';
+  readonly query: string | undefined;
+}
 
-function readCapabilityQuery(args: readonly string[]): string | undefined {
+function readCapabilityArgs(args: readonly string[]): CapabilityCommandArgs {
   const values = args.filter((arg) => !arg.startsWith('--'));
-  return values.length > 0 ? values.join(' ') : undefined;
+  if (values[0] === 'daemon') {
+    const query = values.slice(1).join(' ').trim();
+    return { mode: 'daemon', query: query.length > 0 ? query : undefined };
+  }
+  return { mode: 'benchmark', query: values.length > 0 ? values.join(' ') : undefined };
 }
 
 export async function handleCapabilitiesCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
-  const query = readCapabilityQuery(runtime.cli.commandArgs);
+  const args = readCapabilityArgs(runtime.cli.commandArgs);
+  if (args.mode === 'daemon') {
+    const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
+    const audit = await fetchLiveDaemonCapabilityAudit(connection);
+    if (!audit.ok) {
+      return {
+        output: runtime.cli.flags.outputFormat === 'json'
+          ? JSON.stringify(audit, null, 2)
+          : renderDaemonCapabilityFailure(audit),
+        exitCode: audit.kind === 'auth_required' || audit.kind === 'daemon_unavailable' ? 1 : 2,
+      };
+    }
+    const areas = filterDaemonCapabilityAuditAreas(audit.areas, args.query);
+    return {
+      output: runtime.cli.flags.outputFormat === 'json'
+        ? JSON.stringify({ ...audit, areas }, null, 2)
+        : renderDaemonCapabilityAudit(audit, areas),
+      exitCode: 0,
+    };
+  }
   const report = buildOperatorCapabilityBenchmarkReport();
-  const capabilities = filterOperatorCapabilities(report.capabilities, query);
+  const capabilities = filterOperatorCapabilities(report.capabilities, args.query);
   if (runtime.cli.flags.outputFormat === 'json') {
     return {
       output: JSON.stringify({ ...report, capabilities }, null, 2),

package/src/cli/help.ts

@@ -42,7 +42,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  routines                   Inspect local routines and explicitly promote one to a daemon schedule',
     '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
     '  compat                     Inspect Agent SDK pin, daemon version, and Agent knowledge route readiness',
-    '  capabilities               Show OpenClaw/Hermes capability parity and Agent readiness',
+    '  capabilities               Show OpenClaw/Hermes benchmark and live daemon coverage',
     '  knowledge                  Use isolated Agent Knowledge/Wiki routes',
     '  ask|search                 Shortcuts for isolated Agent Knowledge ask/search',
     '  delegate                   Explicitly delegate build/fix/review work to GoodVibes TUI',
@@ -102,6 +102,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --yes`,
     `  ${binary} compat`,
     `  ${binary} capabilities`,
+    `  ${binary} capabilities daemon`,
     `  ${binary} knowledge status`,
     `  ${binary} knowledge ask "What is GoodVibes Agent?"`,
     `  ${binary} ask "What is GoodVibes Agent?"`,
@@ -168,7 +169,7 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'routines receipts',
       'routines reconcile',
       'routines receipt <receipt-id>',
-      'routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+      'routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--delivery-surface <surface[:route[:label]]>|--delivery-route <route[:label]>|--delivery-webhook <url>|--delivery-link <url>] [--disabled] --yes',
     ],
     summary: 'Inspect Agent-local routines, review local promotion receipts, reconcile receipts against live daemon schedules, and explicitly promote a reviewed routine into an external daemon schedule. Without --yes, promote only prints the schedules.create preview.',
     examples: [
@@ -176,7 +177,7 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'routines show daily-operations-sweep',
       'routines receipts',
       'routines reconcile',
-      'routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --yes',
+      'routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --delivery-surface slack --yes',
       'routines promote weekly-review --every 7d --disabled',
     ],
   },
@@ -196,9 +197,9 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     examples: ['compat', 'compat --json'],
   },
   capabilities: {
-    usage: ['capabilities [openclaw|hermes|query]', 'capabilities --json'],
-    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, configuration commands, usage paths, and next product gaps.',
-    examples: ['capabilities', 'capabilities hermes', 'capabilities knowledge --json'],
+    usage: ['capabilities [openclaw|hermes|query]', 'capabilities daemon [query]', 'capabilities --json'],
+    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, and live GoodVibes daemon method coverage.',
+    examples: ['capabilities', 'capabilities hermes', 'capabilities daemon', 'capabilities daemon knowledge --json'],
   },
   knowledge: {
     usage: [

package/src/cli/routines-command.ts

@@ -100,7 +100,7 @@ async function handleRoutinePromotion(runtime: CliCommandRuntime, args: readonly
     };
     return {
       output: json ? JSON.stringify(failure, null, 2) : [
-        'Usage: goodvibes-agent routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+        'Usage: goodvibes-agent routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--delivery-surface <surface[:route[:label]]>|--delivery-route <route[:label]>|--delivery-webhook <url>|--delivery-link <url>] [--disabled] --yes',
         ...parsed.errors.map((error) => `  ${error}`),
       ].join('\n'),
       exitCode: 2,
@@ -237,7 +237,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) --yes]',
+    output: 'Usage: goodvibes-agent routines [list|enabled|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-surface <surface>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
     exitCode: 2,
   };
 }

package/src/input/agent-workspace.ts

@@ -573,10 +573,10 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     group: 'WATCH',
     label: 'Automation',
     summary: 'Automation and schedule observability with explicit routine promotion.',
-    detail: 'Agent does not create local automation jobs or hidden scheduler spawns. Reviewed local routines can be promoted into externally owned daemon schedules only through an explicit schedules.create command with --yes, then reconciled against live daemon schedules from a redacted local receipt.',
+    detail: 'Agent does not create local automation jobs or hidden scheduler spawns. Reviewed local routines can be promoted into externally owned daemon schedules only through an explicit schedules.create command with --yes, optional delivery targets, and a redacted local receipt.',
     actions: [
       { id: 'schedule-list', label: 'List schedules', detail: 'Inspect configured jobs and history without running or mutating them.', command: '/schedule list', kind: 'command', safety: 'read-only' },
-      { id: 'schedule-promote-routine', label: 'Promote routine', detail: 'Create an external daemon schedule from a local Agent routine. Requires a real routine id, schedule expression, and explicit --yes.', command: '/schedule promote-routine <routine-id> --cron <expr> --yes', kind: 'command', safety: 'safe' },
+      { id: 'schedule-promote-routine', label: 'Promote routine', detail: 'Create an external daemon schedule from a local Agent routine. Requires a real routine id, schedule expression, optional delivery target, and explicit --yes.', command: '/schedule promote-routine <routine-id> --cron <expr> [--delivery-surface slack] --yes', kind: 'command', safety: 'safe' },
       { id: 'schedule-receipts', label: 'Promotion receipts', detail: 'Review local redacted receipt history for routine-to-daemon schedule promotion attempts.', command: '/schedule receipts', kind: 'command', safety: 'read-only' },
       { id: 'schedule-reconcile', label: 'Reconcile schedules', detail: 'Compare local promotion receipts with live externally owned daemon schedules using schedules.list.', command: '/schedule reconcile', kind: 'command', safety: 'read-only' },
       { id: 'schedule-policy', label: 'Local scheduler blocked', detail: 'Local schedule add/run/remove/enable/disable remain blocked; only explicit external daemon schedule promotion is allowed here.', kind: 'guidance', safety: 'blocked' },