@pellux/goodvibes-agent 0.1.37 → 0.1.39

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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
+- 5bb9801 Update automation capability benchmark
+
 ## 0.1.37 - 2026-05-31
 
 - 656b6f4 Add Agent routine daemon schedule promotion

package/README.md

@@ -69,11 +69,13 @@ Local Agent behavior is editable from the TUI:
 /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 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`, 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:
@@ -76,7 +78,7 @@ Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They
 /skills local list
 ```
 
-The active persona plus enabled Agent routines and skills are injected into the main serial assistant conversation. Starting a routine records local usage and prints its steps; it does not spawn background agents or daemon automation jobs. Promoting a routine to a schedule is an explicit `schedules.create` call to the external daemon, requires `--yes`, and preserves the rule that Agent Knowledge never falls back to default Knowledge/Wiki or HomeGraph.
+The active persona plus enabled Agent routines and skills are injected into the main serial assistant conversation. Starting a routine records local usage and prints its steps; it does not spawn background agents or daemon automation jobs. Promoting a routine to a schedule is an explicit `schedules.create` call to the external daemon, requires `--yes`, writes a local redacted promotion receipt, and preserves the rule that Agent Knowledge never falls back to default Knowledge/Wiki or HomeGraph.
 
 ## External Daemon
 

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`; 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 |
@@ -78,6 +78,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.
 - 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.37",
+  "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

@@ -1,17 +1,22 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+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';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { SDK_VERSION } from '../version.ts';
 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;
@@ -80,6 +85,98 @@ export type RoutineSchedulePromotionResult =
   | RoutineSchedulePromotionSuccess
   | RoutineSchedulePromotionFailure;
 
+export interface RoutineScheduleReceipt {
+  readonly id: string;
+  readonly createdAt: string;
+  readonly routineId: string;
+  readonly routineName: string;
+  readonly route: typeof ROUTINE_SCHEDULE_ROUTE;
+  readonly method: typeof ROUTINE_SCHEDULE_METHOD;
+  readonly status: 'created' | 'failed';
+  readonly daemonBaseUrl: string;
+  readonly scheduleId?: string;
+  readonly scheduleStatus?: string;
+  readonly scheduleName: string;
+  readonly scheduleKind: RoutineScheduleKind;
+  readonly scheduleValue: string;
+  readonly timezone?: string;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly enabled: boolean;
+  readonly target: {
+    readonly kind?: string;
+    readonly surfaceKind?: string;
+    readonly preserveThread?: boolean;
+    readonly createIfMissing?: boolean;
+  };
+  readonly deliveryMode?: string;
+  readonly failureKind?: RoutineSchedulePromotionFailure['kind'];
+  readonly failureError?: string;
+}
+
+export interface RoutineScheduleReceiptSnapshot {
+  readonly path: string;
+  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;
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -89,6 +186,20 @@ function readString(record: Record<string, unknown>, key: string): string | null
   return typeof value === 'string' ? value : null;
 }
 
+function readBoolean(record: Record<string, unknown>, key: string): boolean | undefined {
+  const value = record[key];
+  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();
+}
+
 function optionValue(args: readonly string[], index: number, inlineValue: string | undefined): {
   readonly value: string | undefined;
   readonly nextIndex: number;
@@ -111,6 +222,320 @@ function normalizeProviderModel(provider: string | undefined, model: string | un
   };
 }
 
+function readReceipt(value: unknown): RoutineScheduleReceipt | null {
+  if (!isRecord(value)) return null;
+  const id = readString(value, 'id')?.trim();
+  const createdAt = readString(value, 'createdAt')?.trim();
+  const routineId = readString(value, 'routineId')?.trim();
+  const routineName = readString(value, 'routineName')?.trim();
+  const status = value.status === 'created' || value.status === 'failed' ? value.status : null;
+  const scheduleKind = value.scheduleKind === 'cron' || value.scheduleKind === 'every' || value.scheduleKind === 'at'
+    ? value.scheduleKind
+    : null;
+  const scheduleValue = readString(value, 'scheduleValue')?.trim();
+  const target = isRecord(value.target) ? value.target : {};
+  if (!id || !createdAt || !routineId || !routineName || !status || !scheduleKind || !scheduleValue) return null;
+  return {
+    id,
+    createdAt,
+    routineId,
+    routineName,
+    route: ROUTINE_SCHEDULE_ROUTE,
+    method: ROUTINE_SCHEDULE_METHOD,
+    status,
+    daemonBaseUrl: readString(value, 'daemonBaseUrl') ?? '',
+    scheduleId: readString(value, 'scheduleId') ?? undefined,
+    scheduleStatus: readString(value, 'scheduleStatus') ?? undefined,
+    scheduleName: readString(value, 'scheduleName') ?? routineName,
+    scheduleKind,
+    scheduleValue,
+    timezone: readString(value, 'timezone') ?? undefined,
+    provider: readString(value, 'provider') ?? undefined,
+    model: readString(value, 'model') ?? undefined,
+    enabled: value.enabled !== false,
+    target: {
+      kind: readString(target, 'kind') ?? undefined,
+      surfaceKind: readString(target, 'surfaceKind') ?? undefined,
+      preserveThread: readBoolean(target, 'preserveThread'),
+      createIfMissing: readBoolean(target, 'createIfMissing'),
+    },
+    deliveryMode: readString(value, 'deliveryMode') ?? undefined,
+    failureKind: value.failureKind === 'confirmation_required'
+      || value.failureKind === 'auth_required'
+      || value.failureKind === 'daemon_unavailable'
+      || value.failureKind === 'version_mismatch'
+      || value.failureKind === 'daemon_route_unavailable'
+      || value.failureKind === 'daemon_error'
+      ? value.failureKind
+      : undefined,
+    failureError: readString(value, 'failureError') ?? undefined,
+  };
+}
+
+function parseReceiptStore(raw: string): RoutineScheduleReceiptStoreFile {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) return { version: RECEIPT_STORE_VERSION, receipts: [] };
+  return {
+    version: RECEIPT_STORE_VERSION,
+    receipts: Array.isArray(parsed.receipts)
+      ? parsed.receipts.map(readReceipt).filter((receipt): receipt is RoutineScheduleReceipt => receipt !== null)
+      : [],
+  };
+}
+
+function formatReceiptStore(store: RoutineScheduleReceiptStoreFile): string {
+  return `${JSON.stringify(store, null, 2)}\n`;
+}
+
+function receiptId(createdAt: string, routineId: string, existing: readonly RoutineScheduleReceipt[]): string {
+  const dayStamp = createdAt.slice(0, 10).replace(/-/g, '');
+  const base = `routine-schedule-${routineId}-${dayStamp}`.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const ids = new Set(existing.map((receipt) => receipt.id));
+  if (!ids.has(base)) return base;
+  for (let index = 2; index < 1000; index += 1) {
+    const candidate = `${base}-${index}`;
+    if (!ids.has(candidate)) return candidate;
+  }
+  return `${base}-${existing.length + 1}`;
+}
+
+function scheduleValue(payload: ScheduleCreateInput): string {
+  if (payload.kind === 'cron') return String(payload.cron ?? '');
+  if (payload.kind === 'every') return String(payload.every ?? '');
+  return String(payload.at ?? '');
+}
+
+function scheduleKind(payload: ScheduleCreateInput): RoutineScheduleKind {
+  if (payload.kind === 'cron' || payload.kind === 'every' || payload.kind === 'at') return payload.kind;
+  throw new Error('Routine schedule payload is missing a schedule kind.');
+}
+
+function targetSummary(payload: ScheduleCreateInput): RoutineScheduleReceipt['target'] {
+  return isRecord(payload.target)
+    ? {
+      kind: typeof payload.target.kind === 'string' ? payload.target.kind : undefined,
+      surfaceKind: typeof payload.target.surfaceKind === 'string' ? payload.target.surfaceKind : undefined,
+      preserveThread: typeof payload.target.preserveThread === 'boolean' ? payload.target.preserveThread : undefined,
+      createIfMissing: typeof payload.target.createIfMissing === 'boolean' ? payload.target.createIfMissing : undefined,
+    }
+    : {};
+}
+
+function deliveryMode(payload: ScheduleCreateInput): string | undefined {
+  return isRecord(payload.delivery) && typeof payload.delivery.mode === 'string' ? payload.delivery.mode : undefined;
+}
+
+function resultScheduleRecord(result: RoutineSchedulePromotionResult): Record<string, unknown> {
+  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,
+  preview: RoutineSchedulePromotionPreview,
+  result: RoutineSchedulePromotionResult,
+): RoutineScheduleReceipt {
+  const createdAt = nowIso();
+  const kind = scheduleKind(preview.payload);
+  const schedule = resultScheduleRecord(result);
+  const scheduleId = readString(schedule, 'id') ?? undefined;
+  const scheduleStatus = readString(schedule, 'status') ?? (schedule.enabled === false ? 'paused' : schedule.enabled === true ? 'enabled' : undefined);
+  return {
+    id: receiptId(createdAt, preview.routineId, existing),
+    createdAt,
+    routineId: preview.routineId,
+    routineName: preview.routineName,
+    route: ROUTINE_SCHEDULE_ROUTE,
+    method: ROUTINE_SCHEDULE_METHOD,
+    status: result.ok ? 'created' : 'failed',
+    daemonBaseUrl: connection.baseUrl,
+    scheduleId,
+    scheduleStatus,
+    scheduleName: String(preview.payload.name ?? `Agent routine: ${preview.routineName}`),
+    scheduleKind: kind,
+    scheduleValue: scheduleValue(preview.payload),
+    timezone: kind === 'cron' ? preview.payload.timezone : undefined,
+    provider: preview.payload.provider,
+    model: preview.payload.model,
+    enabled: preview.payload.enabled !== false,
+    target: targetSummary(preview.payload),
+    deliveryMode: deliveryMode(preview.payload),
+    failureKind: result.ok ? undefined : result.kind,
+    failureError: result.ok ? undefined : result.error,
+  };
+}
+
+export function routineScheduleReceiptStorePath(shellPaths: ShellPathService): string {
+  return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'routines', 'schedule-receipts.json');
+}
+
+export class RoutineScheduleReceiptStore {
+  public constructor(private readonly storePath: string) {}
+
+  public static fromShellPaths(shellPaths: ShellPathService): RoutineScheduleReceiptStore {
+    return new RoutineScheduleReceiptStore(routineScheduleReceiptStorePath(shellPaths));
+  }
+
+  public snapshot(): RoutineScheduleReceiptSnapshot {
+    const store = this.readStore();
+    return {
+      path: this.storePath,
+      receipts: [...store.receipts].sort((left, right) => right.createdAt.localeCompare(left.createdAt)),
+    };
+  }
+
+  public get(id: string): RoutineScheduleReceipt | null {
+    const normalized = id.trim().toLowerCase();
+    if (!normalized) return null;
+    return this.snapshot().receipts.find((receipt) => receipt.id.toLowerCase() === normalized) ?? null;
+  }
+
+  public append(connection: AgentDaemonConnection, preview: RoutineSchedulePromotionPreview, result: RoutineSchedulePromotionResult): RoutineScheduleReceipt {
+    const store = this.readStore();
+    const receipt = buildReceipt(store.receipts, connection, preview, result);
+    this.writeStore({ ...store, receipts: [...store.receipts, receipt] });
+    return receipt;
+  }
+
+  private readStore(): RoutineScheduleReceiptStoreFile {
+    if (!existsSync(this.storePath)) return { version: RECEIPT_STORE_VERSION, receipts: [] };
+    try {
+      return parseReceiptStore(readFileSync(this.storePath, 'utf-8'));
+    } catch (error) {
+      throw new Error(`Could not read Agent routine schedule receipt store: ${summarizeError(error)}`);
+    }
+  }
+
+  private writeStore(store: RoutineScheduleReceiptStoreFile): void {
+    mkdirSync(dirname(this.storePath), { recursive: true });
+    const tmpPath = `${this.storePath}.tmp`;
+    writeFileSync(tmpPath, formatReceiptStore(store), 'utf-8');
+    renameSync(tmpPath, this.storePath);
+  }
+}
+
 export function parseRoutineSchedulePromotionArgs(args: readonly string[]): ParsedRoutineSchedulePromotionArgs {
   let routineId: string | null = null;
   let schedule: RoutineScheduleSpec | null = null;
@@ -349,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,
@@ -379,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}]` : ''}`
@@ -412,6 +900,102 @@ export function formatRoutineScheduleSuccess(result: RoutineSchedulePromotionSuc
   ].join('\n');
 }
 
+export function formatRoutineScheduleReceipts(snapshot: RoutineScheduleReceiptSnapshot, limit = 10): string {
+  const receipts = snapshot.receipts.slice(0, Math.max(1, limit));
+  if (snapshot.receipts.length === 0) {
+    return [
+      'Agent routine schedule receipts',
+      `  store: ${snapshot.path}`,
+      '  No routine schedule promotions have been recorded yet.',
+      '  Create one with /schedule promote-routine <routine-id> --cron <expr> --yes.',
+    ].join('\n');
+  }
+  return [
+    `Agent routine schedule receipts (${snapshot.receipts.length})`,
+    `  store: ${snapshot.path}`,
+    ...receipts.map((receipt) => {
+      const schedule = receipt.scheduleId ? ` schedule=${receipt.scheduleId}` : '';
+      const failure = receipt.status === 'failed' && receipt.failureKind ? ` failure=${receipt.failureKind}` : '';
+      return `  ${receipt.id}  ${receipt.status}  ${receipt.scheduleKind} ${receipt.scheduleValue}  routine=${receipt.routineId}${schedule}${failure}`;
+    }),
+    snapshot.receipts.length > receipts.length ? `  ...${snapshot.receipts.length - receipts.length} more` : '',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+export function formatRoutineScheduleReceipt(receipt: RoutineScheduleReceipt): string {
+  return [
+    `Agent routine schedule receipt ${receipt.id}`,
+    `  created: ${receipt.createdAt}`,
+    `  status: ${receipt.status}`,
+    `  routine: ${receipt.routineName} (${receipt.routineId})`,
+    `  route: ${receipt.method} ${receipt.route}`,
+    `  daemon: ${receipt.daemonBaseUrl}`,
+    `  schedule: ${receipt.scheduleName}${receipt.scheduleId ? ` (${receipt.scheduleId})` : ''}`,
+    receipt.scheduleStatus ? `  schedule status: ${receipt.scheduleStatus}` : '',
+    `  cadence: ${receipt.scheduleKind} ${receipt.scheduleValue}${receipt.timezone ? ` [${receipt.timezone}]` : ''}`,
+    `  enabled: ${receipt.enabled ? 'yes' : 'no'}`,
+    receipt.provider ? `  provider: ${receipt.provider}` : '',
+    receipt.model ? `  model: ${receipt.model}` : '',
+    `  target: ${receipt.target.kind ?? 'unknown'}${receipt.target.surfaceKind ? `/${receipt.target.surfaceKind}` : ''}`,
+    receipt.deliveryMode ? `  delivery: ${receipt.deliveryMode}` : '',
+    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

@@ -165,12 +165,17 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'routines list',
       '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 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,12 +2,17 @@ import { createShellPathService } from '@/runtime/index.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../agent/routine-schedule-promotion.ts';
 import type { CliCommandOutput } from './types.ts';
 import type { CliCommandRuntime } from './management.ts';
@@ -35,6 +40,13 @@ function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
   }));
 }
 
+function routineReceiptStore(runtime: CliCommandRuntime): RoutineScheduleReceiptStore {
+  return RoutineScheduleReceiptStore.fromShellPaths(createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  }));
+}
+
 function summarizeRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
   const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
@@ -121,14 +133,16 @@ async function handleRoutinePromotion(runtime: CliCommandRuntime, args: readonly
   }
   const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
   const result = await promoteRoutineToDaemonSchedule(connection, preview);
+  const receipt = routineReceiptStore(runtime).append(connection, preview, result);
   if (!result.ok) {
     return {
-      output: json ? JSON.stringify(result, null, 2) : formatRoutineScheduleFailure(result),
+      output: json ? JSON.stringify({ ...result, receipt }, null, 2) : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`,
       exitCode: 1,
     };
   }
+  const value = { ...result, receipt };
   return {
-    output: jsonOrText(runtime, result, formatRoutineScheduleSuccess(result)),
+    output: jsonOrText(runtime, value, `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}`),
     exitCode: 0,
   };
 }
@@ -175,11 +189,55 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       exitCode: 0,
     };
   }
+  if (normalized === 'receipts' || normalized === 'history') {
+    const snapshot = routineReceiptStore(runtime).snapshot();
+    const value: RoutinesCommandSuccess<typeof snapshot> = {
+      ok: true,
+      kind: 'agent.routines.scheduleReceipts.list',
+      data: snapshot,
+    };
+    return {
+      output: jsonOrText(runtime, value, formatRoutineScheduleReceipts(snapshot)),
+      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 };
+    const receipt = routineReceiptStore(runtime).get(id);
+    if (!receipt) {
+      const failure: RoutinesCommandFailure = { ok: false, kind: 'routine_schedule_receipt_not_found', error: `Unknown routine schedule receipt: ${id}` };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 1,
+      };
+    }
+    const value: RoutinesCommandSuccess<typeof receipt> = {
+      ok: true,
+      kind: 'agent.routines.scheduleReceipts.get',
+      data: receipt,
+    };
+    return {
+      output: jsonOrText(runtime, value, formatRoutineScheduleReceipt(receipt)),
+      exitCode: 0,
+    };
+  }
   if (normalized === 'promote' || normalized === 'schedule' || normalized === 'promote-schedule') {
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|show <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,10 +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.',
+    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,12 +1,17 @@
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -52,6 +57,10 @@ function registryFromContext(ctx: CommandContext): AgentRoutineRegistry {
   return AgentRoutineRegistry.fromShellPaths(requireShellPaths(ctx));
 }
 
+function receiptStoreFromContext(ctx: CommandContext): RoutineScheduleReceiptStore {
+  return RoutineScheduleReceiptStore.fromShellPaths(requireShellPaths(ctx));
+}
+
 function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
   const value = flags.get(key)?.trim();
   if (!value) throw new Error(`Missing --${key}.`);
@@ -124,7 +133,8 @@ async function promoteRoutine(args: readonly string[], routineRegistry: AgentRou
   const shellPaths = requireShellPaths(ctx);
   const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
   const result = await promoteRoutineToDaemonSchedule(connection, preview);
-  ctx.print(result.ok ? formatRoutineScheduleSuccess(result) : formatRoutineScheduleFailure(result));
+  const receipt = receiptStoreFromContext(ctx).append(connection, preview, result);
+  ctx.print(result.ok ? `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}` : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`);
 }
 
 export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
@@ -155,6 +165,27 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(routine ? renderRoutine(routine) : `Unknown Agent routine: ${id}`);
       return;
     }
+    if (sub === 'receipts' || sub === 'history') {
+      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) {
+        ctx.print('Usage: /routines receipt <receipt-id>');
+        return;
+      }
+      const receipt = receiptStoreFromContext(ctx).get(id);
+      ctx.print(receipt ? formatRoutineScheduleReceipt(receipt) : `Unknown routine schedule receipt: ${id}`);
+      return;
+    }
     if (sub === 'create') {
       const parsed = parseRoutineArgs(args.slice(1));
       const steps = parsed.flags.get('steps')?.trim() || parsed.rest.join(' ').trim();
@@ -253,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|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);
   }
@@ -264,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,12 +7,17 @@ import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platfor
 import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleCorrelation,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
+  reconcileRoutineScheduleReceipts,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
 import type { CommandContext } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -73,7 +78,8 @@ async function promoteRoutineSchedule(args: readonly string[], ctx: CommandConte
   }
   const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
   const result = await promoteRoutineToDaemonSchedule(connection, preview);
-  ctx.print(result.ok ? formatRoutineScheduleSuccess(result) : formatRoutineScheduleFailure(result));
+  const receipt = RoutineScheduleReceiptStore.fromShellPaths(shellPaths).append(connection, preview, result);
+  ctx.print(result.ok ? `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}` : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`);
 }
 
 export function registerScheduleRuntimeCommands(registry: CommandRegistry): void {
@@ -81,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 | promote-routine <routine-id> --cron <expr> --yes',
-    argsHint: 'list | 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];
 
@@ -91,6 +97,30 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (sub === 'receipts' || sub === 'history') {
+        ctx.print(formatRoutineScheduleReceipts(RoutineScheduleReceiptStore.fromShellPaths(requireShellPaths(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, RoutineScheduleReceiptStore.fromShellPaths(shellPaths).snapshot());
+        ctx.print(formatRoutineScheduleCorrelation(result));
+        return;
+      }
+
+      if (sub === 'receipt') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /schedule receipt <receipt-id>');
+          return;
+        }
+        const receipt = RoutineScheduleReceiptStore.fromShellPaths(requireShellPaths(ctx)).get(id);
+        ctx.print(receipt ? formatRoutineScheduleReceipt(receipt) : `Unknown routine schedule receipt: ${id}`);
+        return;
+      }
+
       const manager = ctx.ops.automationManager;
       if (!manager) {
         ctx.print('Automation manager is not available in this runtime.');
@@ -127,6 +157,9 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
       ctx.print(
         '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

@@ -109,14 +109,14 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
   {
     id: 'automation-schedules',
     title: 'Automation, Schedules, And Routines',
-    posture: 'guarded',
+    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 and allows only explicitly confirmed side-effecting route calls; hidden model scheduling/spawn paths are blocked.',
-    configure: ['/schedule list', '/routines create ...', 'goodvibes-agent status'],
-    use: ['/schedule list', '/routines start <id>'],
-    exceedsBy: ['No recursive hidden scheduler creation from model tools', 'explicit confirmation for side effects', 'local routines separate from daemon jobs'],
-    next: ['Build Agent-first routine-to-daemon schedule promotion flow with preview, confirmation, delivery target selection, and audit trail.'],
+    goodvibesAgent: 'Observes public automation/schedule routes, keeps local routines separate from daemon jobs, and promotes a local routine into an external daemon schedules.create record only through an exact user command with --yes.',
+    configure: ['/schedule list', '/routines create ...', '/schedule promote-routine <id> --cron "0 8 * * *" --yes', 'goodvibes-agent routines promote <id> --every 1d --yes'],
+    use: ['/schedule list', '/routines start <id>', '/schedule promote-routine <id> --cron <expr> --yes'],
+    exceedsBy: ['No recursive hidden scheduler creation from model tools', 'explicit confirmation for side effects', 'local routines separate from daemon jobs', 'scheduled prompts preserve isolated Agent Knowledge and forbid default wiki/HomeGraph fallback'],
+    next: ['Add delivery target selection and deeper live run/delivery history for promoted routines.'],
   },
   {
     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.37';
+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 {