@pellux/goodvibes-agent 0.1.36 → 0.1.38

package/src/cli/completion.ts

@@ -12,6 +12,7 @@ const COMMANDS = [
   'models',
   'providers',
   'profiles',
+  'routines',
   'auth',
   'compat',
   'capabilities',

package/src/cli/help.ts

@@ -39,6 +39,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  models [provider]          List/use/pin selectable models and recent model history',
     '  providers                  List/inspect/use provider config/auth posture',
     '  profiles                   Manage isolated Agent runtime profile homes',
+    '  routines                   Inspect local routines and explicitly promote one to a daemon schedule',
     '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
     '  compat                     Inspect Agent SDK pin, daemon version, and Agent knowledge route readiness',
     '  capabilities               Show OpenClaw/Hermes capability parity and Agent readiness',
@@ -98,6 +99,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} providers inspect openai`,
     `  ${binary} profiles create household --template household --yes`,
     `  ${binary} --agent-profile household`,
+    `  ${binary} routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --yes`,
     `  ${binary} compat`,
     `  ${binary} capabilities`,
     `  ${binary} knowledge status`,
@@ -158,6 +160,24 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Create and inspect isolated Agent runtime profile homes, with starter templates for household, research, travel, operations, personal productivity, and local imported starters. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the externally owned daemon.',
     examples: ['profiles templates', 'profiles templates export research ./research-starter.json --yes', 'profiles templates import ./research-starter.json --yes', 'profiles create household --template household --yes', '--agent-profile household status'],
   },
+  routines: {
+    usage: [
+      '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, 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',
+    ],
+  },
   models: {
     usage: ['models [provider]', 'models current', 'models use <registryKey>', 'models pin <registryKey>', 'models recent'],
     summary: 'List, inspect, select, pin, and review model choices.',

package/src/cli/management.ts

@@ -35,6 +35,7 @@ import { buildControlPlaneStatusResult, formatControlPlaneStatus, handleSecrets,
 import { handleAgentKnowledgeCommand, handleAgentKnowledgeShortcutCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
 import { handleCapabilitiesCommand } from './capabilities-command.ts';
 import { handleProfilesCommand } from './profiles-command.ts';
+import { handleRoutinesCommand } from './routines-command.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface CliCommandRuntime {
@@ -710,6 +711,11 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(result.output);
         return { handled: true, exitCode: result.exitCode };
       }
+      case 'routines': {
+        const result = await handleRoutinesCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       case 'knowledge': {
         const result = await handleAgentKnowledgeCommand(runtime);
         console.log(result.output);

package/src/cli/parser.ts

@@ -27,6 +27,8 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   provider: 'providers',
   profiles: 'profiles',
   profile: 'profiles',
+  routines: 'routines',
+  routine: 'routines',
   auth: 'auth',
   compat: 'compat',
   compatibility: 'compat',

package/src/cli/routines-command.ts

@@ -0,0 +1,230 @@
+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';
+
+interface RoutinesCommandSuccess<TData> {
+  readonly ok: true;
+  readonly kind: string;
+  readonly data: TData;
+}
+
+interface RoutinesCommandFailure {
+  readonly ok: false;
+  readonly kind: string;
+  readonly error: string;
+}
+
+function jsonOrText(runtime: CliCommandRuntime, value: unknown, text: string): string {
+  return runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text;
+}
+
+function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
+  return AgentRoutineRegistry.fromShellPaths(createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  }));
+}
+
+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(',')}` : '';
+  return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
+}
+
+function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[]): string {
+  if (routines.length === 0) {
+    return [
+      title,
+      '  No local Agent routines yet.',
+      '  Create routines inside the Agent TUI with /routines create, or create a runtime profile from a starter template.',
+    ].join('\n');
+  }
+  return [
+    `${title} (${routines.length})`,
+    `  store: ${path}`,
+    ...routines.map(summarizeRoutine),
+  ].join('\n');
+}
+
+function renderRoutine(routine: AgentRoutineRecord): string {
+  return [
+    `Routine ${routine.name}`,
+    `  id: ${routine.id}`,
+    `  enabled: ${routine.enabled ? 'yes' : 'no'}`,
+    `  review: ${routine.reviewState}`,
+    `  source: ${routine.source}`,
+    `  provenance: ${routine.provenance}`,
+    `  tags: ${routine.tags.join(', ') || '(none)'}`,
+    `  triggers: ${routine.triggers.join(', ') || '(manual)'}`,
+    `  started: ${routine.startCount}${routine.lastStartedAt ? `; last ${routine.lastStartedAt}` : ''}`,
+    `  created: ${routine.createdAt}`,
+    `  updated: ${routine.updatedAt}`,
+    routine.staleReason ? `  stale reason: ${routine.staleReason}` : '',
+    '',
+    routine.description,
+    '',
+    routine.steps,
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+async function handleRoutinePromotion(runtime: CliCommandRuntime, args: readonly string[]): Promise<CliCommandOutput> {
+  const parsed = parseRoutineSchedulePromotionArgs(args);
+  const json = runtime.cli.flags.outputFormat === 'json';
+  if (parsed.errors.length > 0) {
+    const failure: RoutinesCommandFailure = {
+      ok: false,
+      kind: 'invalid_routine_schedule_promotion',
+      error: parsed.errors.join(' '),
+    };
+    return {
+      output: json ? JSON.stringify(failure, null, 2) : [
+        'Usage: goodvibes-agent routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+        ...parsed.errors.map((error) => `  ${error}`),
+      ].join('\n'),
+      exitCode: 2,
+    };
+  }
+  const registry = routineRegistry(runtime);
+  const routine = registry.get(parsed.routineId ?? '');
+  if (!routine) {
+    const failure: RoutinesCommandFailure = {
+      ok: false,
+      kind: 'routine_not_found',
+      error: `Unknown Agent routine: ${parsed.routineId ?? ''}`,
+    };
+    return {
+      output: json ? JSON.stringify(failure, null, 2) : failure.error,
+      exitCode: 1,
+    };
+  }
+  const preview = buildRoutineSchedulePreview(routine, parsed);
+  if (!parsed.yes) {
+    const value: RoutinesCommandSuccess<typeof preview> = {
+      ok: true,
+      kind: 'schedules.create.preview',
+      data: preview,
+    };
+    return {
+      output: jsonOrText(runtime, value, formatRoutineSchedulePreview(preview)),
+      exitCode: 0,
+    };
+  }
+  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, receipt }, null, 2) : `${formatRoutineScheduleFailure(result)}\n  receipt: ${receipt.id}`,
+      exitCode: 1,
+    };
+  }
+  const value = { ...result, receipt };
+  return {
+    output: jsonOrText(runtime, value, `${formatRoutineScheduleSuccess(result)}\n  receipt: ${receipt.id}`),
+    exitCode: 0,
+  };
+}
+
+export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  const [sub = 'list', ...rest] = runtime.cli.commandArgs;
+  const registry = routineRegistry(runtime);
+  const snapshot = registry.snapshot();
+  const normalized = sub.toLowerCase();
+  if (normalized === 'list' || normalized === 'enabled') {
+    const routines = normalized === 'enabled' ? snapshot.enabledRoutines : snapshot.routines;
+    const value: RoutinesCommandSuccess<{
+      readonly path: string;
+      readonly routines: readonly AgentRoutineRecord[];
+      readonly enabledCount: number;
+    }> = {
+      ok: true,
+      kind: normalized === 'enabled' ? 'agent.routines.enabled' : 'agent.routines.list',
+      data: {
+        path: snapshot.path,
+        routines,
+        enabledCount: snapshot.enabledRoutines.length,
+      },
+    };
+    return {
+      output: jsonOrText(runtime, value, renderRoutineList(normalized === 'enabled' ? 'Enabled Agent routines' : 'Agent routines', snapshot.path, routines)),
+      exitCode: 0,
+    };
+  }
+  if (normalized === 'show') {
+    const id = rest[0];
+    if (!id) return { output: 'Usage: goodvibes-agent routines show <id>', exitCode: 2 };
+    const routine = registry.get(id);
+    if (!routine) {
+      const failure: RoutinesCommandFailure = { ok: false, kind: 'routine_not_found', error: `Unknown Agent routine: ${id}` };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 1,
+      };
+    }
+    const value: RoutinesCommandSuccess<AgentRoutineRecord> = { ok: true, kind: 'agent.routines.show', data: routine };
+    return {
+      output: jsonOrText(runtime, value, renderRoutine(routine)),
+      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>|receipts|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) --yes]',
+    exitCode: 2,
+  };
+}

package/src/cli/types.ts

@@ -10,6 +10,7 @@ export type GoodVibesCliCommand =
   | 'models'
   | 'providers'
   | 'profiles'
+  | 'routines'
   | 'auth'
   | 'compat'
   | 'capabilities'

package/src/input/agent-workspace.ts

@@ -572,11 +572,13 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     id: 'automation',
     group: 'WATCH',
     label: 'Automation',
-    summary: 'Read-only automation and schedule observability.',
-    detail: 'Agent does not create, run, enable, disable, or remove local automation jobs. Schedule mutations wait for an Agent-safe public route and explicit approval.',
+    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.',
     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-policy', label: 'Mutation blocked', detail: 'Schedule add/run/remove/enable/disable are intentionally blocked in Agent.', kind: 'guidance', safety: 'blocked' },
+      { 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,4 +1,16 @@
 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';
 
@@ -43,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}.`);
@@ -93,6 +109,32 @@ function printError(ctx: CommandContext, error: unknown): void {
   ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
 }
 
+async function promoteRoutine(args: readonly string[], routineRegistry: AgentRoutineRegistry, ctx: CommandContext): Promise<void> {
+  const parsed = parseRoutineSchedulePromotionArgs(args);
+  if (parsed.errors.length > 0) {
+    ctx.print([
+      'Usage: /routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+      ...parsed.errors.map((error) => `  ${error}`),
+    ].join('\n'));
+    return;
+  }
+  const routine = routineRegistry.get(parsed.routineId ?? '');
+  if (!routine) {
+    ctx.print(`Unknown Agent routine: ${parsed.routineId ?? ''}`);
+    return;
+  }
+  const preview = buildRoutineSchedulePreview(routine, parsed);
+  if (!parsed.yes) {
+    ctx.print(formatRoutineSchedulePreview(preview));
+    return;
+  }
+  const shellPaths = requireShellPaths(ctx);
+  const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await promoteRoutineToDaemonSchedule(connection, preview);
+  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> {
   const sub = (args[0] ?? 'list').toLowerCase();
   const routineRegistry = registryFromContext(ctx);
@@ -121,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();
@@ -200,6 +256,10 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(`Marked Agent routine ${routine.id} stale.`);
       return;
     }
+    if (sub === 'promote' || sub === 'schedule' || sub === 'promote-schedule') {
+      await promoteRoutine(args.slice(1), routineRegistry, ctx);
+      return;
+    }
     if (sub === 'delete' || sub === 'remove') {
       const parsed = parseRoutineArgs(args.slice(1));
       const id = parsed.rest[0];
@@ -215,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|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);
   }
@@ -226,7 +286,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...>|delete <id> --yes]',
+    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]',
     handler: runRoutinesRuntimeCommand,
   });
 }

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

@@ -4,6 +4,21 @@ import {
 } from '@pellux/goodvibes-sdk/platform/automation';
 import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
 import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation';
+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';
 
 function formatSchedule(schedule: AutomationScheduleDefinition): string {
   switch (schedule.kind) {
@@ -31,35 +46,83 @@ function formatPrompt(job: AutomationJob): string {
 
 function printReadOnlyScheduleBoundary(print: (text: string) => void, requestedAction: string): void {
   print([
-    'GoodVibes Agent schedule commands are read-only in this runtime.',
+    'GoodVibes Agent local schedule commands are read-only in this runtime.',
     `  requested: ${requestedAction}`,
     '  policy: no local Agent automation jobs, scheduled spawns, or immediate automation runs',
     '  use: /schedule list',
-    '  future: mutate schedules through an Agent-safe public daemon route after explicit approval',
+    '  daemon route: use /schedule promote-routine <routine> --cron <expr> --yes to create an external daemon schedule explicitly',
   ].join('\n'));
 }
 
+async function promoteRoutineSchedule(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const parsed = parseRoutineSchedulePromotionArgs(args);
+  if (parsed.errors.length > 0) {
+    ctx.print([
+      'Usage: /schedule promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--disabled] --yes',
+      ...parsed.errors.map((error) => `  ${error}`),
+    ].join('\n'));
+    return;
+  }
+  const shellPaths = requireShellPaths(ctx);
+  const routine = AgentRoutineRegistry.fromShellPaths(shellPaths).get(parsed.routineId ?? '');
+  if (!routine) {
+    ctx.print(`Unknown Agent routine: ${parsed.routineId ?? ''}`);
+    return;
+  }
+  const preview = buildRoutineSchedulePreview(routine, parsed);
+  if (!parsed.yes) {
+    ctx.print(formatRoutineSchedulePreview(preview));
+    return;
+  }
+  const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await promoteRoutineToDaemonSchedule(connection, preview);
+  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 {
   registry.register({
     name: 'schedule',
     aliases: ['sched'],
-    description: 'Inspect automation jobs and scheduled runs',
-    usage: 'list',
-    argsHint: 'list',
+    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',
     async handler(args, ctx) {
+      const sub = args[0];
+
+      if (sub === 'promote-routine' || sub === 'promote' || sub === 'create-routine-schedule') {
+        await promoteRoutineSchedule(args.slice(1), ctx);
+        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.');
         return;
       }
-      const sub = args[0];
 
       if (!sub || sub === 'list') {
         const jobs = manager.listJobs();
         if (jobs.length === 0) {
           ctx.print(
             'No automation jobs.\n'
-            + 'Agent schedule commands are read-only here; create/run/enable/disable/remove are blocked until an Agent-safe route exists.'
+            + 'Local add/run/enable/disable/remove are blocked. Use /schedule promote-routine <routine> --cron <expr> --yes for an explicit external daemon schedule.'
           );
           return;
         }
@@ -84,7 +147,10 @@ export function registerScheduleRuntimeCommands(registry: CommandRegistry): void
       ctx.print(
         'Usage:\n'
         + '  /schedule list\n'
-        + '  Agent schedule mutations and runs are blocked until an Agent-safe route exists.'
+        + '  /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.36';
+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 {