@pellux/goodvibes-agent 0.1.36 → 0.1.37

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.37 - 2026-05-31
+
+- 656b6f4 Add Agent routine daemon schedule promotion
+
 ## 0.1.36 - 2026-05-31
 
 - 9de2f5e Add guided Agent starter authoring

package/README.md

@@ -68,10 +68,13 @@ Local Agent behavior is editable from the TUI:
 /personas use research
 /routines create --name "Evening Review" --description "Review open work before shutdown" --steps "Check work plan, approvals, and Agent Knowledge status before summarizing." --enabled true
 /routines start evening-review
+/schedule promote-routine evening-review --cron "0 17 * * 1-5" --timezone America/Chicago --yes
 /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.
+
 ## Daemon Prerequisite
 
 Start or restart the daemon from GoodVibes TUI or the daemon host before launching Agent. Agent status and companion/knowledge routes connect to that external daemon, normally on `http://127.0.0.1:3421`.

package/docs/getting-started.md

@@ -70,12 +70,13 @@ Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They
 /personas use research
 /routines create --name "Evening Review" --description "Review open work before shutdown" --steps "Check work plan, approvals, and Agent Knowledge status before summarizing." --enabled true
 /routines start evening-review
+/schedule promote-routine evening-review --cron "0 17 * * 1-5" --timezone America/Chicago --yes
 /agent-skills create --name "Morning Brief" --description "Daily briefing flow" --procedure "Check tasks, approvals, calendar, and unread state before summarizing." --enabled true
 /agent-skills enabled
 /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.
+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.
 
 ## 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 | Guarded automation/schedule routes plus local routines; hidden model scheduling blocked |
+| 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 |
 | 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 |
@@ -66,6 +66,7 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 
 - Capability surfaces are discoverable through `goodvibes-agent capabilities`, `/capabilities`, onboarding, and the operator workspace.
 - Agent Knowledge isolation is a release gate, not a convention.
+- Routine-to-schedule promotion preserves Agent Knowledge isolation and uses only public external daemon schedule routes.
 - Model-visible tools are policy-gated for serial, non-secret, non-destructive use.
 - Personal assistant state is Agent-local unless an explicit Agent Knowledge ingest route is used.
 - Build work is delegated to the product that owns coding execution instead of turning the personal operator into a second coding TUI.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "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

@@ -0,0 +1,434 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { 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 { getModelIdFromProviderModel, getProviderIdFromModel } from '../config/provider-model.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';
+
+type ScheduleCreateInput = OperatorMethodInput<'schedules.create'>;
+type ScheduleCreateOutput = OperatorMethodOutput<'schedules.create'>;
+
+export interface AgentDaemonConfigReader {
+  get(key: string): unknown;
+}
+
+export interface AgentDaemonConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly tokenPath: string;
+}
+
+export type RoutineScheduleKind = 'cron' | 'every' | 'at';
+
+export interface RoutineScheduleSpec {
+  readonly kind: RoutineScheduleKind;
+  readonly value: string;
+}
+
+export interface ParsedRoutineSchedulePromotionArgs {
+  readonly routineId: string | null;
+  readonly schedule: RoutineScheduleSpec | null;
+  readonly name?: string;
+  readonly timezone?: string;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly enabled: boolean;
+  readonly yes: boolean;
+  readonly errors: readonly string[];
+}
+
+export interface RoutineSchedulePromotionPreview {
+  readonly routineId: string;
+  readonly routineName: string;
+  readonly route: typeof ROUTINE_SCHEDULE_ROUTE;
+  readonly method: typeof ROUTINE_SCHEDULE_METHOD;
+  readonly payload: ScheduleCreateInput;
+}
+
+export interface RoutineSchedulePromotionSuccess {
+  readonly ok: true;
+  readonly kind: typeof ROUTINE_SCHEDULE_METHOD;
+  readonly route: typeof ROUTINE_SCHEDULE_ROUTE;
+  readonly routineId: string;
+  readonly routineName: string;
+  readonly schedule: ScheduleCreateOutput;
+  readonly request: ScheduleCreateInput;
+}
+
+export interface RoutineSchedulePromotionFailure {
+  readonly ok: false;
+  readonly kind:
+    | 'confirmation_required'
+    | '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 RoutineSchedulePromotionResult =
+  | RoutineSchedulePromotionSuccess
+  | RoutineSchedulePromotionFailure;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === 'string' ? value : null;
+}
+
+function optionValue(args: readonly string[], index: number, inlineValue: string | undefined): {
+  readonly value: string | undefined;
+  readonly nextIndex: number;
+} {
+  if (inlineValue !== undefined) return { value: inlineValue, nextIndex: index };
+  const next = args[index + 1];
+  if (next === undefined || next.startsWith('--')) return { value: undefined, nextIndex: index };
+  return { value: next, nextIndex: index + 1 };
+}
+
+function normalizeProviderModel(provider: string | undefined, model: string | undefined): {
+  readonly provider?: string;
+  readonly model?: string;
+} {
+  if (!model) return provider ? { provider } : {};
+  const normalizedProvider = provider ?? getProviderIdFromModel(model);
+  return {
+    provider: normalizedProvider,
+    model: getModelIdFromProviderModel(model),
+  };
+}
+
+export function parseRoutineSchedulePromotionArgs(args: readonly string[]): ParsedRoutineSchedulePromotionArgs {
+  let routineId: string | null = null;
+  let schedule: RoutineScheduleSpec | null = null;
+  let name: string | undefined;
+  let timezone: string | undefined;
+  let provider: string | undefined;
+  let model: string | undefined;
+  let enabled = true;
+  let yes = false;
+  const errors: string[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const raw = args[index] ?? '';
+    const equals = raw.indexOf('=');
+    const optionName = equals >= 0 ? raw.slice(0, equals) : raw;
+    const inlineValue = equals >= 0 ? raw.slice(equals + 1) : undefined;
+
+    if (raw === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (raw === '--disabled') {
+      enabled = false;
+      continue;
+    }
+    if (optionName === '--name' || optionName === '--timezone' || optionName === '--provider' || optionName === '--model') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      if (optionName === '--name') name = value;
+      if (optionName === '--timezone') timezone = value;
+      if (optionName === '--provider') provider = value;
+      if (optionName === '--model') model = value;
+      continue;
+    }
+    if (optionName === '--cron' || optionName === '--every' || optionName === '--at') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      if (schedule) {
+        errors.push('Choose exactly one schedule selector: --cron, --every, or --at.');
+        continue;
+      }
+      schedule = {
+        kind: optionName === '--cron' ? 'cron' : optionName === '--every' ? 'every' : 'at',
+        value,
+      };
+      continue;
+    }
+    if (raw.startsWith('--')) {
+      errors.push(`Unknown option: ${raw}`);
+      continue;
+    }
+    if (!routineId) {
+      routineId = raw;
+      continue;
+    }
+    errors.push(`Unexpected argument: ${raw}`);
+  }
+
+  if (!routineId) errors.push('Routine id or name is required.');
+  if (!schedule) errors.push('Schedule is required: use --cron <expr>, --every <interval>, or --at <iso-time>.');
+  return { routineId, schedule, name, timezone, provider, model, enabled, yes, errors };
+}
+
+export function resolveAgentDaemonConnection(
+  configManager: AgentDaemonConfigReader,
+  homeDirectory: string,
+): AgentDaemonConnection {
+  const host = String(configManager.get('controlPlane.host') ?? '127.0.0.1');
+  const port = Number(configManager.get('controlPlane.port') ?? 3421);
+  const tokenPath = join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  if (!existsSync(tokenPath)) return { baseUrl: `http://${host}:${Number.isFinite(port) ? port : 3421}`, token: null, tokenPath };
+  try {
+    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
+    return { baseUrl: `http://${host}:${Number.isFinite(port) ? port : 3421}`, token, tokenPath };
+  } catch {
+    return { baseUrl: `http://${host}:${Number.isFinite(port) ? port : 3421}`, token: null, tokenPath };
+  }
+}
+
+export function buildRoutineSchedulePrompt(routine: AgentRoutineRecord): string {
+  return [
+    'GoodVibes Agent scheduled routine.',
+    '',
+    `Routine: ${routine.name}`,
+    `Routine id: ${routine.id}`,
+    `Review state: ${routine.reviewState}`,
+    `Tags: ${routine.tags.join(', ') || '(none)'}`,
+    `Triggers: ${routine.triggers.join(', ') || '(manual)'}`,
+    '',
+    'Operator policy:',
+    '- Run this as a serial GoodVibes Agent operator routine.',
+    '- Use isolated Agent Knowledge routes only; never use default Knowledge/Wiki or HomeGraph as fallback.',
+    '- Do not perform destructive, costly, externally visible, or secret-handling actions without explicit approval.',
+    '- Do not request WRFC unless this scheduled routine explicitly delegates build/fix/review work to GoodVibes TUI.',
+    '- Summarize what was checked, what changed, and what still needs user review.',
+    '',
+    'Routine description:',
+    routine.description,
+    '',
+    'Routine steps:',
+    routine.steps,
+  ].join('\n');
+}
+
+export function buildRoutineSchedulePayload(
+  routine: AgentRoutineRecord,
+  parsed: ParsedRoutineSchedulePromotionArgs,
+): ScheduleCreateInput {
+  if (!parsed.schedule) throw new Error('Schedule is required.');
+  const modelRoute = normalizeProviderModel(parsed.provider, parsed.model);
+  const payload: ScheduleCreateInput = {
+    name: parsed.name ?? `Agent routine: ${routine.name}`,
+    prompt: buildRoutineSchedulePrompt(routine),
+    kind: parsed.schedule.kind,
+    enabled: parsed.enabled,
+    target: {
+      kind: 'main',
+      surfaceKind: 'service',
+      preserveThread: true,
+      createIfMissing: true,
+    },
+    delivery: {
+      mode: 'none',
+      targets: [],
+      fallbackTargets: [],
+      includeSummary: true,
+      includeTranscript: false,
+      includeLinks: true,
+    },
+    failure: {
+      action: 'retry',
+      maxConsecutiveFailures: 3,
+      cooldownMs: 3_600_000,
+      retryPolicy: {
+        maxAttempts: 2,
+        delayMs: 60_000,
+        strategy: 'exponential',
+        maxDelayMs: 900_000,
+        jitterMs: 30_000,
+      },
+      disableAfterFailures: false,
+    },
+    lightContext: true,
+    autoApprove: false,
+    allowUnsafeExternalContent: false,
+    ...modelRoute,
+  };
+  if (parsed.schedule.kind === 'cron') {
+    return {
+      ...payload,
+      cron: parsed.schedule.value,
+      timezone: parsed.timezone,
+    };
+  }
+  if (parsed.schedule.kind === 'every') {
+    return { ...payload, every: parsed.schedule.value };
+  }
+  return { ...payload, at: parsed.schedule.value };
+}
+
+export function buildRoutineSchedulePreview(
+  routine: AgentRoutineRecord,
+  parsed: ParsedRoutineSchedulePromotionArgs,
+): RoutineSchedulePromotionPreview {
+  return {
+    routineId: routine.id,
+    routineName: routine.name,
+    route: ROUTINE_SCHEDULE_ROUTE,
+    method: ROUTINE_SCHEDULE_METHOD,
+    payload: buildRoutineSchedulePayload(routine, parsed),
+  };
+}
+
+async function fetchDaemonStatus(connection: AgentDaemonConnection): Promise<{
+  readonly ok: boolean;
+  readonly status: number;
+  readonly body: unknown;
+}> {
+  try {
+    const response = await fetch(`${connection.baseUrl}/status`, {
+      headers: connection.token ? { authorization: `Bearer ${connection.token}` } : undefined,
+    });
+    const text = await response.text();
+    let body: unknown = text;
+    try {
+      body = text.trim() ? JSON.parse(text) as unknown : {};
+    } catch {
+      body = text;
+    }
+    return { ok: response.ok, status: response.status, body };
+  } catch (error) {
+    return { ok: false, status: 0, body: summarizeError(error) };
+  }
+}
+
+async function classifyScheduleError(
+  error: unknown,
+  connection: AgentDaemonConnection,
+): Promise<RoutineSchedulePromotionFailure> {
+  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.create 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,
+): Promise<RoutineSchedulePromotionResult> {
+  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 schedule = await sdk.operator.invoke(ROUTINE_SCHEDULE_METHOD, preview.payload);
+    return {
+      ok: true,
+      kind: ROUTINE_SCHEDULE_METHOD,
+      route: ROUTINE_SCHEDULE_ROUTE,
+      routineId: preview.routineId,
+      routineName: preview.routineName,
+      schedule,
+      request: preview.payload,
+    };
+  } catch (error) {
+    return classifyScheduleError(error, connection);
+  }
+}
+
+export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPreview): string {
+  const schedule = preview.payload.kind === 'cron'
+    ? `${preview.payload.cron}${preview.payload.timezone ? ` [${preview.payload.timezone}]` : ''}`
+    : preview.payload.kind === 'every'
+      ? String(preview.payload.every)
+      : String(preview.payload.at);
+  return [
+    'Daemon schedule preview for Agent routine',
+    `  routine: ${preview.routineName} (${preview.routineId})`,
+    `  route: ${preview.method} ${preview.route}`,
+    `  name: ${String(preview.payload.name ?? '(daemon default)')}`,
+    `  schedule: ${preview.payload.kind} ${schedule}`,
+    `  enabled: ${preview.payload.enabled === false ? 'no' : 'yes'}`,
+    '  target: external daemon service/main conversation route',
+    '  policy: isolated Agent Knowledge only; no default wiki/HomeGraph fallback; no WRFC unless explicitly delegated',
+    '  next: rerun with --yes to create this daemon schedule',
+  ].join('\n');
+}
+
+export function formatRoutineScheduleSuccess(result: RoutineSchedulePromotionSuccess): string {
+  const record: Record<string, unknown> = isRecord(result.schedule) ? result.schedule : {};
+  const id = readString(record, 'id') ?? '(unknown)';
+  const status = readString(record, 'status') ?? (record.enabled === false ? 'paused' : 'enabled');
+  return [
+    'Created daemon schedule for Agent routine',
+    `  routine: ${result.routineName} (${result.routineId})`,
+    `  schedule: ${id}`,
+    `  status: ${status}`,
+    `  route: ${result.kind} ${result.route}`,
+    '  next: inspect with /schedule list or daemon schedule observability',
+  ].join('\n');
+}
+
+export function formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFailure): string {
+  return [
+    `Daemon schedule error: ${failure.kind}`,
+    `  ${failure.error}`,
+    failure.baseUrl ? `  daemon: ${failure.baseUrl}` : null,
+    `  route: ${ROUTINE_SCHEDULE_METHOD} ${failure.route}`,
+    failure.kind === 'version_mismatch' && failure.daemonVersion && failure.expectedSdkVersion
+      ? `  versions: daemon=${failure.daemonVersion} expected=${failure.expectedSdkVersion}`
+      : null,
+    failure.kind === 'auth_required'
+      ? '  next: pair/authenticate with the externally managed GoodVibes daemon, then retry with --yes.'
+      : null,
+    failure.kind === 'daemon_unavailable'
+      ? '  next: start/restart the external GoodVibes daemon from TUI or daemon host tooling; Agent does not own daemon lifecycle.'
+      : null,
+    failure.kind === 'version_mismatch' || failure.kind === 'daemon_route_unavailable'
+      ? '  next: update/restart the external GoodVibes daemon so public schedules.create is available.'
+      : null,
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}

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,21 @@ 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 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.',
+    examples: [
+      'routines list',
+      'routines show daily-operations-sweep',
+      '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,185 @@
+import { createShellPathService } from '@/runtime/index.ts';
+import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import {
+  buildRoutineSchedulePreview,
+  formatRoutineScheduleFailure,
+  formatRoutineSchedulePreview,
+  formatRoutineScheduleSuccess,
+  parseRoutineSchedulePromotionArgs,
+  promoteRoutineToDaemonSchedule,
+  resolveAgentDaemonConnection,
+} 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 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);
+  if (!result.ok) {
+    return {
+      output: json ? JSON.stringify(result, null, 2) : formatRoutineScheduleFailure(result),
+      exitCode: 1,
+    };
+  }
+  return {
+    output: jsonOrText(runtime, result, formatRoutineScheduleSuccess(result)),
+    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 === '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]',
+    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,12 @@ 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.',
     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-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,13 @@
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
+import {
+  buildRoutineSchedulePreview,
+  formatRoutineScheduleFailure,
+  formatRoutineSchedulePreview,
+  formatRoutineScheduleSuccess,
+  parseRoutineSchedulePromotionArgs,
+  promoteRoutineToDaemonSchedule,
+  resolveAgentDaemonConnection,
+} from '../../agent/routine-schedule-promotion.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
@@ -93,6 +102,31 @@ 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);
+  ctx.print(result.ok ? formatRoutineScheduleSuccess(result) : formatRoutineScheduleFailure(result));
+}
+
 export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
   const sub = (args[0] ?? 'list').toLowerCase();
   const routineRegistry = registryFromContext(ctx);
@@ -200,6 +234,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 +253,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|create|update|enable|disable|start|review|stale|promote|delete]');
   } catch (error) {
     printError(ctx, error);
   }
@@ -226,7 +264,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,18 @@ 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,
+  formatRoutineScheduleFailure,
+  formatRoutineSchedulePreview,
+  formatRoutineScheduleSuccess,
+  parseRoutineSchedulePromotionArgs,
+  promoteRoutineToDaemonSchedule,
+  resolveAgentDaemonConnection,
+} 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 +43,66 @@ 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);
+  ctx.print(result.ok ? formatRoutineScheduleSuccess(result) : formatRoutineScheduleFailure(result));
+}
+
 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 | promote-routine <routine-id> --cron <expr> --yes',
+    argsHint: 'list | 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;
+      }
+
       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 +127,8 @@ 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 promote-routine <routine-id> (--cron <expr>|--every <interval>|--at <iso-time>) --yes\n'
+        + '  Local schedule mutations and runs remain blocked.'
       );
     },
   });

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