@pellux/goodvibes-agent 0.1.35 → 0.1.37

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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
+
 ## 0.1.35 - 2026-05-31
 
 - 2c25d5e Add local starter profile import export

package/README.md

@@ -46,6 +46,8 @@ Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator
 
 Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps.
 
+Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated runtime profiles from them.
+
 Use isolated Agent runtime profiles when one machine needs separate operator identities or local state:
 
 ```sh
@@ -66,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/README.md

@@ -21,7 +21,7 @@ Important baseline constraints:
 - Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`; there is no default Knowledge/Wiki, HomeGraph, or Home Assistant fallback.
 - Agent exposes `goodvibes-agent capabilities` and `/capabilities` to compare OpenClaw/Hermes capability targets against current Agent readiness and configuration paths.
 - Agent supports isolated runtime homes with `GOODVIBES_AGENT_HOME=<path>` and named profile homes with `goodvibes-agent profiles create <name> --template <starter> --yes` plus `--agent-profile <name>`.
-- Agent ships starter profile templates for household, research, travel, operations, and personal productivity local state; `profiles templates export/import` supports local custom starters.
+- Agent ships starter profile templates for household, research, travel, operations, and personal productivity local state; `profiles templates export/import` and `/agent-profile guide` support local custom starters.
 - Local personas, routines, and Agent skills are stored under the Agent surface root and are injected only into the serial Agent conversation.
 - Normal assistant chat is not coding-session delegation.
 - Build/fix/review delegation to GoodVibes TUI must be explicit; WRFC is not the default Agent behavior.

package/docs/getting-started.md

@@ -37,6 +37,8 @@ bun run dev
 
 Once the TUI opens, run `/agent`, `/home`, or `/operator` to open the Agent operator workspace. That fullscreen workspace is the current front door for setup/config, knowledge status, local memory and skills, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+Use `/agent-profile guide` inside that workspace to walk through starter-profile authoring. It lists built-in and local starters, exports a JSON starter for editing, imports the edited starter back into this Agent home, and creates isolated profiles from the result.
+
 ## Isolated Agent Profiles
 
 Use a separate Agent home when you want isolated local state:
@@ -68,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,11 +53,11 @@ 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 |
-| Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; starter templates seed local personas/skills/routines; starter JSON can be exported/imported for local custom lanes; the Agent workspace exposes profile and portability flows; daemon remains external |
+| Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; starter templates seed local personas/skills/routines; starter JSON can be exported/imported for local custom lanes; `/agent-profile guide` brings starter authoring into the Agent workspace; daemon remains external |
 | Security | DM pairing, approvals, sandboxing, allowlists | Daemon approvals, auth diagnostics, secret refs, confirmation gates, model-tool policy |
 
 ## Exceed Targets
@@ -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.
@@ -75,7 +76,7 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 
 - Live daemon account health and last delivery errors in the Channels workspace once a stable read-only route is available.
 - Artifact and multimodal Agent Knowledge ingest affordances once Agent-specific routes are stable.
-- Guided starter profile authoring inside the fullscreen Agent workspace.
+- 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.
 - Delegation receipts and artifact review inside the operator workspace.
 - Approval center with route risk labels and saved policy presets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.35",
+  "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/agent/runtime-profile.ts

@@ -615,6 +615,10 @@ export function getAgentRuntimeProfileTemplate(templateId: AgentRuntimeProfileTe
   return summarizeTemplate(resolveAgentRuntimeProfileTemplate(templateId, baseHomeDirectory));
 }
 
+export function getAgentRuntimeProfileTemplateFile(templateId: AgentRuntimeProfileTemplateId, baseHomeDirectory?: string): AgentRuntimeProfileStarterTemplateFile {
+  return templateFilePayload(resolveAgentRuntimeProfileTemplate(templateId, baseHomeDirectory));
+}
+
 function templateFilePayload(template: AgentRuntimeProfileStarterTemplate): AgentRuntimeProfileStarterTemplateFile {
   return {
     version: 1,

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',