@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/agent/reminder-schedule.ts

@@ -4,11 +4,11 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { getModelIdFromProviderModel, getProviderIdFromModel } from '../config/provider-model.ts';
 import { SDK_VERSION } from '../version.ts';
 import {
-  resolveAgentDaemonConnection,
+  resolveAgentConnectedHostConnection,
   ROUTINE_SCHEDULE_METHOD,
   ROUTINE_SCHEDULE_ROUTE,
-  type AgentDaemonConfigReader,
-  type AgentDaemonConnection,
+  type AgentConnectedHostConfigReader,
+  type AgentConnectedHostConnection,
   type RoutineScheduleDeliveryKind,
   type RoutineScheduleDeliverySurfaceKind,
   type RoutineScheduleDeliveryTargetSpec,
@@ -58,14 +58,14 @@ export interface ReminderScheduleFailure {
   readonly kind:
     | 'confirmation_required'
     | 'auth_required'
-    | 'daemon_unavailable'
+    | 'connected_host_unavailable'
     | 'version_mismatch'
-    | 'daemon_route_unavailable'
-    | 'daemon_error';
+    | 'connected_host_route_unavailable'
+    | 'connected_host_error';
   readonly error: string;
   readonly route: typeof REMINDER_SCHEDULE_ROUTE;
   readonly baseUrl?: string;
-  readonly daemonVersion?: string;
+  readonly connectedHostVersion?: string;
   readonly expectedSdkVersion?: string;
 }
 
@@ -82,6 +82,7 @@ const DELIVERY_SURFACE_KINDS: readonly RoutineScheduleDeliverySurfaceKind[] = [
   'google-chat',
   'signal',
   'whatsapp',
+  'telephony',
   'imessage',
   'msteams',
   'bluebubbles',
@@ -186,7 +187,7 @@ function deliveryModeFromTargets(targets: readonly RoutineScheduleDeliveryTarget
 function toDeliveryTargetInput(target: RoutineScheduleDeliveryTargetSpec): ScheduleDeliveryTargetInput {
   return {
     kind: target.kind,
-    surfaceKind: target.surfaceKind,
+    surfaceKind: target.surfaceKind as ScheduleDeliveryTargetInput['surfaceKind'],
     address: target.address,
     routeId: target.routeId,
     label: target.label,
@@ -312,7 +313,7 @@ export function parseReminderScheduleArgs(args: readonly string[]): ParsedRemind
       continue;
     }
     if (raw.startsWith('--')) {
-      errors.push(`Unknown option: ${raw}`);
+      errors.push(`Unknown option ${raw}`);
       continue;
     }
     positional.push(raw);
@@ -335,9 +336,9 @@ export function buildReminderSchedulePrompt(message: string): string {
     '',
     'Operator policy:',
     '- Treat this as a reminder delivery, not an autonomous hidden workflow.',
-    '- Use isolated Agent Knowledge routes only when lookup is needed; never use default Knowledge/Wiki or non-Agent knowledge spaces as fallback.',
+    '- Use isolated Agent Knowledge routes only when lookup is needed; never use default knowledge or non-Agent knowledge spaces as fallback.',
     '- Do not perform destructive, costly, externally visible, or secret-handling actions from this reminder without explicit approval.',
-    '- Do not request WRFC from a reminder. If build/fix/review work is needed, ask the user to delegate it explicitly to GoodVibes TUI.',
+    '- Do not request GoodVibes TUI delegation from a reminder. If build/fix/review work is needed, ask the user to delegate it explicitly to GoodVibes TUI.',
     '- Keep the reminder concise and state any next action the user can take.',
   ].join('\n');
 }
@@ -406,7 +407,7 @@ export function buildReminderSchedulePreview(parsed: ParsedReminderScheduleArgs)
   };
 }
 
-async function fetchDaemonStatus(connection: AgentDaemonConnection): Promise<{
+async function fetchConnectedHostStatus(connection: AgentConnectedHostConnection): Promise<{
   readonly ok: boolean;
   readonly status: number;
   readonly body: unknown;
@@ -430,7 +431,7 @@ async function fetchDaemonStatus(connection: AgentDaemonConnection): Promise<{
 
 async function classifyReminderScheduleError(
   error: unknown,
-  connection: AgentDaemonConnection,
+  connection: AgentConnectedHostConnection,
 ): Promise<ReminderScheduleFailure> {
   const message = summarizeError(error);
   const lower = message.toLowerCase();
@@ -438,37 +439,37 @@ async function classifyReminderScheduleError(
     return { ok: false, kind: 'auth_required', error: message, route: REMINDER_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) {
+    const connectedHost = await fetchConnectedHostStatus(connection);
+    const record = isRecord(connectedHost.body) ? connectedHost.body : {};
+    const connectedHostVersion = readString(record, 'version') ?? 'unknown';
+    if (connectedHost.ok && connectedHostVersion !== SDK_VERSION) {
       return {
         ok: false,
         kind: 'version_mismatch',
-        error: `Connected GoodVibes service SDK version ${daemonVersion} does not match Agent SDK pin ${SDK_VERSION}; schedules.create is unavailable.`,
+        error: `Connected GoodVibes host SDK version ${connectedHostVersion} does not match Agent SDK pin ${SDK_VERSION}; schedules.create is unavailable.`,
         route: REMINDER_SCHEDULE_ROUTE,
         baseUrl: connection.baseUrl,
-        daemonVersion,
+        connectedHostVersion,
         expectedSdkVersion: SDK_VERSION,
       };
     }
-    return { ok: false, kind: 'daemon_route_unavailable', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+    return { ok: false, kind: 'connected_host_route_unavailable', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
   }
   if (lower.includes('fetch') || lower.includes('connect') || lower.includes('econnrefused')) {
-    return { ok: false, kind: 'daemon_unavailable', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+    return { ok: false, kind: 'connected_host_unavailable', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
   }
-  return { ok: false, kind: 'daemon_error', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
+  return { ok: false, kind: 'connected_host_error', error: message, route: REMINDER_SCHEDULE_ROUTE, baseUrl: connection.baseUrl };
 }
 
 export async function createReminderSchedule(
-  connection: AgentDaemonConnection,
+  connection: AgentConnectedHostConnection,
   preview: ReminderSchedulePreview,
 ): Promise<ReminderScheduleResult> {
   if (!connection.token) {
     return {
       ok: false,
       kind: 'auth_required',
-      error: `No daemon operator token found at ${connection.tokenPath}`,
+      error: `No connected-host operator token found at ${connection.tokenPath}`,
       route: REMINDER_SCHEDULE_ROUTE,
       baseUrl: connection.baseUrl,
     };
@@ -489,6 +490,6 @@ export async function createReminderSchedule(
   }
 }
 
-export function resolveReminderDaemonConnection(configManager: AgentDaemonConfigReader, homeDirectory: string): AgentDaemonConnection {
-  return resolveAgentDaemonConnection(configManager, homeDirectory);
+export function resolveReminderConnectedHostConnection(configManager: AgentConnectedHostConfigReader, homeDirectory: string): AgentConnectedHostConnection {
+  return resolveAgentConnectedHostConnection(configManager, homeDirectory);
 }

package/src/agent/routine-registry.ts

@@ -3,9 +3,19 @@ import { dirname } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { assertNoSecretLikeText } from './persona-registry.ts';
+import { formatAgentRecordReviewState } from './record-labels.ts';
+import {
+  evaluateAgentSkillReadiness,
+  formatAgentSkillRequirement,
+  normalizeAgentSkillRequirements,
+  type AgentSkillReadiness,
+  type AgentSkillRequirement,
+} from './skill-registry.ts';
 
 export type AgentRoutineSource = 'user' | 'agent' | 'imported' | 'system';
 export type AgentRoutineReviewState = 'fresh' | 'reviewed' | 'stale';
+export type AgentRoutineRequirement = AgentSkillRequirement;
+export type AgentRoutineReadiness = AgentSkillReadiness;
 
 export interface AgentRoutineRecord {
   readonly id: string;
@@ -14,6 +24,7 @@ export interface AgentRoutineRecord {
   readonly steps: string;
   readonly triggers: readonly string[];
   readonly tags: readonly string[];
+  readonly requirements: readonly AgentRoutineRequirement[];
   readonly enabled: boolean;
   readonly source: AgentRoutineSource;
   readonly provenance: string;
@@ -32,6 +43,7 @@ export interface AgentRoutineCreateInput {
   readonly steps: string;
   readonly triggers?: readonly string[];
   readonly tags?: readonly string[];
+  readonly requirements?: readonly AgentRoutineRequirement[];
   readonly enabled?: boolean;
   readonly source?: AgentRoutineSource;
   readonly provenance?: string;
@@ -43,6 +55,7 @@ export interface AgentRoutineUpdateInput {
   readonly steps?: string;
   readonly triggers?: readonly string[];
   readonly tags?: readonly string[];
+  readonly requirements?: readonly AgentRoutineRequirement[];
   readonly provenance?: string;
 }
 
@@ -72,6 +85,18 @@ function readStringArray(value: unknown): string[] {
   return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function readRequirementArray(value: unknown): readonly AgentRoutineRequirement[] {
+  if (!Array.isArray(value)) return [];
+  const requirements = value
+    .filter(isRecord)
+    .map((entry) => ({
+      kind: entry.kind === 'command' ? 'command' as const : 'env' as const,
+      name: readString(entry.name).trim(),
+      description: readString(entry.description).trim() || undefined,
+    }));
+  return normalizeAgentSkillRequirements(requirements);
+}
+
 function readNonNegativeInteger(value: unknown): number {
   const parsed = typeof value === 'number' ? value : Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
@@ -123,6 +148,7 @@ function parseRoutine(value: unknown): AgentRoutineRecord | null {
     steps,
     triggers: readStringArray(value.triggers),
     tags: readStringArray(value.tags),
+    requirements: readRequirementArray(value.requirements),
     enabled: value.enabled === true,
     source,
     provenance: readString(value.provenance, source).trim() || source,
@@ -151,14 +177,16 @@ function formatStore(store: RoutineStoreFile): string {
   return `${JSON.stringify(store, null, 2)}\n`;
 }
 
-export function routineStorePath(shellPaths: ShellPathService): string {
+type AgentLocalStorePaths = Pick<ShellPathService, 'resolveUserPath'>;
+
+export function routineStorePath(shellPaths: AgentLocalStorePaths): string {
   return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'routines', 'routines.json');
 }
 
 export class AgentRoutineRegistry {
   public constructor(private readonly storePath: string) {}
 
-  public static fromShellPaths(shellPaths: ShellPathService): AgentRoutineRegistry {
+  public static fromShellPaths(shellPaths: AgentLocalStorePaths): AgentRoutineRegistry {
     return new AgentRoutineRegistry(routineStorePath(shellPaths));
   }
 
@@ -200,9 +228,10 @@ export class AgentRoutineRegistry {
     const description = input.description.trim();
     const steps = input.steps.trim();
     this.validateRequired(name, description, steps);
-    assertNoSecretLikeText([name, description, steps, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const requirements = normalizeAgentSkillRequirements(input.requirements);
+    assertNoSecretLikeText([name, description, steps, ...(input.tags ?? []), ...(input.triggers ?? []), ...requirements.flatMap((requirement) => [requirement.name, requirement.description ?? ''])], 'Routines');
     const duplicate = store.routines.find((routine) => routine.name.toLowerCase() === name.toLowerCase());
-    if (duplicate) throw new Error(`Routine already exists: ${duplicate.id}`);
+    if (duplicate) throw new Error(`Routine already exists ${duplicate.id}`);
     const timestamp = nowIso();
     const routine: AgentRoutineRecord = {
       id: this.nextId(name, store.routines),
@@ -211,6 +240,7 @@ export class AgentRoutineRegistry {
       steps,
       triggers: normalizeList(input.triggers),
       tags: normalizeList(input.tags),
+      requirements,
       enabled: input.enabled === true,
       source: input.source ?? 'user',
       provenance: input.provenance?.trim() || input.source || 'user',
@@ -226,14 +256,15 @@ export class AgentRoutineRegistry {
   public update(idOrName: string, input: AgentRoutineUpdateInput): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     const name = input.name === undefined ? existing.name : normalizeName(input.name);
     const description = input.description === undefined ? existing.description : input.description.trim();
     const steps = input.steps === undefined ? existing.steps : input.steps.trim();
     this.validateRequired(name, description, steps);
-    assertNoSecretLikeText([name, description, steps, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const requirements = input.requirements === undefined ? existing.requirements : normalizeAgentSkillRequirements(input.requirements);
+    assertNoSecretLikeText([name, description, steps, ...(input.tags ?? []), ...(input.triggers ?? []), ...requirements.flatMap((requirement) => [requirement.name, requirement.description ?? ''])], 'Routines');
     const duplicate = store.routines.find((routine) => routine.id !== existing.id && routine.name.toLowerCase() === name.toLowerCase());
-    if (duplicate) throw new Error(`Routine already exists: ${duplicate.id}`);
+    if (duplicate) throw new Error(`Routine already exists ${duplicate.id}`);
     const updated: AgentRoutineRecord = {
       ...existing,
       name,
@@ -241,6 +272,7 @@ export class AgentRoutineRegistry {
       steps,
       triggers: input.triggers === undefined ? existing.triggers : normalizeList(input.triggers),
       tags: input.tags === undefined ? existing.tags : normalizeList(input.tags),
+      requirements,
       provenance: input.provenance === undefined ? existing.provenance : input.provenance.trim() || existing.provenance,
       reviewState: 'fresh',
       staleReason: undefined,
@@ -257,7 +289,7 @@ export class AgentRoutineRegistry {
   public setEnabled(idOrName: string, enabled: boolean): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     const updated: AgentRoutineRecord = { ...existing, enabled, updatedAt: nowIso() };
     this.writeStore({
       ...store,
@@ -269,7 +301,7 @@ export class AgentRoutineRegistry {
   public markStarted(idOrName: string): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     const timestamp = nowIso();
     const updated: AgentRoutineRecord = {
       ...existing,
@@ -287,7 +319,7 @@ export class AgentRoutineRegistry {
   public markReviewed(idOrName: string): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     const updated: AgentRoutineRecord = {
       ...existing,
       reviewState: 'reviewed',
@@ -305,7 +337,7 @@ export class AgentRoutineRegistry {
   public markStale(idOrName: string, reason: string): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     const updated: AgentRoutineRecord = {
       ...existing,
       reviewState: 'stale',
@@ -322,7 +354,7 @@ export class AgentRoutineRegistry {
   public deleteRoutine(idOrName: string): AgentRoutineRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown routine: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown routine ${idOrName}`);
     this.writeStore({
       ...store,
       routines: store.routines.filter((routine) => routine.id !== existing.id),
@@ -358,7 +390,7 @@ export class AgentRoutineRegistry {
     try {
       return parseStore(readFileSync(this.storePath, 'utf-8'));
     } catch (error) {
-      throw new Error(`Could not read Agent routine store: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Could not read Agent routine store ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
@@ -370,6 +402,13 @@ export class AgentRoutineRegistry {
   }
 }
 
+export function evaluateAgentRoutineReadiness(
+  routine: Pick<AgentRoutineRecord, 'requirements'>,
+  options: Parameters<typeof evaluateAgentSkillReadiness>[1] = {},
+): AgentRoutineReadiness {
+  return evaluateAgentSkillReadiness(routine, options);
+}
+
 export function buildEnabledRoutinesPrompt(shellPaths: ShellPathService): string | null {
   const enabled = AgentRoutineRegistry.fromShellPaths(shellPaths).snapshot().enabledRoutines;
   if (enabled.length === 0) return null;
@@ -380,8 +419,9 @@ export function buildEnabledRoutinesPrompt(shellPaths: ShellPathService): string
     ...enabled.slice(0, 8).flatMap((routine) => [
       `### ${routine.name}`,
       `Description: ${routine.description}`,
-      `Review state: ${routine.reviewState}`,
+      `Review: ${formatAgentRecordReviewState(routine.reviewState)}`,
       `Triggers: ${routine.triggers.join(', ') || '(manual)'}`,
+      `Readiness: ${evaluateAgentRoutineReadiness(routine).ready ? 'ready' : `missing ${evaluateAgentRoutineReadiness(routine).missing.map(formatAgentSkillRequirement).join(', ')}`}`,
       routine.steps,
       '',
     ]),

package/src/agent/routine-schedule-args.ts

@@ -15,6 +15,7 @@ const DELIVERY_SURFACE_KINDS: readonly RoutineScheduleDeliverySurfaceKind[] = [
   'google-chat',
   'signal',
   'whatsapp',
+  'telephony',
   'imessage',
   'msteams',
   'bluebubbles',
@@ -204,7 +205,7 @@ export function parseRoutineSchedulePromotionArgs(args: readonly string[]): Pars
       continue;
     }
     if (raw.startsWith('--')) {
-      errors.push(`Unknown option: ${raw}`);
+      errors.push(`Unknown option ${raw}`);
       continue;
     }
     if (!routineId) {

package/src/agent/routine-schedule-format.ts

@@ -23,6 +23,30 @@ function formatDeliveryTargetKind(target: { readonly kind?: string; readonly sur
   return `${target.kind ?? 'unknown'}${target.surfaceKind ? `/${target.surfaceKind}` : ''}`;
 }
 
+function formatDeliveryTarget(target: {
+  readonly kind?: string;
+  readonly surfaceKind?: string;
+  readonly routeId?: string;
+  readonly address?: string;
+  readonly label?: string;
+}): string {
+  const details = [
+    target.routeId ? `route=${target.routeId}` : '',
+    target.address ? `address=${target.address}` : '',
+    target.label ? `label=${target.label}` : '',
+  ].filter(Boolean);
+  return `${formatDeliveryTargetKind(target)}${details.length > 0 ? ` ${details.join(' ')}` : ''}`;
+}
+
+function formatRoutineScheduleFailureKind(kind: string): string {
+  if (kind === 'auth_required') return 'authorization required';
+  if (kind === 'connected_host_unavailable') return 'connected host unavailable';
+  if (kind === 'connected_host_route_unavailable') return 'connected host route unavailable';
+  if (kind === 'connected_host_error') return 'connected host error';
+  if (kind === 'version_mismatch') return 'version mismatch';
+  return kind.replace(/[_-]+/g, ' ');
+}
+
 export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPreview): string {
   const schedule = preview.payload.kind === 'cron'
     ? `${preview.payload.cron}${preview.payload.timezone ? ` [${preview.payload.timezone}]` : ''}`
@@ -33,15 +57,15 @@ export function formatRoutineSchedulePreview(preview: RoutineSchedulePromotionPr
   const deliveryTargetCount = delivery?.targets.length ?? 0;
   return [
     'GoodVibes schedule preview for Agent routine',
-    `  routine: ${preview.routineName} (${preview.routineId})`,
-    `  route: ${preview.method} ${preview.route}`,
-    `  name: ${String(preview.payload.name ?? '(runtime default)')}`,
-    `  schedule: ${preview.payload.kind} ${schedule}`,
-    `  enabled: ${preview.payload.enabled === false ? 'no' : 'yes'}`,
+    `  routine ${preview.routineName} (${preview.routineId})`,
+    `  route ${preview.method} ${preview.route}`,
+    `  name ${String(preview.payload.name ?? '(connected-host default)')}`,
+    `  schedule ${preview.payload.kind} ${schedule}`,
+    `  enabled ${preview.payload.enabled === false ? 'no' : 'yes'}`,
     `  delivery: ${delivery?.mode ?? 'none'}${deliveryTargetCount > 0 ? ` (${deliveryTargetCount} target${deliveryTargetCount === 1 ? '' : 's'})` : ''}`,
-    '  target: GoodVibes runtime/main conversation route',
-    '  policy: isolated Agent Knowledge only; no default wiki/non-Agent fallback; no WRFC unless explicitly delegated',
-    '  next: rerun with --yes to create this connected schedule',
+    '  target connected GoodVibes host/main conversation route',
+    '  policy isolated Agent Knowledge only; no default knowledge/non-Agent fallback; no delegated review unless explicitly requested',
+    '  next rerun with --yes to create this connected schedule',
   ].join('\n');
 }
 
@@ -51,11 +75,11 @@ export function formatRoutineScheduleSuccess(result: RoutineSchedulePromotionSuc
   const status = readString(record, 'status') ?? (record.enabled === false ? 'paused' : 'enabled');
   return [
     'Created GoodVibes schedule for Agent routine',
-    `  routine: ${result.routineName} (${result.routineId})`,
-    `  schedule: ${id}`,
-    `  status: ${status}`,
-    `  route: ${result.kind} ${result.route}`,
-    '  next: inspect with /schedule list or schedule observability',
+    `  routine ${result.routineName} (${result.routineId})`,
+    `  schedule ${id}`,
+    `  status ${status}`,
+    `  route ${result.kind} ${result.route}`,
+    '  next inspect with /schedule list or schedule observability',
   ].join('\n');
 }
 
@@ -64,18 +88,18 @@ export function formatRoutineScheduleReceipts(snapshot: RoutineScheduleReceiptSn
   if (snapshot.receipts.length === 0) {
     return [
       'Agent routine schedule receipts',
-      `  store: ${snapshot.path}`,
+      `  store ${snapshot.path}`,
       '  No routine schedule promotions have been recorded yet.',
       '  Create one with /schedule promote-routine <routine-id> --cron <expr> --yes.',
     ].join('\n');
   }
   return [
     `Agent routine schedule receipts (${snapshot.receipts.length})`,
-    `  store: ${snapshot.path}`,
+    `  store ${snapshot.path}`,
     ...receipts.map((receipt) => {
       const schedule = receipt.scheduleId ? ` schedule=${receipt.scheduleId}` : '';
-      const failure = receipt.status === 'failed' && receipt.failureKind ? ` failure=${receipt.failureKind}` : '';
-      return `  ${receipt.id}  ${receipt.status}  ${receipt.scheduleKind} ${receipt.scheduleValue}  routine=${receipt.routineId}${schedule}${failure}`;
+      const failure = receipt.status === 'failed' && receipt.failureKind ? ` failure ${formatRoutineScheduleFailureKind(receipt.failureKind)}` : '';
+      return `  ${receipt.id}  ${receipt.status}  ${receipt.scheduleKind} ${receipt.scheduleValue}  routine ${receipt.routineId}${schedule}${failure}`;
     }),
     snapshot.receipts.length > receipts.length ? `  ...${snapshot.receipts.length - receipts.length} more` : '',
   ].filter((line): line is string => Boolean(line)).join('\n');
@@ -84,20 +108,20 @@ export function formatRoutineScheduleReceipts(snapshot: RoutineScheduleReceiptSn
 export function formatRoutineScheduleReceipt(receipt: RoutineScheduleReceipt): string {
   return [
     `Agent routine schedule receipt ${receipt.id}`,
-    `  created: ${receipt.createdAt}`,
-    `  status: ${receipt.status}`,
-    `  routine: ${receipt.routineName} (${receipt.routineId})`,
-    `  route: ${receipt.method} ${receipt.route}`,
-    `  runtime: ${receipt.daemonBaseUrl}`,
-    `  schedule: ${receipt.scheduleName}${receipt.scheduleId ? ` (${receipt.scheduleId})` : ''}`,
-    receipt.scheduleStatus ? `  schedule status: ${receipt.scheduleStatus}` : '',
+    `  created ${receipt.createdAt}`,
+    `  status ${receipt.status}`,
+    `  routine ${receipt.routineName} (${receipt.routineId})`,
+    `  route ${receipt.method} ${receipt.route}`,
+    `  connected host: ${receipt.connectedHostBaseUrl}`,
+    `  schedule ${receipt.scheduleName}${receipt.scheduleId ? ` (${receipt.scheduleId})` : ''}`,
+    receipt.scheduleStatus ? `  schedule status ${receipt.scheduleStatus}` : '',
     `  cadence: ${receipt.scheduleKind} ${receipt.scheduleValue}${receipt.timezone ? ` [${receipt.timezone}]` : ''}`,
-    `  enabled: ${receipt.enabled ? 'yes' : 'no'}`,
-    receipt.provider ? `  provider: ${receipt.provider}` : '',
-    receipt.model ? `  model: ${receipt.model}` : '',
-    `  target: ${formatDeliveryTargetKind(receipt.target)}`,
+    `  enabled ${receipt.enabled ? 'yes' : 'no'}`,
+    receipt.provider ? `  provider ${receipt.provider}` : '',
+    receipt.model ? `  model ${receipt.model}` : '',
+    `  target ${formatDeliveryTargetKind(receipt.target)}`,
     receipt.deliveryMode ? `  delivery: ${receipt.deliveryMode}` : '',
-    ...(receipt.deliveryTargets ?? []).map((target) => `  delivery target: ${formatDeliveryTargetKind(target)}${target.routeId ? ` route=${target.routeId}` : ''}${target.address ? ` address=${target.address}` : ''}${target.label ? ` label=${target.label}` : ''}`),
+    ...(receipt.deliveryTargets ?? []).map((target) => `  delivery target: ${formatDeliveryTarget(target)}`),
     receipt.failureKind ? `  failure: ${receipt.failureKind}` : '',
     receipt.failureError ? `  error: ${receipt.failureError}` : '',
   ].filter((line): line is string => Boolean(line)).join('\n');
@@ -106,18 +130,18 @@ export function formatRoutineScheduleReceipt(receipt: RoutineScheduleReceipt): s
 export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelationResult, limit = 10): string {
   if (!result.ok) {
     return [
-      `GoodVibes schedule reconciliation error: ${result.kind}`,
+      `GoodVibes schedule reconciliation error ${formatRoutineScheduleFailureKind(result.kind)}`,
       `  ${result.error}`,
-      result.baseUrl ? `  runtime: ${result.baseUrl}` : null,
-      `  route: ${ROUTINE_SCHEDULE_LIST_METHOD} ${result.route}`,
+      result.baseUrl ? `  connected host ${result.baseUrl}` : null,
+      `  route ${ROUTINE_SCHEDULE_LIST_METHOD} ${result.route}`,
       result.kind === 'auth_required'
-        ? '  next: pair/authenticate with connected GoodVibes services, then retry.'
+        ? '  next pair/authenticate with the connected GoodVibes host, then retry.'
         : null,
-      result.kind === 'daemon_unavailable'
-        ? '  next: make connected GoodVibes services available outside Agent, then retry.'
+      result.kind === 'connected_host_unavailable'
+        ? '  next make the connected GoodVibes host available outside Agent, then retry.'
         : null,
-      result.kind === 'version_mismatch' || result.kind === 'daemon_route_unavailable'
-        ? '  next: update connected GoodVibes services so public schedules.list is available.'
+      result.kind === 'version_mismatch' || result.kind === 'connected_host_route_unavailable'
+        ? '  next update the connected GoodVibes host so public schedules.list is available.'
         : null,
     ].filter((line): line is string => Boolean(line)).join('\n');
   }
@@ -125,7 +149,7 @@ export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelat
   if (result.receiptCount === 0) {
     return [
       'Agent routine schedule reconciliation',
-      `  runtime: ${result.baseUrl}`,
+      `  connected host: ${result.baseUrl}`,
       `  route: ${result.kind} ${result.route}`,
       `  live schedules: ${result.scheduleCount}`,
       '  No local routine promotion receipts exist yet.',
@@ -137,20 +161,20 @@ export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelat
   const failed = result.correlations.filter((entry) => entry.liveStatus === 'failed-receipt').length;
   return [
     'Agent routine schedule reconciliation',
-    `  runtime: ${result.baseUrl}`,
+    `  connected host: ${result.baseUrl}`,
     `  route: ${result.kind} ${result.route}`,
     `  receipts: ${result.receiptCount}; live schedules: ${result.scheduleCount}; matched: ${matched}; missing: ${missing}; failed receipts: ${failed}`,
     ...correlations.map((entry) => {
       const receipt = entry.receipt;
       const schedule = entry.schedule;
       const live = schedule
-        ? ` live=${schedule.id} status=${schedule.status ?? (schedule.enabled === false ? 'paused' : 'enabled')}`
+        ? ` live=${schedule.id}; status ${schedule.status ?? (schedule.enabled === false ? 'paused' : 'enabled')}`
         : '';
       const runs = schedule && schedule.runCount !== undefined
-        ? ` runs=${schedule.runCount}/${schedule.successCount ?? 0}/${schedule.failureCount ?? 0}`
+        ? ` runs ${schedule.runCount}/${schedule.successCount ?? 0}/${schedule.failureCount ?? 0}`
         : '';
-      const next = schedule?.nextRunAt ? ` next=${new Date(schedule.nextRunAt).toISOString()}` : '';
-      return `  ${receipt.id}  ${entry.liveStatus}  reason=${entry.matchReason}  routine=${receipt.routineId}  receiptSchedule=${receipt.scheduleId ?? '(none)'}${live}${runs}${next}`;
+      const next = schedule?.nextRunAt ? ` next ${new Date(schedule.nextRunAt).toISOString()}` : '';
+      return `  ${receipt.id}  ${entry.liveStatus}  reason ${entry.matchReason}  routine ${receipt.routineId}  receipt schedule ${receipt.scheduleId ?? '(none)'}${live}${runs}${next}`;
     }),
     result.correlations.length > correlations.length ? `  ...${result.correlations.length - correlations.length} more` : '',
   ].filter((line): line is string => Boolean(line)).join('\n');
@@ -158,21 +182,21 @@ export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelat
 
 export function formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFailure): string {
   return [
-    `GoodVibes schedule error: ${failure.kind}`,
+    `GoodVibes schedule error ${formatRoutineScheduleFailureKind(failure.kind)}`,
     `  ${failure.error}`,
-    failure.baseUrl ? `  runtime: ${failure.baseUrl}` : null,
-    `  route: ${ROUTINE_SCHEDULE_METHOD} ${failure.route}`,
-    failure.kind === 'version_mismatch' && failure.daemonVersion && failure.expectedSdkVersion
-      ? `  versions: runtime=${failure.daemonVersion} expected=${failure.expectedSdkVersion}`
+    failure.baseUrl ? `  connected host ${failure.baseUrl}` : null,
+    `  route ${ROUTINE_SCHEDULE_METHOD} ${failure.route}`,
+    failure.kind === 'version_mismatch' && failure.connectedHostVersion && failure.expectedSdkVersion
+      ? `  versions connected host ${failure.connectedHostVersion}; expected ${failure.expectedSdkVersion}`
       : null,
     failure.kind === 'auth_required'
-      ? '  next: pair/authenticate with connected GoodVibes services, then retry with --yes.'
+      ? '  next pair/authenticate with the connected GoodVibes host, then retry with --yes.'
       : null,
-    failure.kind === 'daemon_unavailable'
-        ? '  next: make connected GoodVibes services available outside Agent, then retry.'
+    failure.kind === 'connected_host_unavailable'
+      ? '  next make the connected GoodVibes host available outside Agent, then retry.'
       : null,
-    failure.kind === 'version_mismatch' || failure.kind === 'daemon_route_unavailable'
-      ? '  next: update connected GoodVibes services so public schedules.create is available.'
+    failure.kind === 'version_mismatch' || failure.kind === 'connected_host_route_unavailable'
+      ? '  next update the connected GoodVibes host so public schedules.create is available.'
       : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }