@pellux/goodvibes-agent 0.1.38 → 0.1.39

package/CHANGELOG.md

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

@@ -70,11 +70,12 @@ Local Agent behavior is editable from the TUI:
 /routines start evening-review
 /schedule promote-routine evening-review --cron "0 17 * * 1-5" --timezone America/Chicago --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`, 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

@@ -53,7 +53,7 @@ Primary sources used for the benchmark:
 | 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 |
 | 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 |
+| 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 |
 | Build/code work | Direct terminal/file/code tools and subagents | Explicit delegation to GoodVibes TUI; local WRFC/spawn fanout blocked |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "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,11 @@ 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'>;
 
 export interface AgentDaemonConfigReader {
   get(key: string): unknown;
@@ -116,6 +119,57 @@ 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[];
@@ -137,6 +191,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();
 }
@@ -270,6 +329,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,
@@ -593,6 +774,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,6 +836,37 @@ 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}]` : ''}`
@@ -699,6 +943,59 @@ export function formatRoutineScheduleReceipt(receipt: RoutineScheduleReceipt): s
   ].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,14 +166,16 @@ 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',
     ],
-    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 reconcile',
       'routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --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';
@@ -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>) --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, then reconciled against live daemon schedules from 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-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> --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';
@@ -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> --yes',
+    argsHint: 'list | receipts | reconcile | receipt <id> | promote-routine <routine-id> --cron <expr> --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,6 +158,7 @@ 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'
         + '  Local schedule mutations and runs remain blocked.'

package/src/operator/capability-benchmark.ts

@@ -116,7 +116,7 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     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.'],
+    next: ['Add delivery target selection and deeper live run/delivery history for promoted routines.'],
   },
   {
     id: 'tool-gateway-mcp',

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.39';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {