@pellux/goodvibes-agent 0.1.35 → 0.1.37

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

@@ -4,7 +4,7 @@ import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
-import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles } from '../agent/runtime-profile.ts';
+import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -97,6 +97,8 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly activeRuntimeProfile: string;
   readonly runtimeProfileCount: number;
   readonly runtimeProfileRoot: string;
+  readonly runtimeStarterTemplateCount: number;
+  readonly localStarterTemplateCount: number;
   readonly configProfileCount: number;
   readonly warnings: readonly string[];
 }
@@ -378,6 +380,13 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return 0;
     }
   })();
+  const runtimeStarterTemplates = (() => {
+    try {
+      return listAgentRuntimeProfileTemplates(context.workspace?.shellPaths?.homeDirectory ?? '');
+    } catch {
+      return [];
+    }
+  })();
   const voiceProviders = (() => {
     try {
       return context.platform?.voiceProviderRegistry?.list?.() ?? [];
@@ -437,6 +446,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeProfileCount: runtimeProfiles.length,
     runtimeProfileRoot: getAgentRuntimeProfilesRoot(context.workspace?.shellPaths?.homeDirectory ?? ''),
+    runtimeStarterTemplateCount: runtimeStarterTemplates.length,
+    localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
     configProfileCount,
     warnings,
   };
@@ -522,11 +533,13 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Hermes profiles isolate agent state. GoodVibes Agent exposes named runtime homes, config profile pickers, profile-sync bundles, setup transfer bundles, and support bundles while keeping the daemon external.',
     actions: [
       { id: 'profiles-open', label: 'Open config profiles', detail: 'Open the TUI-derived config profile picker for display/provider/behavior profile files.', command: '/profiles', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-guide', label: 'Starter authoring guide', detail: 'Open the Agent-local starter authoring flow inside the TUI command surface.', command: '/agent-profile guide', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-templates', label: 'Browse starter templates', detail: 'List built-in and local Agent starter templates with persona, skill, routine, and source details.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
       { id: 'profile-sync-list', label: 'Profile sync list', detail: 'Inspect saved config profiles available for export/import.', command: '/profilesync list', kind: 'command', safety: 'read-only' },
       { id: 'profile-sync-export', label: 'Export profile sync', detail: 'Export config profiles to a portable bundle. Requires a real path and explicit --yes.', command: '/profilesync export <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'setup-transfer-export', label: 'Export setup transfer', detail: 'Export Agent setup transfer data from the current home. Requires a real path and explicit --yes.', command: '/setup transfer export <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'runtime-profile-create', label: 'Create runtime profile', detail: 'Use goodvibes-agent profiles templates, then goodvibes-agent profiles create <name> --template <id> --yes. Starters seed local personas, skills, and routines without touching the daemon.', kind: 'guidance', safety: 'safe' },
-      { id: 'runtime-profile-template-edit', label: 'Customize starter', detail: 'Use goodvibes-agent profiles templates export <id> <path> --yes, edit the JSON, then import it with profiles templates import <path> --yes.', kind: 'guidance', safety: 'safe' },
+      { id: 'runtime-profile-create', label: 'Create runtime profile', detail: 'Create an isolated Agent runtime profile from a built-in or local starter. Requires a real name and explicit --yes.', command: '/agent-profile create <name> --template <id> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-template-edit', label: 'Customize starter', detail: 'Export a starter JSON file, edit it, import it as a local starter, then create a profile from it.', command: '/agent-profile template export <id> <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-switch', label: 'Switch runtime profile', detail: 'Launch goodvibes-agent --agent-profile <name> to use that isolated Agent home. This workspace cannot switch the current process home after startup.', kind: 'guidance', safety: 'safe' },
     ],
   },
@@ -559,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/agent-runtime-profile-runtime.ts

@@ -0,0 +1,223 @@
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  createAgentRuntimeProfile,
+  deleteAgentRuntimeProfile,
+  exportAgentRuntimeProfileTemplate,
+  getAgentRuntimeProfileTemplateFile,
+  importAgentRuntimeProfileTemplate,
+  listAgentRuntimeProfiles,
+  listAgentRuntimeProfileTemplates,
+  type AgentRuntimeProfileInfo,
+  type AgentRuntimeProfileTemplateSummary,
+} from '../../agent/runtime-profile.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+function parseFlag(args: readonly string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  return value && !value.startsWith('--') ? value : undefined;
+}
+
+function profileLine(profile: AgentRuntimeProfileInfo): string {
+  const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
+  const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
+  return `  ${profile.id}  home=${profile.homeDirectory}${created}${starter}`;
+}
+
+function templateLine(template: AgentRuntimeProfileTemplateSummary): string {
+  const source = template.source === 'local' ? `local ${template.path ?? ''}`.trim() : 'builtin';
+  return [
+    `  ${template.id}  [${source}]`,
+    `    ${template.name}: ${template.description}`,
+    `    persona: ${template.personaName}`,
+    `    skills: ${template.skillNames.join(', ')}`,
+    `    routines: ${template.routineNames.join(', ')}`,
+  ].join('\n');
+}
+
+function renderProfiles(homeDirectory: string): string {
+  const profiles = listAgentRuntimeProfiles(homeDirectory);
+  if (profiles.length === 0) {
+    return [
+      'Agent Runtime Profiles',
+      '  No isolated Agent runtime profiles yet.',
+      '  Create one with /agent-profile create <name> --template <id> --yes.',
+    ].join('\n');
+  }
+  return ['Agent Runtime Profiles', ...profiles.map(profileLine)].join('\n');
+}
+
+function renderTemplates(homeDirectory: string): string {
+  const templates = listAgentRuntimeProfileTemplates(homeDirectory);
+  return [
+    `Agent Starter Templates (${templates.length})`,
+    ...templates.map(templateLine),
+    '',
+    'Authoring flow:',
+    '  /agent-profile template export research ./agent-starter.json --yes',
+    '  edit the JSON file',
+    '  /agent-profile template import ./agent-starter.json --yes',
+    '  /agent-profile create <name> --template <imported-id> --yes',
+  ].join('\n');
+}
+
+function renderGuide(homeDirectory: string): string {
+  const templates = listAgentRuntimeProfileTemplates(homeDirectory);
+  const localCount = templates.filter((template) => template.source === 'local').length;
+  return [
+    'Agent Starter Authoring Guide',
+    `  built-in starters: ${templates.length - localCount}`,
+    `  local starters: ${localCount}`,
+    '',
+    '1. Pick a base starter:',
+    '   /agent-profile templates',
+    '2. Export a starter JSON file:',
+    '   /agent-profile template export research ./agent-starter.json --yes',
+    '3. Edit id, name, description, persona, skills, and routines in that JSON file.',
+    '4. Import it into this Agent home:',
+    '   /agent-profile template import ./agent-starter.json --yes',
+    '5. Create a runtime profile from the imported starter:',
+    '   /agent-profile create <name> --template <imported-id> --yes',
+    '',
+    'This writes only Agent-local starter/profile state. It does not mutate the daemon, default wiki, or HomeGraph.',
+  ].join('\n');
+}
+
+function renderTemplatePreview(homeDirectory: string, templateId: string): string {
+  const file = getAgentRuntimeProfileTemplateFile(templateId, homeDirectory);
+  return [
+    `Agent Starter Template: ${file.template.id}`,
+    `  name: ${file.template.name}`,
+    `  source: ${file.template.source}`,
+    `  description: ${file.template.description}`,
+    `  persona: ${file.template.persona.name}`,
+    `  skills: ${file.template.skills.map((skill) => skill.name).join(', ')}`,
+    `  routines: ${file.template.routines.map((routine) => routine.name).join(', ')}`,
+    '',
+    'Export/edit/import to customize this starter:',
+    `  /agent-profile template export ${file.template.id} ./agent-starter.json --yes`,
+  ].join('\n');
+}
+
+export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'agent-profile',
+    aliases: ['runtime-profile', 'agent-profiles'],
+    description: 'Manage isolated Agent runtime profiles and starter templates',
+    usage: '[list|templates|guide|template show|template export|template import|create|delete]',
+    handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const homeDirectory = shellPaths.homeDirectory;
+      const parsed = stripYesFlag(args);
+      const commandArgs = [...parsed.rest];
+      const sub = (commandArgs[0] ?? 'list').toLowerCase();
+
+      try {
+        if (sub === 'list' || sub === 'profiles') {
+          ctx.print(renderProfiles(homeDirectory));
+          return;
+        }
+
+        if (sub === 'templates' || sub === 'starters') {
+          ctx.print(renderTemplates(homeDirectory));
+          return;
+        }
+
+        if (sub === 'guide' || sub === 'author') {
+          ctx.print(renderGuide(homeDirectory));
+          return;
+        }
+
+        if (sub === 'template' || sub === 'starter') {
+          const mode = (commandArgs[1] ?? 'show').toLowerCase();
+          if (mode === 'show' || mode === 'preview') {
+            const templateId = commandArgs[2];
+            if (!templateId) {
+              ctx.print('Usage: /agent-profile template show <id>');
+              return;
+            }
+            ctx.print(renderTemplatePreview(homeDirectory, templateId));
+            return;
+          }
+          if (mode === 'export') {
+            const templateId = commandArgs[2];
+            const pathArg = commandArgs[3];
+            if (!templateId || !pathArg) {
+              ctx.print('Usage: /agent-profile template export <id> <path> --yes');
+              return;
+            }
+            if (!parsed.yes) {
+              requireYesFlag(ctx, `export Agent starter template ${templateId}`, '/agent-profile template export <id> <path> --yes');
+              return;
+            }
+            const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+            mkdirSync(dirname(targetPath), { recursive: true });
+            const template = exportAgentRuntimeProfileTemplate(homeDirectory, templateId, targetPath);
+            ctx.print(`Agent starter template exported: ${template.id}\n  path: ${template.path ?? targetPath}\n  edit it, then import it with /agent-profile template import <path> --yes`);
+            return;
+          }
+          if (mode === 'import') {
+            const pathArg = commandArgs[2];
+            if (!pathArg) {
+              ctx.print('Usage: /agent-profile template import <path> --yes');
+              return;
+            }
+            if (!parsed.yes) {
+              requireYesFlag(ctx, 'import Agent starter template', '/agent-profile template import <path> --yes');
+              return;
+            }
+            const sourcePath = shellPaths.resolveWorkspacePath(pathArg);
+            const template = importAgentRuntimeProfileTemplate(homeDirectory, sourcePath);
+            ctx.print(`Agent starter template imported: ${template.id}\n  source: ${template.source}\n  use: /agent-profile create <name> --template ${template.id} --yes`);
+            return;
+          }
+          ctx.print('Usage: /agent-profile template [show <id>|export <id> <path> --yes|import <path> --yes]');
+          return;
+        }
+
+        if (sub === 'create') {
+          const name = commandArgs[1];
+          const templateId = parseFlag(commandArgs, '--template') ?? parseFlag(commandArgs, '--starter');
+          if (!name) {
+            ctx.print('Usage: /agent-profile create <name> [--template <id>] --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `create Agent runtime profile ${name}`, '/agent-profile create <name> [--template <id>] --yes');
+            return;
+          }
+          const profile = createAgentRuntimeProfile(homeDirectory, name, { templateId });
+          ctx.print([
+            `Agent runtime profile created: ${profile.id}`,
+            `  home: ${profile.homeDirectory}`,
+            profile.starterTemplateId ? `  starter: ${profile.starterTemplateId}` : '',
+            `  launch: goodvibes-agent --agent-profile ${profile.id}`,
+          ].filter(Boolean).join('\n'));
+          return;
+        }
+
+        if (sub === 'delete') {
+          const name = commandArgs[1];
+          if (!name) {
+            ctx.print('Usage: /agent-profile delete <name> --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `delete Agent runtime profile ${name}`, '/agent-profile delete <name> --yes');
+            return;
+          }
+          ctx.print(deleteAgentRuntimeProfile(homeDirectory, name) ? `Agent runtime profile deleted: ${name}` : `Agent runtime profile not found: ${name}`);
+          return;
+        }
+
+        ctx.print('Usage: /agent-profile [list|templates|guide|template show <id>|template export <id> <path> --yes|template import <path> --yes|create <name> [--template <id>] --yes|delete <name> --yes]');
+      } catch (error) {
+        ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    },
+  });
+}

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,
   });
 }