@pellux/goodvibes-agent 0.1.39 → 0.1.40

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 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

@@ -68,14 +68,14 @@ 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
 

package/docs/operator-capability-benchmark.md

@@ -43,19 +43,27 @@ 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.
 
 ## 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 +74,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 +86,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.40",
   "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/help.ts

@@ -168,7 +168,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 +176,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',
     ],
   },

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' },

package/src/input/commands/routines-runtime.ts

@@ -295,7 +295,7 @@ export function registerRoutinesRuntimeCommands(registry: CommandRegistry): void
     name: 'routines',
     aliases: ['routine'],
     description: 'Manage local GoodVibes Agent routines',
-    usage: '[list|enabled|search <query>|show <id>|receipts|reconcile|receipt <id>|create --name <name> --description <summary> --steps <steps>|update <id> [--name ...] [--description ...] [--steps ...]|enable <id>|disable <id>|start <id>|review <id>|stale <id> <reason...>|promote <id> --cron <expr> --yes|delete <id> --yes]',
+    usage: '[list|enabled|search <query>|show <id>|receipts|reconcile|receipt <id>|create --name <name> --description <summary> --steps <steps>|update <id> [--name ...] [--description ...] [--steps ...]|enable <id>|disable <id>|start <id>|review <id>|stale <id> <reason...>|promote <id> --cron <expr> [--delivery-surface slack] --yes|delete <id> --yes]',
     handler: runRoutinesRuntimeCommand,
   });
 }

package/src/input/commands/schedule-runtime.ts

@@ -60,7 +60,7 @@ async function promoteRoutineSchedule(args: readonly string[], ctx: CommandConte
   const parsed = parseRoutineSchedulePromotionArgs(args);
   if (parsed.errors.length > 0) {
     ctx.print([
-      'Usage: /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+      'Usage: /schedule promote-routine <routine-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'));
     return;
@@ -87,8 +87,8 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
     name: 'schedule',
     aliases: ['sched'],
     description: 'Inspect schedules and explicitly promote local Agent routines to daemon schedules',
-    usage: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
-    argsHint: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
+    usage: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-surface slack] --yes',
+    argsHint: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> [--delivery-surface slack] --yes',
     async handler(args, ctx) {
       const sub = args[0];
 
@@ -160,7 +160,7 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         + '  /schedule receipts\n'
         + '  /schedule reconcile\n'
         + '  /schedule receipt <receipt-id>\n'
-        + '  /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) --yes\n'
+        + '  /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-surface <surface>|--delivery-route <route>|--delivery-webhook <url>] --yes\n'
         + '  Local schedule mutations and runs remain blocked.'
       );
     },

package/src/operator/capability-benchmark.ts

@@ -14,6 +14,7 @@ export interface OperatorCapabilityBenchmark {
   readonly posture: CapabilityPosture;
   readonly competitors: readonly CompetitorProduct[];
   readonly competitorBaseline: string;
+  readonly goodvibesDaemon?: string;
   readonly goodvibesAgent: string;
   readonly configure: readonly string[];
   readonly use: readonly string[];
@@ -43,6 +44,7 @@ export const OPERATOR_CAPABILITY_BENCHMARK_SOURCES = [
   'https://hermes-agent.nousresearch.com/docs/user-guide/features/voice-mode/',
   'https://hermes-agent.nousresearch.com/docs/user-guide/features/api-server/',
   'https://hermes-agent.nousresearch.com/docs/user-guide/profiles/',
+  '@pellux/goodvibes-sdk@0.33.35 public operator contract and /api/goodvibes-agent/knowledge routes',
 ] as const;
 
 export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmark[] = [
@@ -64,6 +66,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'external-daemon',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Always-on gateway/service provides channel ingress, sessions, tools, events, and scheduled execution.',
+    goodvibesDaemon: 'Daemon exposes status/auth/control, sessions, companion chat, channels, remote peers, approvals, automation, schedules, artifacts, MCP, providers, voice, media, web search, and isolated Agent Knowledge routes.',
     goodvibesAgent: 'Connects to the GoodVibes daemon owned by GoodVibes TUI/daemon tooling; Agent never starts, stops, or owns daemon lifecycle.',
     configure: ['goodvibes-agent compat', 'goodvibes-agent service check', 'goodvibes-agent control-plane status'],
     use: ['goodvibes-agent status', 'goodvibes-agent doctor'],
@@ -76,6 +79,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'configurable',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Messaging gateway for WhatsApp, Telegram, Slack, Discord, Signal, iMessage, web chat, and related platforms.',
+    goodvibesDaemon: 'Public channel routes include channels.status, channels.capabilities.*, channels.accounts.*, channels.setup.*, channels.directory.*, channels.actions.*, channels.tools.*, channels.targets.resolve, pairing, and companion chat routes.',
     goodvibesAgent: 'Uses GoodVibes daemon channel, companion, pairing, QR, communication, and session surfaces while keeping side effects behind explicit user action. The Agent workspace exposes channel setup, per-channel readiness, default-target posture, and risk labels as a first-class operator area.',
     configure: ['goodvibes-agent pair', 'goodvibes-agent qrcode', 'goodvibes-agent surfaces check', '/agent → Channels'],
     use: ['/agent → Channels', '/communication', '/pair'],
@@ -88,6 +92,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'ready',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Persistent memory and knowledge/wiki layers with search, recall, provenance, and freshness checks.',
+    goodvibesDaemon: 'Agent-specific daemon routes cover /api/goodvibes-agent/knowledge/status, ask, search, ingest, source/node/issue/candidate/refinement/report/job/schedule, projection, GraphQL, and usage surfaces.',
     goodvibesAgent: 'Uses only /api/goodvibes-agent/knowledge/*; never falls back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes. The Agent workspace exposes isolated ask/search/status, URL/bookmark ingestion, review queue, and consolidation workflows.',
     configure: ['goodvibes-agent compat', 'goodvibes-agent knowledge status', '/agent → Knowledge'],
     use: ['goodvibes-agent ask <question>', 'goodvibes-agent search <query>', '/knowledge ask <question>', '/knowledge ingest-url <url> --yes', '/knowledge queue'],
@@ -112,11 +117,12 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'configurable',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Cron/scheduler can create, pause, resume, run, remove, and deliver recurring tasks from natural language.',
-    goodvibesAgent: 'Observes public automation/schedule routes, keeps local routines separate from daemon jobs, and promotes a local routine into an external daemon schedules.create record only through an exact user command with --yes.',
-    configure: ['/schedule list', '/routines create ...', '/schedule promote-routine <id> --cron "0 8 * * *" --yes', 'goodvibes-agent routines promote <id> --every 1d --yes'],
-    use: ['/schedule list', '/routines start <id>', '/schedule promote-routine <id> --cron <expr> --yes'],
-    exceedsBy: ['No recursive hidden scheduler creation from model tools', 'explicit confirmation for side effects', 'local routines separate from daemon jobs', 'scheduled prompts preserve isolated Agent Knowledge and forbid default wiki/HomeGraph fallback'],
-    next: ['Add delivery target selection and deeper live run/delivery history for promoted routines.'],
+    goodvibesDaemon: 'Public daemon routes cover automation.integration.snapshot, automation.jobs.*, automation.runs.*, automation.heartbeat.*, scheduler.capacity, schedules.create/list/run/enable/disable/delete, and delivery policy fields.',
+    goodvibesAgent: 'Observes public automation/schedule routes, keeps local routines separate from daemon jobs, and promotes a local routine into an external daemon schedules.create record only through an exact user command with --yes and optional explicit delivery targets.',
+    configure: ['/schedule list', '/routines create ...', '/schedule promote-routine <id> --cron "0 8 * * *" --delivery-surface slack --yes', 'goodvibes-agent routines promote <id> --every 1d --delivery-webhook https://example.test/hook --yes'],
+    use: ['/schedule list', '/routines start <id>', '/schedule promote-routine <id> --cron <expr> [--delivery-surface slack] --yes', '/schedule receipts', '/schedule reconcile'],
+    exceedsBy: ['No recursive hidden scheduler creation from model tools', 'explicit confirmation for side effects', 'local routines separate from daemon jobs', 'explicit delivery target selection', 'redacted promotion receipts', 'scheduled prompts preserve isolated Agent Knowledge and forbid default wiki/HomeGraph fallback'],
+    next: ['Add deeper live run/delivery history for promoted routines and expose delivery attempt errors in the operator workspace.'],
   },
   {
     id: 'tool-gateway-mcp',
@@ -124,6 +130,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'configurable',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Broad toolsets, MCP integration, browser/web/media tools, and configurable platform-specific tool availability.',
+    goodvibesDaemon: 'Daemon public routes include mcp.servers/tools/config, artifacts.create/get/list/content, web_search.providers/query, providers/model surfaces, media.analyze/generate/transform, multimodal providers, and channel tool/action registries.',
     goodvibesAgent: 'Uses GoodVibes SDK tool registry, MCP inspection, provider tools, web search, media, plugins, and policy-gated model-visible tools.',
     configure: ['/mcp servers', '/plugin list', 'goodvibes-agent providers', 'goodvibes-agent models'],
     use: ['/mcp tools', '/provider current', 'goodvibes-agent search <query>'],
@@ -136,6 +143,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'configurable',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Voice/TTS, mobile nodes, live canvas, browser automation, image/video generation, and multimodal analysis.',
+    goodvibesDaemon: 'Daemon public routes include voice.status/providers/voices/tts/stt/realtime, media providers/analyze/generate/transform, multimodal providers, artifacts, remote.snapshot/peers/work, and channel media-capable surfaces.',
     goodvibesAgent: 'Uses GoodVibes voice/media/browser/node primitives and exposes an Agent workspace for TTS setup, image input, browser/web posture, MCP browser tools, and node/remote inspection.',
     configure: ['/agent → Voice, Media & Nodes', '/config tts', '/voice review', '/mcp servers'],
     use: ['/tts <prompt>', '/image <path> <prompt>', '/remote list'],
@@ -148,6 +156,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'explicit-delegation',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Terminal/file/code tools and subagents can execute software tasks directly.',
+    goodvibesDaemon: 'Daemon shared-session routes cover sessions.create/list/get/messages/followUp/steer/close/reopen and task/workflow visibility used by GoodVibes TUI-owned execution.',
     goodvibesAgent: 'Main assistant stays serial. Explicit build/fix/review/code work is delegated to GoodVibes TUI/shared-session contracts; WRFC is opt-in only.',
     configure: ['goodvibes-agent delegate --help', 'goodvibes-agent compat'],
     use: ['goodvibes-agent delegate "fix the failing tests"', 'goodvibes-agent delegate --wrfc "implement and review the feature"'],
@@ -172,6 +181,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'ready',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Command approval, DM pairing, sandboxing, allowlists, and safety defaults for exposed channels.',
+    goodvibesDaemon: 'Daemon public routes include approvals.list/claim/approve/deny/cancel, channel policies/allowlists, local auth/session controls, secrets, and route danger metadata in the operator contract.',
     goodvibesAgent: 'Uses daemon approvals, local auth diagnostics, secret refs, explicit confirmation gates, and Agent model-tool policy guards.',
     configure: ['goodvibes-agent auth status', 'goodvibes-agent secrets providers', '/approvals list'],
     use: ['/policy status', '/approvals list', 'goodvibes-agent doctor'],
@@ -218,6 +228,7 @@ export function renderOperatorCapabilityBenchmark(
     lines.push(`${capability.title} [${capability.posture}]`);
     lines.push(`  competitors: ${capability.competitors.join(', ')}`);
     lines.push(`  baseline: ${capability.competitorBaseline}`);
+    if (capability.goodvibesDaemon) lines.push(`  daemon: ${capability.goodvibesDaemon}`);
     lines.push(`  Agent: ${capability.goodvibesAgent}`);
     lines.push(`  configure: ${capability.configure.join(' | ')}`);
     lines.push(`  use: ${capability.use.join(' | ')}`);

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.39';
+let _version = '0.1.40';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {