@pellux/goodvibes-agent 0.1.55 → 0.1.57

package/.goodvibes/GOODVIBES.md

@@ -22,7 +22,7 @@ GoodVibes Agent is a proactive personal operator assistant built on the GoodVibe
 ## Product Boundaries
 
 - Agent connects to an already-running GoodVibes daemon. It does not start, restart, install, or own daemon/listener services.
-- GoodVibes TUI owns coding execution, file edits, git/worktree lifecycle, sandbox/QEMU UX, and WRFC owner chains.
+- GoodVibes TUI owns coding execution, file edits, git/worktree lifecycle, runtime-isolation UX, and WRFC owner chains.
 - Agent owns personal operator flow, setup/config surfaces, local memory, local skills, local personas, Agent knowledge, status/approval/automation observability, and explicit delegation receipts.
 
 ## Engineering Rules

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.57 - 2026-05-31
+
+- 90edab3 Expand Agent onboarding setup surfaces
+- 251ae62 Guard package-facing Agent product language
+
+## 0.1.56 - 2026-05-31
+
+- a0b54e8 Document Bun global PATH setup
+- f845cca Rename onboarding setup step
+- 4462e52 Clarify Bun-only install path
+
 ## 0.1.55 - 2026-05-31
 
 - d8f4eee Remove copied developer audit surfaces
@@ -188,7 +199,7 @@ All notable changes to GoodVibes Agent will be recorded here.
 
 - d20a93e Allow explicit recall review without yes
 - 601f41c Require confirmation for eval execution
-- f41befb Block Cloudflare onboarding mutations
+- f41befb Block copied infrastructure onboarding mutations
 - 79071ec Block implicit block file saves
 - 40aca02 Block inline diff file edits in Agent
 - 854eda8 Block MCP workspace config mutations
@@ -259,24 +270,24 @@ All notable changes to GoodVibes Agent will be recorded here.
 ## 0.1.7 - 2026-05-31
 
 - Replaced active planning-loop output and tests that still described planning as TUI-owned with Agent-owned planning state and planning namespace language.
-- Added `LICENSE` to the explicit package file contract and release verification so npm tarballs cannot omit license text.
+- Added `LICENSE` to the explicit package file contract and release verification so registry tarballs cannot omit license text.
 - Prevented the operator workspace from dispatching placeholder delegation commands such as `/delegate --wrfc <task>`; those actions now provide guidance until the user supplies real task text.
 - Added local Agent routines with `/routines`: create/list/search/show/enable/disable/start/review/stale/delete, secret-looking value rejection, enabled routine prompt injection, and operator workspace status. Starting a routine stays in the main conversation and does not create hidden background jobs.
-- Removed copied TUI release, UAT, and WRFC artifact docs from the Agent source tree and updated remaining source docs so channel, Cloudflare, voice, Home Assistant, and panel guidance speaks in Agent/external-daemon terms.
+- Removed copied TUI release, UAT, and WRFC artifact docs from the Agent source tree and updated remaining source docs so channel, voice, integration, and panel guidance speaks in Agent/external-daemon terms.
 
 ## 0.1.6 - 2026-05-31
 
 - Made the publish helper use exported `NODE_AUTH_TOKEN` or `NPM_TOKEN` automatically by writing a temporary npm user config for publish commands.
-- Rewrote source docs for tools, commands, knowledge, artifacts, and multimodal behavior so they describe Agent-only Knowledge/Wiki and never teach default Knowledge/Wiki or HomeGraph fallback.
+- Rewrote source docs for tools, commands, knowledge, artifacts, and multimodal behavior so they describe Agent-only Knowledge/Wiki and never teach default Knowledge/Wiki or non-Agent graph fallback.
 - Updated `/plan` command and Planning panel language from copied TUI-owned wording to Agent-owned workspace planning state.
 - Added regression tests that keep source docs and active planning surfaces aligned with Agent Knowledge isolation and Agent product language.
 
 ## 0.1.5 - 2026-05-31
 
-- Hardened package-facing release checks so shipped docs and Agent guidance cannot reintroduce default Knowledge/Wiki, HomeGraph, Home Assistant, copied TUI daemon, or copied WRFC-first policy text.
+- Hardened package-facing release checks so shipped docs and Agent guidance cannot reintroduce default Knowledge/Wiki, non-Agent graph, copied daemon, or copied WRFC-first policy text.
 - Removed the generic default `knowledgeApi` client from the active Agent command context so slash commands must use the isolated Agent Knowledge API.
 - Changed CLI `knowledge ingest-url` to post directly to `/api/goodvibes-agent/knowledge/ingest/url` instead of invoking the generic knowledge operator method.
-- Rejected `--space`, `--knowledge-space`, `--knowledgeSpaceId`, `--includeAllSpaces`, and HomeGraph-style flags in CLI and slash Agent Knowledge commands before any daemon call.
+- Rejected default-space and broad cross-space query flags in CLI and slash Agent Knowledge commands before any daemon call.
 
 ## 0.1.4 - 2026-05-31
 
@@ -288,12 +299,12 @@ All notable changes to GoodVibes Agent will be recorded here.
 
 - Added local Agent personas with `/personas`: create/list/search/show/use/review/stale/delete, secret-looking value rejection, active persona prompt injection, and operator workspace status.
 - Added local Agent skills with `/agent-skills` and `/skills local`: create/list/search/show/enable/disable/review/stale/delete, secret-looking value rejection, enabled skill prompt injection, and operator workspace status.
-- Kept persona and skill state Agent-local with no default Knowledge/Wiki or HomeGraph fallback.
+- Kept persona and skill state Agent-local with no default Knowledge/Wiki or non-Agent graph fallback.
 
 ## 0.1.2 - 2026-05-30
 
 - Added `goodvibes-agent compat` for package SDK pin, external daemon version, auth presence, and isolated Agent Knowledge route readiness.
-- Added `goodvibes-agent knowledge ...` commands for the isolated `/api/goodvibes-agent/knowledge/*` environment with no default Knowledge/Wiki or HomeGraph fallback.
+- Added `goodvibes-agent knowledge ...` commands for the isolated `/api/goodvibes-agent/knowledge/*` environment with no default Knowledge/Wiki or non-Agent graph fallback.
 - Added explicit GoodVibes TUI build delegation through `goodvibes-agent delegate` and `/delegate`; WRFC is requested only through explicit `--wrfc`, `/wrfc`, or `/review` delegation.
 - Removed the copied WRFC panel from the default Agent panel registry while preserving explicit TUI delegation for build/fix/review work.
 - Hardened the Agent release helper and CLI help output for the current Agent changelog and command set.

package/README.md

@@ -19,6 +19,13 @@ goodvibes-agent profiles templates
 goodvibes-agent knowledge status
 ```
 
+If `goodvibes-agent` is not found after installation, add Bun's global bin directory to `PATH`:
+
+```sh
+export PATH="$(bun pm bin -g):$PATH"
+goodvibes-agent --help
+```
+
 If Bun reports untrusted lifecycle dependencies, trust only the package and dependencies required by this package:
 
 ```sh
@@ -74,7 +81,7 @@ Local Agent behavior is editable from the TUI:
 /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`, can include explicit delivery targets such as `--delivery-surface slack`, records a redacted local receipt, and the generated scheduled prompt keeps Agent Knowledge isolated from default Knowledge/Wiki and HomeGraph. Use `/schedule reconcile` to compare those local receipts against live externally owned daemon schedules through public `schedules.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`, can include explicit delivery targets such as `--delivery-surface slack`, records a redacted local receipt, and the generated scheduled prompt keeps Agent Knowledge isolated from default Knowledge/Wiki and non-Agent knowledge segments. Use `/schedule reconcile` to compare those local receipts against live externally owned daemon schedules through public `schedules.list`.
 
 ## Daemon Prerequisite
 
@@ -94,9 +101,9 @@ Those commands should return explicit external-daemon guidance instead of mutati
 
 GoodVibes Agent owns the operator assistant surface: serial assistant flow, proactive safe actions, local memory/routines/skills/personas, Agent knowledge routes, companion chat, approvals/automation observability, and explicit build delegation.
 
-Agent Knowledge/Wiki is its own product segment. Agent uses `/api/goodvibes-agent/knowledge/*` and must not fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes.
+Agent Knowledge/Wiki is its own product segment. Agent uses `/api/goodvibes-agent/knowledge/*` and must not fall back to default Knowledge/Wiki or other product-specific knowledge routes.
 
-GoodVibes TUI owns coding execution: file edits, git/worktree workflows, coding panels, sandbox/QEMU UX, and WRFC execution. Agent may delegate explicit build/fix/review work to TUI through public daemon/session contracts; normal assistant chat must not use shared coding sessions.
+GoodVibes TUI owns coding execution: file edits, git/worktree workflows, coding panels, runtime-isolation UX, and WRFC execution. Agent may delegate explicit build/fix/review work to TUI through public daemon/session contracts; normal assistant chat must not use shared coding sessions.
 
 ## Package Docs
 

package/docs/README.md

@@ -17,7 +17,7 @@ Important baseline constraints:
 - Agent depends on `@pellux/goodvibes-sdk@0.33.35`.
 - Agent connects to an externally managed daemon.
 - Agent does not start, stop, restart, install, uninstall, or own daemon/listener/web/service lifecycle.
-- Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`; there is no default Knowledge/Wiki, HomeGraph, or Home Assistant fallback.
+- Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`; there is no default Knowledge/Wiki or non-Agent product fallback.
 - 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` 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.

package/docs/getting-started.md

@@ -18,6 +18,13 @@ goodvibes-agent --help
 goodvibes-agent status
 ```
 
+If the installed command is not found, add Bun's global bin directory to `PATH`:
+
+```sh
+export PATH="$(bun pm bin -g):$PATH"
+goodvibes-agent --help
+```
+
 If Bun requires lifecycle trust:
 
 ```sh
@@ -64,7 +71,7 @@ Named profiles isolate Agent-local config, sessions, memory, personas, skills, r
 
 ## Local Personas, Routines, And Skills
 
-Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They do not write into default Knowledge/Wiki or HomeGraph.
+Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They do not write into default Knowledge/Wiki or non-Agent knowledge segments.
 
 ```text
 /personas list
@@ -78,7 +85,7 @@ Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They
 /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. Promoting a routine to a schedule is an explicit `schedules.create` call to the external daemon, requires `--yes`, writes a local redacted promotion receipt, and preserves the rule that Agent Knowledge never falls back to default Knowledge/Wiki or HomeGraph.
+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`, writes a local redacted promotion receipt, and preserves the rule that Agent Knowledge never falls back to default Knowledge/Wiki or non-Agent knowledge segments.
 
 ## External Daemon
 
@@ -90,7 +97,7 @@ Start the daemon from GoodVibes TUI or the daemon host before using daemon-backe
 - `/api/goodvibes-agent/knowledge/search`
 - `/api/goodvibes-agent/knowledge/ingest/url`
 
-Agent Knowledge/Wiki is an Agent-owned product segment. Agent commands must not fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant spaces.
+Agent Knowledge/Wiki is an Agent-owned product segment. Agent commands must not fall back to default Knowledge/Wiki or other product-specific knowledge spaces.
 
 Agent lifecycle commands that would start or mutate daemon posture are blocked intentionally. Use `goodvibes-agent status`, `goodvibes-agent doctor`, and read-only surface checks for diagnostics.
 

package/docs/release-and-publishing.md

@@ -4,13 +4,22 @@ GoodVibes Agent's current installable public alpha version is recorded in `packa
 
 ## Package Identity
 
-- npm package: `@pellux/goodvibes-agent`
+- registry package: `@pellux/goodvibes-agent`
 - executable: `goodvibes-agent`
 - SDK dependency: exact pin to `@pellux/goodvibes-sdk@0.33.35`
 - runtime: Bun
 - source language: TypeScript
 - daemon ownership: external only
 
+End users install and run GoodVibes Agent with Bun:
+
+```sh
+bun add -g @pellux/goodvibes-agent
+goodvibes-agent --help
+```
+
+Do not add non-Bun install instructions for this product. The package is hosted on the public package registry, but the supported install and smoke path is Bun.
+
 ## Required Gates
 
 Before any release candidate:
@@ -25,7 +34,7 @@ bun pm pack --dry-run
 git diff --check
 ```
 
-`bun run publish:package` publishes from a staged package directory. If `NPM_CONFIG_USERCONFIG` is already set, npm uses it. Otherwise the script creates a temporary 0600 npm userconfig from `NODE_AUTH_TOKEN` or `NPM_TOKEN`, uses it for that publish command, and removes it with the staging directory.
+`bun run publish:package` publishes from a staged package directory to the package registry. If `NPM_CONFIG_USERCONFIG` is already set, the registry publish command uses it. Otherwise the script creates a temporary 0600 registry userconfig from `NODE_AUTH_TOKEN` or `NPM_TOKEN`, uses it for that publish command, and removes it with the staging directory.
 
 Also run the package install smoke from a packed artifact. It must prove:
 
@@ -42,7 +51,7 @@ Also run the package install smoke from a packed artifact. It must prove:
 
 Do not publish if package-facing docs or install commands refer to another package name, another executable, or Agent-owned daemon lifecycle.
 
-Do not publish if Agent Knowledge commands can fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes. Agent Knowledge must use the isolated `/api/goodvibes-agent/knowledge/*` segment.
+Do not publish if Agent Knowledge commands can fall back to default Knowledge/Wiki or another product-specific knowledge route. Agent Knowledge must use the isolated `/api/goodvibes-agent/knowledge/*` segment.
 
 Do not ship daemon binaries from this package. If Agent later gets compiled artifacts, they must use Agent artifact names and remain separate from daemon ownership.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "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",
@@ -18,7 +18,6 @@
     "!src/test",
     "!src/**/*.test.ts",
     "!src/**/__tests__",
-    "!src/daemon/**",
     "!src/panels/diff-panel.ts",
     "!src/panels/file-explorer-panel.ts",
     "!src/panels/file-preview-panel.ts",
@@ -92,7 +91,6 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=20",
     "bun": ">=1.3.10"
   },
   "dependencies": {

package/scripts/check-bun.sh

@@ -5,9 +5,13 @@ if ! command -v bun >/dev/null 2>&1; then
   cat >&2 <<'EOF'
 goodvibes-agent requires Bun.
 
-Install Bun first, then install GoodVibes Agent from the npm registry with:
+Install Bun first, then install GoodVibes Agent with:
 
   bun add -g @pellux/goodvibes-agent
+
+If the installed command is not found, add Bun's global bin directory to PATH:
+
+  export PATH="$(bun pm bin -g):$PATH"
 EOF
   exit 1
 fi

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

@@ -0,0 +1,219 @@
+import type {
+  ParsedRoutineSchedulePromotionArgs,
+  RoutineScheduleDeliverySurfaceKind,
+  RoutineScheduleDeliveryTargetSpec,
+} from './routine-schedule-promotion.ts';
+
+const DELIVERY_SURFACE_KINDS: readonly RoutineScheduleDeliverySurfaceKind[] = [
+  'tui',
+  'web',
+  'slack',
+  'discord',
+  'ntfy',
+  'webhook',
+  'telegram',
+  'google-chat',
+  'signal',
+  'whatsapp',
+  'imessage',
+  'msteams',
+  'bluebubbles',
+  'mattermost',
+  'matrix',
+  'service',
+];
+
+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 };
+}
+
+export function isRoutineScheduleDeliverySurfaceKind(value: string): value is RoutineScheduleDeliverySurfaceKind {
+  return DELIVERY_SURFACE_KINDS.includes(value as RoutineScheduleDeliverySurfaceKind);
+}
+
+function parseSurfaceDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const [surfaceKind = '', routeId, label] = raw.split(':');
+  if (!isRoutineScheduleDeliverySurfaceKind(surfaceKind)) {
+    return `Unsupported delivery surface "${surfaceKind}".`;
+  }
+  return {
+    kind: 'surface',
+    surfaceKind,
+    routeId: routeId?.trim() || undefined,
+    label: label?.trim() || undefined,
+  };
+}
+
+function parseRouteDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const [routeId = '', label] = raw.split(':');
+  const normalizedRouteId = routeId.trim();
+  if (!normalizedRouteId) return '--delivery-route requires a route id.';
+  return {
+    kind: 'surface',
+    routeId: normalizedRouteId,
+    label: label?.trim() || undefined,
+  };
+}
+
+function parseWebhookDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const normalized = raw.trim();
+  if (!normalized) return '--delivery-webhook requires a URL.';
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') return '--delivery-webhook must be an http(s) URL.';
+  } catch {
+    return '--delivery-webhook must be a valid URL.';
+  }
+  return {
+    kind: 'webhook',
+    address: normalized,
+  };
+}
+
+function parseLinkDeliveryTarget(raw: string): RoutineScheduleDeliveryTargetSpec | string {
+  const normalized = raw.trim();
+  if (!normalized) return '--delivery-link requires a URL or label.';
+  return {
+    kind: 'link',
+    address: normalized,
+  };
+}
+
+function validateDeliveryTargets(targets: readonly RoutineScheduleDeliveryTargetSpec[]): string | null {
+  const kinds = new Set(targets.map((target) => target.kind));
+  return kinds.size > 1 ? 'Use one delivery target kind per routine promotion command.' : null;
+}
+
+export function parseRoutineSchedulePromotionArgs(args: readonly string[]): ParsedRoutineSchedulePromotionArgs {
+  let routineId: string | null = null;
+  let schedule: ParsedRoutineSchedulePromotionArgs['schedule'] = null;
+  const deliveryTargets: RoutineScheduleDeliveryTargetSpec[] = [];
+  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 (optionName === '--delivery-surface' || optionName === '--deliver-surface') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseSurfaceDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-route' || optionName === '--deliver-route') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseRouteDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-webhook' || optionName === '--deliver-webhook') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseWebhookDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      continue;
+    }
+    if (optionName === '--delivery-link' || optionName === '--deliver-link') {
+      const consumed = optionValue(args, index, inlineValue);
+      index = consumed.nextIndex;
+      const value = consumed.value?.trim();
+      if (!value) {
+        errors.push(`${optionName} requires a value.`);
+        continue;
+      }
+      const target = parseLinkDeliveryTarget(value);
+      if (typeof target === 'string') errors.push(target);
+      else deliveryTargets.push(target);
+      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>.');
+  const deliveryError = validateDeliveryTargets(deliveryTargets);
+  if (deliveryError) errors.push(deliveryError);
+  return { routineId, schedule, deliveryTargets, name, timezone, provider, model, enabled, yes, errors };
+}

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

@@ -0,0 +1,173 @@
+import {
+  ROUTINE_SCHEDULE_LIST_METHOD,
+  ROUTINE_SCHEDULE_METHOD,
+  type RoutineScheduleCorrelationResult,
+  type RoutineSchedulePromotionFailure,
+  type RoutineSchedulePromotionPreview,
+  type RoutineSchedulePromotionSuccess,
+  type RoutineScheduleReceipt,
+  type RoutineScheduleReceiptSnapshot,
+} from './routine-schedule-promotion.ts';
+
+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;
+}
+
+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);
+  const delivery = preview.payload.delivery;
+  const deliveryTargetCount = delivery?.targets.length ?? 0;
+  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'}`,
+    `  delivery: ${delivery?.mode ?? 'none'}${deliveryTargetCount > 0 ? ` (${deliveryTargetCount} target${deliveryTargetCount === 1 ? '' : 's'})` : ''}`,
+    '  target: external daemon service/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 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 formatRoutineScheduleReceipts(snapshot: RoutineScheduleReceiptSnapshot, limit = 10): string {
+  const receipts = snapshot.receipts.slice(0, Math.max(1, limit));
+  if (snapshot.receipts.length === 0) {
+    return [
+      'Agent routine schedule receipts',
+      `  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}`,
+    ...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}`;
+    }),
+    snapshot.receipts.length > receipts.length ? `  ...${snapshot.receipts.length - receipts.length} more` : '',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+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}`,
+    `  daemon: ${receipt.daemonBaseUrl}`,
+    `  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: ${receipt.target.kind ?? 'unknown'}${receipt.target.surfaceKind ? `/${receipt.target.surfaceKind}` : ''}`,
+    receipt.deliveryMode ? `  delivery: ${receipt.deliveryMode}` : '',
+    ...(receipt.deliveryTargets ?? []).map((target) => `  delivery target: ${target.kind}${target.surfaceKind ? `/${target.surfaceKind}` : ''}${target.routeId ? ` route=${target.routeId}` : ''}${target.address ? ` address=${target.address}` : ''}${target.label ? ` label=${target.label}` : ''}`),
+    receipt.failureKind ? `  failure: ${receipt.failureKind}` : '',
+    receipt.failureError ? `  error: ${receipt.failureError}` : '',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelationResult, limit = 10): string {
+  if (!result.ok) {
+    return [
+      `Daemon schedule reconciliation error: ${result.kind}`,
+      `  ${result.error}`,
+      result.baseUrl ? `  daemon: ${result.baseUrl}` : null,
+      `  route: ${ROUTINE_SCHEDULE_LIST_METHOD} ${result.route}`,
+      result.kind === 'auth_required'
+        ? '  next: pair/authenticate with the externally managed GoodVibes daemon, then retry.'
+        : null,
+      result.kind === 'daemon_unavailable'
+        ? '  next: start/restart the external GoodVibes daemon from TUI or daemon host tooling; Agent does not own daemon lifecycle.'
+        : null,
+      result.kind === 'version_mismatch' || result.kind === 'daemon_route_unavailable'
+        ? '  next: update/restart the external GoodVibes daemon so public schedules.list is available.'
+        : null,
+    ].filter((line): line is string => Boolean(line)).join('\n');
+  }
+  const correlations = result.correlations.slice(0, Math.max(1, limit));
+  if (result.receiptCount === 0) {
+    return [
+      'Agent routine schedule reconciliation',
+      `  daemon: ${result.baseUrl}`,
+      `  route: ${result.kind} ${result.route}`,
+      `  live schedules: ${result.scheduleCount}`,
+      '  No local routine promotion receipts exist yet.',
+      '  Create one with /schedule promote-routine <routine-id> --cron <expr> --yes.',
+    ].join('\n');
+  }
+  const matched = result.correlations.filter((entry) => entry.liveStatus === 'matched').length;
+  const missing = result.correlations.filter((entry) => entry.liveStatus === 'missing').length;
+  const failed = result.correlations.filter((entry) => entry.liveStatus === 'failed-receipt').length;
+  return [
+    'Agent routine schedule reconciliation',
+    `  daemon: ${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')}`
+        : '';
+      const runs = schedule && schedule.runCount !== undefined
+        ? ` 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}`;
+    }),
+    result.correlations.length > correlations.length ? `  ...${result.correlations.length - correlations.length} more` : '',
+  ].filter((line): line is string => Boolean(line)).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');
+}