@pellux/goodvibes-agent 0.1.37 → 0.1.38

package/CHANGELOG.md

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

package/docs/getting-started.md

@@ -76,7 +76,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; 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.38",
   "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,9 +1,11 @@
-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 { 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';
 
@@ -80,6 +82,47 @@ 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[];
+}
+
+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 +132,15 @@ 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 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 +163,198 @@ 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 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;
@@ -412,6 +656,49 @@ 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 formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFailure): string {
   return [
     `Daemon schedule error: ${failure.kind}`,

package/src/cli/help.ts

@@ -165,12 +165,15 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
       'routines list',
       'routines enabled',
       'routines show <id>',
+      'routines receipts',
+      '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, 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 promote weekly-review --every 7d --disabled',
     ],

package/src/cli/routines-command.ts

@@ -2,12 +2,15 @@ import { createShellPathService } from '@/runtime/index.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../agent/routine-schedule-promotion.ts';
 import type { CliCommandOutput } from './types.ts';
 import type { CliCommandRuntime } from './management.ts';
@@ -35,6 +38,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 +131,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 +187,44 @@ 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 === '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|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) --yes]',
     exitCode: 2,
   };
 }

package/src/input/agent-workspace.ts

@@ -573,10 +573,11 @@ 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 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-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-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,15 @@
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -52,6 +55,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 +131,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 +163,20 @@ 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 === '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 +275,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|receipt|create|update|enable|disable|start|review|stale|promote|delete]');
   } catch (error) {
     printError(ctx, error);
   }

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

@@ -7,12 +7,15 @@ import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platfor
 import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
+  formatRoutineScheduleReceipt,
+  formatRoutineScheduleReceipts,
   formatRoutineScheduleFailure,
   formatRoutineSchedulePreview,
   formatRoutineScheduleSuccess,
   parseRoutineSchedulePromotionArgs,
   promoteRoutineToDaemonSchedule,
   resolveAgentDaemonConnection,
+  RoutineScheduleReceiptStore,
 } from '../../agent/routine-schedule-promotion.ts';
 import type { CommandContext } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -73,7 +76,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 +85,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 | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
+    argsHint: 'list | receipts | receipt <id> | promote-routine <routine-id> --cron <expr> --yes',
     async handler(args, ctx) {
       const sub = args[0];
 
@@ -91,6 +95,22 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      if (sub === 'receipts' || sub === 'history') {
+        ctx.print(formatRoutineScheduleReceipts(RoutineScheduleReceiptStore.fromShellPaths(requireShellPaths(ctx)).snapshot()));
+        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 +147,8 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
       ctx.print(
         'Usage:\n'
         + '  /schedule list\n'
+        + '  /schedule receipts\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 live schedule recovery/status correlation 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.38';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {