@pellux/goodvibes-agent 0.1.38 → 0.1.40

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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
+
 ## 0.1.38 - 2026-05-31
 
 - 072503c Add routine schedule promotion receipts

package/README.md

@@ -68,13 +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.
+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/getting-started.md

@@ -39,6 +39,8 @@ Once the TUI opens, run `/agent`, `/home`, or `/operator` to open the Agent oper
 
 Use `/agent-profile guide` inside that workspace to walk through starter-profile authoring. It lists built-in and local starters, exports a JSON starter for editing, imports the edited starter back into this Agent home, and creates isolated profiles from the result.
 
+Use `/schedule receipts` to review redacted local routine promotion history and `/schedule reconcile` to compare those receipts with live externally owned daemon schedules through public `schedules.list`.
+
 ## Isolated Agent Profiles
 
 Use a separate Agent home when you want isolated local state:

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; 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.38",
+  "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

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import { dirname, join } from 'node:path';
 import { createBrowserGoodVibesSdk } from '@pellux/goodvibes-sdk/browser';
 import type { OperatorMethodInput, OperatorMethodOutput } from '@pellux/goodvibes-sdk/contracts';
+import { formatEveryInterval } from '@pellux/goodvibes-sdk/platform/automation';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { getModelIdFromProviderModel, getProviderIdFromModel } from '../config/provider-model.ts';
@@ -11,9 +12,13 @@ import type { AgentRoutineRecord } from './routine-registry.ts';
 
 export const ROUTINE_SCHEDULE_ROUTE = '/api/automation/schedules';
 export const ROUTINE_SCHEDULE_METHOD = 'schedules.create';
+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;
@@ -32,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;
@@ -107,6 +149,7 @@ export interface RoutineScheduleReceipt {
     readonly createIfMissing?: boolean;
   };
   readonly deliveryMode?: string;
+  readonly deliveryTargets?: readonly RoutineScheduleReceiptDeliveryTarget[];
   readonly failureKind?: RoutineSchedulePromotionFailure['kind'];
   readonly failureError?: string;
 }
@@ -116,12 +159,81 @@ export interface RoutineScheduleReceiptSnapshot {
   readonly receipts: readonly RoutineScheduleReceipt[];
 }
 
+export interface RoutineScheduleLiveRecord {
+  readonly id: string;
+  readonly name: string;
+  readonly status?: string;
+  readonly enabled?: boolean;
+  readonly scheduleKind?: RoutineScheduleKind;
+  readonly scheduleValue?: string;
+  readonly timezone?: string;
+  readonly nextRunAt?: number;
+  readonly lastRunAt?: number;
+  readonly runCount?: number;
+  readonly successCount?: number;
+  readonly failureCount?: number;
+}
+
+export interface RoutineScheduleCorrelation {
+  readonly receipt: RoutineScheduleReceipt;
+  readonly liveStatus: 'matched' | 'missing' | 'failed-receipt';
+  readonly matchReason: 'schedule-id' | 'name-and-cadence' | 'failed-receipt' | 'not-found';
+  readonly schedule?: RoutineScheduleLiveRecord;
+}
+
+export interface RoutineScheduleCorrelationSuccess {
+  readonly ok: true;
+  readonly kind: typeof ROUTINE_SCHEDULE_LIST_METHOD;
+  readonly route: typeof ROUTINE_SCHEDULE_ROUTE;
+  readonly baseUrl: string;
+  readonly scheduleCount: number;
+  readonly receiptCount: number;
+  readonly correlations: readonly RoutineScheduleCorrelation[];
+}
+
+export interface RoutineScheduleCorrelationFailure {
+  readonly ok: false;
+  readonly kind:
+    | 'auth_required'
+    | 'daemon_unavailable'
+    | 'version_mismatch'
+    | 'daemon_route_unavailable'
+    | 'daemon_error';
+  readonly error: string;
+  readonly route: typeof ROUTINE_SCHEDULE_ROUTE;
+  readonly baseUrl?: string;
+  readonly daemonVersion?: string;
+  readonly expectedSdkVersion?: string;
+}
+
+export type RoutineScheduleCorrelationResult =
+  | RoutineScheduleCorrelationSuccess
+  | RoutineScheduleCorrelationFailure;
+
 interface RoutineScheduleReceiptStoreFile {
   readonly version: 1;
   readonly receipts: readonly RoutineScheduleReceipt[];
 }
 
 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);
@@ -137,6 +249,11 @@ function readBoolean(record: Record<string, unknown>, key: string): boolean | un
   return typeof value === 'boolean' ? value : undefined;
 }
 
+function readNumber(record: Record<string, unknown>, key: string): number | undefined {
+  const value = record[key];
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
 function nowIso(): string {
   return new Date().toISOString();
 }
@@ -163,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();
@@ -175,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,
@@ -201,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'
@@ -270,6 +498,128 @@ function resultScheduleRecord(result: RoutineSchedulePromotionResult): Record<st
   return result.ok && isRecord(result.schedule) ? result.schedule : {};
 }
 
+function normalizeForMatch(value: string | undefined): string {
+  return (value ?? '').trim().toLowerCase();
+}
+
+function isoTime(value: string): string | null {
+  const time = new Date(value).getTime();
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+
+function readLiveScheduleDefinition(value: unknown): {
+  readonly kind?: RoutineScheduleKind;
+  readonly value?: string;
+  readonly timezone?: string;
+} {
+  if (!isRecord(value)) return {};
+  if (value.kind === 'cron') {
+    return {
+      kind: 'cron',
+      value: readString(value, 'expression') ?? undefined,
+      timezone: readString(value, 'timezone') ?? undefined,
+    };
+  }
+  if (value.kind === 'every') {
+    const intervalMs = readNumber(value, 'intervalMs');
+    return {
+      kind: 'every',
+      value: intervalMs === undefined ? undefined : formatEveryInterval(intervalMs),
+    };
+  }
+  if (value.kind === 'at') {
+    const at = readNumber(value, 'at');
+    return {
+      kind: 'at',
+      value: at === undefined ? undefined : new Date(at).toISOString(),
+    };
+  }
+  return {};
+}
+
+function readLiveScheduleRecord(value: unknown): RoutineScheduleLiveRecord | null {
+  if (!isRecord(value)) return null;
+  const id = readString(value, 'id')?.trim();
+  const name = readString(value, 'name')?.trim();
+  if (!id || !name) return null;
+  const schedule = readLiveScheduleDefinition(value.schedule);
+  return {
+    id,
+    name,
+    status: readString(value, 'status') ?? undefined,
+    enabled: readBoolean(value, 'enabled'),
+    scheduleKind: schedule.kind,
+    scheduleValue: schedule.value,
+    timezone: schedule.timezone,
+    nextRunAt: readNumber(value, 'nextRunAt'),
+    lastRunAt: readNumber(value, 'lastRunAt'),
+    runCount: readNumber(value, 'runCount'),
+    successCount: readNumber(value, 'successCount'),
+    failureCount: readNumber(value, 'failureCount'),
+  };
+}
+
+function readLiveSchedules(output: ScheduleListOutput): readonly RoutineScheduleLiveRecord[] {
+  const record: Record<string, unknown> = isRecord(output) ? output : {};
+  const jobs: readonly unknown[] = Array.isArray(record.jobs) ? record.jobs : [];
+  return jobs.map(readLiveScheduleRecord).filter((schedule): schedule is RoutineScheduleLiveRecord => schedule !== null);
+}
+
+function cadenceMatches(receipt: RoutineScheduleReceipt, schedule: RoutineScheduleLiveRecord): boolean {
+  if (receipt.scheduleKind !== schedule.scheduleKind) return false;
+  if (receipt.scheduleKind === 'at') {
+    const left = isoTime(receipt.scheduleValue);
+    const right = schedule.scheduleValue ? isoTime(schedule.scheduleValue) : null;
+    return Boolean(left && right && left === right);
+  }
+  return normalizeForMatch(receipt.scheduleValue) === normalizeForMatch(schedule.scheduleValue);
+}
+
+function findScheduleForReceipt(
+  receipt: RoutineScheduleReceipt,
+  schedules: readonly RoutineScheduleLiveRecord[],
+): { readonly reason: RoutineScheduleCorrelation['matchReason']; readonly schedule?: RoutineScheduleLiveRecord } {
+  if (receipt.scheduleId) {
+    const byId = schedules.find((schedule) => schedule.id === receipt.scheduleId);
+    if (byId) return { reason: 'schedule-id', schedule: byId };
+  }
+  const byNameAndCadence = schedules.find((schedule) => (
+    normalizeForMatch(schedule.name) === normalizeForMatch(receipt.scheduleName)
+    && cadenceMatches(receipt, schedule)
+  ));
+  return byNameAndCadence
+    ? { reason: 'name-and-cadence', schedule: byNameAndCadence }
+    : { reason: 'not-found' };
+}
+
+function correlateReceipts(
+  receipts: readonly RoutineScheduleReceipt[],
+  schedules: readonly RoutineScheduleLiveRecord[],
+): readonly RoutineScheduleCorrelation[] {
+  return receipts.map((receipt) => {
+    if (receipt.status === 'failed') {
+      return {
+        receipt,
+        liveStatus: 'failed-receipt',
+        matchReason: 'failed-receipt',
+      };
+    }
+    const match = findScheduleForReceipt(receipt, schedules);
+    return match.schedule
+      ? {
+        receipt,
+        liveStatus: 'matched',
+        matchReason: match.reason,
+        schedule: match.schedule,
+      }
+      : {
+        receipt,
+        liveStatus: 'missing',
+        matchReason: 'not-found',
+      };
+  });
+}
+
 function buildReceipt(
   existing: readonly RoutineScheduleReceipt[],
   connection: AgentDaemonConnection,
@@ -301,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,
   };
@@ -358,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;
@@ -412,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;
@@ -425,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(
@@ -488,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,
@@ -593,6 +999,38 @@ async function classifyScheduleError(
   return { ok: false, kind: 'daemon_error', error: message, route: ROUTINE_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
 }
 
+async function classifyScheduleListError(
+  error: unknown,
+  connection: AgentDaemonConnection,
+): Promise<RoutineScheduleCorrelationFailure> {
+  const message = summarizeError(error);
+  const lower = message.toLowerCase();
+  if (lower.includes('401') || lower.includes('unauthorized') || lower.includes('auth')) {
+    return { ok: false, kind: 'auth_required', error: message, route: ROUTINE_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+  }
+  if (lower.includes('404') || lower.includes('not found')) {
+    const daemon = await fetchDaemonStatus(connection);
+    const record = isRecord(daemon.body) ? daemon.body : {};
+    const daemonVersion = readString(record, 'version') ?? 'unknown';
+    if (daemon.ok && daemonVersion !== SDK_VERSION) {
+      return {
+        ok: false,
+        kind: 'version_mismatch',
+        error: `External daemon SDK version ${daemonVersion} does not match Agent SDK pin ${SDK_VERSION}; schedules.list is unavailable.`,
+        route: ROUTINE_SCHEDULE_ROUTE,
+        baseUrl: connection.baseUrl,
+        daemonVersion,
+        expectedSdkVersion: SDK_VERSION,
+      };
+    }
+    return { ok: false, kind: 'daemon_route_unavailable', error: message, route: ROUTINE_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+  }
+  if (lower.includes('fetch') || lower.includes('connect') || lower.includes('econnrefused')) {
+    return { ok: false, kind: 'daemon_unavailable', error: message, route: ROUTINE_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+  }
+  return { ok: false, kind: 'daemon_error', error: message, route: ROUTINE_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+}
+
 export async function promoteRoutineToDaemonSchedule(
   connection: AgentDaemonConnection,
   preview: RoutineSchedulePromotionPreview,
@@ -623,12 +1061,45 @@ export async function promoteRoutineToDaemonSchedule(
   }
 }
 
+export async function reconcileRoutineScheduleReceipts(
+  connection: AgentDaemonConnection,
+  snapshot: RoutineScheduleReceiptSnapshot,
+): Promise<RoutineScheduleCorrelationResult> {
+  if (!connection.token) {
+    return {
+      ok: false,
+      kind: 'auth_required',
+      error: `No daemon operator token found at ${connection.tokenPath}`,
+      route: ROUTINE_SCHEDULE_ROUTE,
+      baseUrl: connection.baseUrl,
+    };
+  }
+  try {
+    const sdk = createBrowserGoodVibesSdk({ baseUrl: connection.baseUrl, authToken: connection.token });
+    const output = await sdk.operator.invoke(ROUTINE_SCHEDULE_LIST_METHOD, {});
+    const schedules = readLiveSchedules(output);
+    return {
+      ok: true,
+      kind: ROUTINE_SCHEDULE_LIST_METHOD,
+      route: ROUTINE_SCHEDULE_ROUTE,
+      baseUrl: connection.baseUrl,
+      scheduleCount: schedules.length,
+      receiptCount: snapshot.receipts.length,
+      correlations: correlateReceipts(snapshot.receipts, schedules),
+    };
+  } catch (error) {
+    return classifyScheduleListError(error, connection);
+  }
+}
+
 export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPreview): string {
   const schedule = preview.payload.kind === 'cron'
     ? `${preview.payload.cron}${preview.payload.timezone ? ` [${preview.payload.timezone}]` : ''}`
     : 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})`,
@@ -636,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',
@@ -694,11 +1166,65 @@ 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');
 }
 
+export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelationResult, limit = 10): string {
+  if (!result.ok) {
+    return [
+      `Daemon schedule reconciliation error: ${result.kind}`,
+      `  ${result.error}`,
+      result.baseUrl ? `  daemon: ${result.baseUrl}` : null,
+      `  route: ${ROUTINE_SCHEDULE_LIST_METHOD} ${result.route}`,
+      result.kind === 'auth_required'
+        ? '  next: pair/authenticate with the externally managed GoodVibes daemon, then retry.'
+        : null,
+      result.kind === 'daemon_unavailable'
+        ? '  next: start/restart the external GoodVibes daemon from TUI or daemon host tooling; Agent does not own daemon lifecycle.'
+        : null,
+      result.kind === 'version_mismatch' || result.kind === 'daemon_route_unavailable'
+        ? '  next: update/restart the external GoodVibes daemon so public schedules.list is available.'
+        : null,
+    ].filter((line): line is string => Boolean(line)).join('\n');
+  }
+  const correlations = result.correlations.slice(0, Math.max(1, limit));
+  if (result.receiptCount === 0) {
+    return [
+      'Agent routine schedule reconciliation',
+      `  daemon: ${result.baseUrl}`,
+      `  route: ${result.kind} ${result.route}`,
+      `  live schedules: ${result.scheduleCount}`,
+      '  No local routine promotion receipts exist yet.',
+      '  Create one with /schedule promote-routine <routine-id> --cron <expr> --yes.',
+    ].join('\n');
+  }
+  const matched = result.correlations.filter((entry) => entry.liveStatus === 'matched').length;
+  const missing = result.correlations.filter((entry) => entry.liveStatus === 'missing').length;
+  const failed = result.correlations.filter((entry) => entry.liveStatus === 'failed-receipt').length;
+  return [
+    'Agent routine schedule reconciliation',
+    `  daemon: ${result.baseUrl}`,
+    `  route: ${result.kind} ${result.route}`,
+    `  receipts: ${result.receiptCount}; live schedules: ${result.scheduleCount}; matched: ${matched}; missing: ${missing}; failed receipts: ${failed}`,
+    ...correlations.map((entry) => {
+      const receipt = entry.receipt;
+      const schedule = entry.schedule;
+      const live = schedule
+        ? ` live=${schedule.id} status=${schedule.status ?? (schedule.enabled === false ? 'paused' : 'enabled')}`
+        : '';
+      const runs = schedule && schedule.runCount !== undefined
+        ? ` runs=${schedule.runCount}/${schedule.successCount ?? 0}/${schedule.failureCount ?? 0}`
+        : '';
+      const next = schedule?.nextRunAt ? ` next=${new Date(schedule.nextRunAt).toISOString()}` : '';
+      return `  ${receipt.id}  ${entry.liveStatus}  reason=${entry.matchReason}  routine=${receipt.routineId}  receiptSchedule=${receipt.scheduleId ?? '(none)'}${live}${runs}${next}`;
+    }),
+    result.correlations.length > correlations.length ? `  ...${result.correlations.length - correlations.length} more` : '',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
 export function formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFailure): string {
   return [
     `Daemon schedule error: ${failure.kind}`,

package/src/cli/help.ts

@@ -166,15 +166,17 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'routines enabled',
       'routines show <id>',
       '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, and explicitly promote a reviewed routine into an external daemon schedule. Without --yes, promote only prints the schedules.create preview.',
+    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: [
       'routines list',
       'routines show daily-operations-sweep',
       'routines receipts',
-      'routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --yes',
+      'routines reconcile',
+      '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

@@ -2,6 +2,7 @@ import { createShellPathService } from '@/runtime/index.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
   formatRoutineScheduleReceipt,
   formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
@@ -9,6 +10,7 @@ import {
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
   RoutineScheduleReceiptStore,
 } from '../agent/routine-schedule-promotion.ts';
@@ -98,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,
@@ -199,6 +201,17 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       exitCode: 0,
     };
   }
+  if (normalized === 'reconcile' || normalized === 'sync' || normalized === 'status') {
+    const store = routineReceiptStore(runtime);
+    const result = await reconcileRoutineScheduleReceipts(
+      resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory),
+      store.snapshot(),
+    );
+    return {
+      output: jsonOrText(runtime, result, formatRoutineScheduleCorrelation(result)),
+      exitCode: result.ok ? 0 : 1,
+    };
+  }
   if (normalized === 'receipt') {
     const id = rest[0];
     if (!id) return { output: 'Usage: goodvibes-agent routines receipt <receipt-id>', exitCode: 2 };
@@ -224,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|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,11 +573,12 @@ 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 and 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' },
       { id: 'health-services', label: 'Service health', detail: 'Inspect service readiness without starting, stopping, or restarting daemon services.', command: '/health services', kind: 'command', safety: 'read-only' },
     ],

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

@@ -1,6 +1,7 @@
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
   formatRoutineScheduleReceipt,
   formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
@@ -8,6 +9,7 @@ import {
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
   RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
@@ -167,6 +169,13 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(formatRoutineScheduleReceipts(receiptStoreFromContext(ctx).snapshot()));
       return;
     }
+    if (sub === 'reconcile' || sub === 'sync' || sub === 'status') {
+      const shellPaths = requireShellPaths(ctx);
+      const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+      const result = await reconcileRoutineScheduleReceipts(connection, receiptStoreFromContext(ctx).snapshot());
+      ctx.print(formatRoutineScheduleCorrelation(result));
+      return;
+    }
     if (sub === 'receipt') {
       const id = args[1];
       if (!id) {
@@ -275,7 +284,7 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(`Deleted Agent routine ${removed.id}: ${removed.name}`);
       return;
     }
-    ctx.print('Usage: /routines [list|enabled|search|show|receipts|receipt|create|update|enable|disable|start|review|stale|promote|delete]');
+    ctx.print('Usage: /routines [list|enabled|search|show|receipts|reconcile|receipt|create|update|enable|disable|start|review|stale|promote|delete]');
   } catch (error) {
     printError(ctx, error);
   }
@@ -286,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>|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

@@ -7,6 +7,7 @@ import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platfor
 import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
   formatRoutineScheduleReceipt,
   formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
@@ -14,6 +15,7 @@ import {
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
   RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
@@ -58,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;
@@ -85,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 | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
-    argsHint: 'list | receipts | 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];
 
@@ -100,6 +102,14 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (sub === 'reconcile' || sub === 'sync' || sub === 'status') {
+        const shellPaths = requireShellPaths(ctx);
+        const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+        const result = await reconcileRoutineScheduleReceipts(connection, RoutineScheduleReceiptStore.fromShellPaths(shellPaths).snapshot());
+        ctx.print(formatRoutineScheduleCorrelation(result));
+        return;
+      }
+
       if (sub === 'receipt') {
         const id = args[1];
         if (!id) {
@@ -148,8 +158,9 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         'Usage:\n'
         + '  /schedule list\n'
         + '  /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 live schedule recovery/status correlation 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.38';
+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 {