@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/agent/operator-actions.ts

@@ -0,0 +1,343 @@
+import type { OperatorMethodInput } from '@pellux/goodvibes-sdk/contracts';
+
+export type JsonRecord = Record<string, unknown>;
+
+export type ApprovalActionId = 'approvals.approve' | 'approvals.deny' | 'approvals.cancel';
+export type AutomationActionId =
+  | 'automation.jobs.run'
+  | 'automation.jobs.pause'
+  | 'automation.jobs.resume'
+  | 'automation.runs.cancel'
+  | 'automation.runs.retry'
+  | 'schedules.run';
+export type OperatorActionId = ApprovalActionId | AutomationActionId;
+
+type ApprovalActionInput =
+  | OperatorMethodInput<'approvals.approve'>
+  | OperatorMethodInput<'approvals.deny'>
+  | OperatorMethodInput<'approvals.cancel'>;
+
+export interface OperatorActionArgs {
+  readonly action?: unknown;
+  readonly targetId?: unknown;
+  readonly approvalId?: unknown;
+  readonly jobId?: unknown;
+  readonly runId?: unknown;
+  readonly scheduleId?: unknown;
+  readonly note?: unknown;
+  readonly remember?: unknown;
+}
+
+export interface OperatorActionDescriptor {
+  readonly action: OperatorActionId;
+  readonly label: string;
+  readonly pathTemplate: string;
+  readonly targetField: 'approvalId' | 'jobId' | 'runId' | 'scheduleId';
+}
+
+export interface OperatorActionRequest {
+  readonly ok: true;
+  readonly descriptor: OperatorActionDescriptor;
+  readonly targetId: string;
+  readonly body: JsonRecord | null;
+}
+
+export interface OperatorActionSuccess {
+  readonly ok: true;
+  readonly methodId: OperatorActionId;
+  readonly path: string;
+  readonly body: unknown;
+}
+
+export interface OperatorActionFailure {
+  readonly ok: false;
+  readonly kind:
+    | 'auth_required'
+    | 'connected_host_unavailable'
+    | 'connected_host_route_unavailable'
+    | 'connected_host_error';
+  readonly error: string;
+  readonly methodId: OperatorActionId;
+  readonly path: string;
+}
+
+export type OperatorActionResult = OperatorActionSuccess | OperatorActionFailure;
+export type OperatorActionParseResult = OperatorActionRequest | { readonly ok: false; readonly error: string };
+
+export interface OperatorActionConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly tokenPath?: string;
+}
+
+export const OPERATOR_ACTIONS: Record<OperatorActionId, OperatorActionDescriptor> = {
+  'approvals.approve': {
+    action: 'approvals.approve',
+    label: 'approve approval',
+    pathTemplate: '/api/approvals/{approvalId}/approve',
+    targetField: 'approvalId',
+  },
+  'approvals.deny': {
+    action: 'approvals.deny',
+    label: 'deny approval',
+    pathTemplate: '/api/approvals/{approvalId}/deny',
+    targetField: 'approvalId',
+  },
+  'approvals.cancel': {
+    action: 'approvals.cancel',
+    label: 'cancel approval',
+    pathTemplate: '/api/approvals/{approvalId}/cancel',
+    targetField: 'approvalId',
+  },
+  'automation.jobs.run': {
+    action: 'automation.jobs.run',
+    label: 'run automation job',
+    pathTemplate: '/api/automation/jobs/{jobId}/run',
+    targetField: 'jobId',
+  },
+  'automation.jobs.pause': {
+    action: 'automation.jobs.pause',
+    label: 'pause automation job',
+    pathTemplate: '/api/automation/jobs/{jobId}/pause',
+    targetField: 'jobId',
+  },
+  'automation.jobs.resume': {
+    action: 'automation.jobs.resume',
+    label: 'resume automation job',
+    pathTemplate: '/api/automation/jobs/{jobId}/resume',
+    targetField: 'jobId',
+  },
+  'automation.runs.cancel': {
+    action: 'automation.runs.cancel',
+    label: 'cancel automation run',
+    pathTemplate: '/api/automation/runs/{runId}/cancel',
+    targetField: 'runId',
+  },
+  'automation.runs.retry': {
+    action: 'automation.runs.retry',
+    label: 'retry automation run',
+    pathTemplate: '/api/automation/runs/{runId}/retry',
+    targetField: 'runId',
+  },
+  'schedules.run': {
+    action: 'schedules.run',
+    label: 'run schedule',
+    pathTemplate: '/api/automation/schedules/{scheduleId}/run',
+    targetField: 'scheduleId',
+  },
+};
+
+export const OPERATOR_ACTION_IDS = Object.keys(OPERATOR_ACTIONS) as readonly OperatorActionId[];
+
+export function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function readOperatorActionString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function readOperatorActionBoolean(value: unknown): boolean {
+  return value === true || value === 'true' || value === 'yes';
+}
+
+export function isOperatorActionId(value: unknown): value is OperatorActionId {
+  return typeof value === 'string' && value in OPERATOR_ACTIONS;
+}
+
+export function targetValue(args: OperatorActionArgs, descriptor: OperatorActionDescriptor): string {
+  const specific = args[descriptor.targetField];
+  return readOperatorActionString(specific) || readOperatorActionString(args.targetId);
+}
+
+export function renderOperatorActionPath(descriptor: OperatorActionDescriptor, targetId: string): string {
+  return descriptor.pathTemplate.replace(`{${descriptor.targetField}}`, encodeURIComponent(targetId));
+}
+
+function approvalBody(args: OperatorActionArgs): ApprovalActionInput {
+  const note = readOperatorActionString(args.note);
+  const body: ApprovalActionInput = {
+    approvalId: targetValue(args, OPERATOR_ACTIONS['approvals.approve']),
+  };
+  if (note) body.note = note;
+  if (args.remember !== undefined) body.remember = readOperatorActionBoolean(args.remember);
+  return body;
+}
+
+function requestBody(args: OperatorActionArgs, action: OperatorActionId): JsonRecord | null {
+  if (action !== 'approvals.approve' && action !== 'approvals.deny' && action !== 'approvals.cancel') return null;
+  const body = approvalBody(args);
+  const out: JsonRecord = {};
+  if (body.note) out.note = body.note;
+  if (body.remember !== undefined) out.remember = body.remember;
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+export function buildOperatorActionRequest(rawArgs: unknown): OperatorActionParseResult {
+  if (!isRecord(rawArgs)) return { ok: false, error: 'Operator action arguments must be an object.' };
+  const args = rawArgs as OperatorActionArgs;
+  if (!isOperatorActionId(args.action)) {
+    return {
+      ok: false,
+      error: `action must be one of: ${OPERATOR_ACTION_IDS.join(', ')}`,
+    };
+  }
+  const descriptor = OPERATOR_ACTIONS[args.action];
+  const targetId = targetValue(args, descriptor);
+  if (!targetId) {
+    return {
+      ok: false,
+      error: `${descriptor.targetField} or targetId is required for ${descriptor.action}.`,
+    };
+  }
+  return {
+    ok: true,
+    descriptor,
+    targetId,
+    body: requestBody(args, descriptor.action),
+  };
+}
+
+async function readResponseBody(response: Response): Promise<unknown> {
+  const text = await response.text();
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return text;
+  }
+}
+
+function summarizeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function classifyHttpFailure(
+  methodId: OperatorActionId,
+  path: string,
+  status: number,
+  body: unknown,
+): OperatorActionFailure {
+  const detail = isRecord(body) && typeof body.error === 'string' ? body.error : '';
+  return {
+    ok: false,
+    methodId,
+    path,
+    kind: status === 401 || status === 403
+      ? 'auth_required'
+      : status === 404
+        ? 'connected_host_route_unavailable'
+        : 'connected_host_error',
+    error: `HTTP ${status}${detail ? `: ${detail}` : ''}`,
+  };
+}
+
+export async function postOperatorAction(
+  connection: OperatorActionConnection,
+  request: OperatorActionRequest,
+): Promise<OperatorActionResult> {
+  const path = renderOperatorActionPath(request.descriptor, request.targetId);
+  const token = connection.token;
+  if (!token) {
+    return {
+      ok: false,
+      methodId: request.descriptor.action,
+      path,
+      kind: 'auth_required',
+      error: connection.tokenPath ? `no connected-host operator token found at ${connection.tokenPath}` : 'no connected-host operator token found',
+    };
+  }
+  const headers: HeadersInit = {
+    authorization: `Bearer ${token}`,
+  };
+  const init: RequestInit = {
+    method: 'POST',
+    headers,
+  };
+  if (request.body) {
+    headers['content-type'] = 'application/json';
+    init.body = JSON.stringify(request.body);
+  }
+  try {
+    const response = await fetch(`${connection.baseUrl}${path}`, init);
+    const body = await readResponseBody(response);
+    if (!response.ok) return classifyHttpFailure(request.descriptor.action, path, response.status, body);
+    return {
+      ok: true,
+      methodId: request.descriptor.action,
+      path,
+      body,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      methodId: request.descriptor.action,
+      path,
+      kind: 'connected_host_unavailable',
+      error: summarizeError(error),
+    };
+  }
+}
+
+export function statusFromOperatorActionBody(body: unknown): string {
+  if (!isRecord(body)) return 'ok';
+  const approval = body.approval;
+  if (isRecord(approval) && typeof approval.status === 'string') return approval.status;
+  const run = body.run;
+  if (isRecord(run) && typeof run.status === 'string') return run.status;
+  if (typeof body.status === 'string') return body.status;
+  if (typeof body.enabled === 'boolean') return body.enabled ? 'enabled' : 'disabled';
+  return 'ok';
+}
+
+function formatOperatorActionFailureKind(kind: OperatorActionFailure['kind']): 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';
+  return 'connected host error';
+}
+
+export function formatOperatorActionSuccess(baseUrl: string, result: OperatorActionSuccess): string {
+  return [
+    'Agent operator action completed',
+    `  method: ${result.methodId}`,
+    `  route: POST ${result.path}`,
+    `  connected host: ${baseUrl}`,
+    `  status: ${statusFromOperatorActionBody(result.body)}`,
+  ].join('\n');
+}
+
+export function formatOperatorActionFailure(result: OperatorActionFailure): string {
+  return [
+    `Agent operator action failed: ${result.kind} (${formatOperatorActionFailureKind(result.kind)})`,
+    `  method: ${result.methodId}`,
+    `  route: POST ${result.path}`,
+    `  error: ${result.error}`,
+  ].join('\n');
+}
+
+export function formatOperatorActionPreview(request: OperatorActionRequest, explicitUserRequest: string): string {
+  return [
+    'Agent operator action preview',
+    `  method ${request.descriptor.action}`,
+    `  action ${request.descriptor.label}`,
+    `  target ${request.targetId}`,
+    `  route POST ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
+    explicitUserRequest ? `  requested by ${explicitUserRequest}` : '  requested by (missing)',
+    '',
+    'Confirmation required: type yes in the workspace form or pass --yes only when the user explicitly asked GoodVibes Agent to perform this exact operator action.',
+  ].join('\n');
+}
+
+export function formatOperatorActionToolPreview(request: OperatorActionRequest, explicitUserRequest: string): string {
+  return [
+    'Agent operator action preview',
+    `  method ${request.descriptor.action}`,
+    `  action ${request.descriptor.label}`,
+    `  target ${request.targetId}`,
+    `  route POST ${renderOperatorActionPath(request.descriptor, request.targetId)}`,
+    explicitUserRequest ? `  requested by ${explicitUserRequest}` : '  requested by (missing)',
+    '',
+    'Model tool confirmation required. Call this tool with confirm:true only when the user explicitly asked GoodVibes Agent to perform this exact operator action.',
+  ].join('\n');
+}

package/src/agent/persona-discovery.ts

@@ -14,7 +14,7 @@ export interface DiscoveredPersonaRecord {
   readonly frontmatter: Record<string, string>;
 }
 
-const DIRECTORY_MARKERS: readonly string[] = ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'];
+const DIRECTORY_MARKERS: readonly string[] = ['PERSONA.md', 'persona.md'];
 
 function parseFrontmatter(content: string): Record<string, string> {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -33,10 +33,8 @@ function getPersonaDirectories(cwd: string, homeDir: string): Array<{ root: stri
   return [
     { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
     { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
-    { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
     { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
     { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
-    { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
   ];
 }
 

package/src/agent/persona-registry.ts

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import { dirname } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { formatAgentRecordReviewState } from './record-labels.ts';
 
 export type AgentPersonaSource = 'user' | 'agent' | 'imported' | 'system';
 export type AgentPersonaReviewState = 'fresh' | 'reviewed' | 'stale';
@@ -106,9 +107,9 @@ function containsSecretLikeText(text: string): boolean {
   return SECRET_PATTERNS.some((pattern) => pattern.test(text));
 }
 
-export function assertNoSecretLikeText(fields: readonly string[]): void {
+export function assertNoSecretLikeText(fields: readonly string[], ownerLabel = 'Agent local records'): void {
   if (fields.some((field) => containsSecretLikeText(field))) {
-    throw new Error('Personas cannot store secret-looking values. Store a secret reference or remove the sensitive text.');
+    throw new Error(`${ownerLabel} cannot store secret-looking values. Store a secret reference or remove the sensitive text.`);
   }
 }
 
@@ -158,14 +159,16 @@ function formatStore(store: PersonaStoreFile): string {
   return `${JSON.stringify(store, null, 2)}\n`;
 }
 
-export function personaStorePath(shellPaths: ShellPathService): string {
+type AgentLocalStorePaths = Pick<ShellPathService, 'resolveUserPath'>;
+
+export function personaStorePath(shellPaths: AgentLocalStorePaths): string {
   return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'personas', 'personas.json');
 }
 
 export class AgentPersonaRegistry {
   public constructor(private readonly storePath: string) {}
 
-  public static fromShellPaths(shellPaths: ShellPathService): AgentPersonaRegistry {
+  public static fromShellPaths(shellPaths: AgentLocalStorePaths): AgentPersonaRegistry {
     return new AgentPersonaRegistry(personaStorePath(shellPaths));
   }
 
@@ -211,9 +214,9 @@ export class AgentPersonaRegistry {
     const description = input.description.trim();
     const body = input.body.trim();
     this.validateRequired(name, description, body);
-    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])], 'Personas');
     const duplicate = store.personas.find((persona) => persona.name.toLowerCase() === name.toLowerCase());
-    if (duplicate) throw new Error(`Persona already exists: ${duplicate.id}`);
+    if (duplicate) throw new Error(`Persona already exists ${duplicate.id}`);
     const timestamp = nowIso();
     const persona: AgentPersonaRecord = {
       id: this.nextId(name, store.personas),
@@ -235,14 +238,14 @@ export class AgentPersonaRegistry {
   public update(idOrName: string, input: AgentPersonaUpdateInput): AgentPersonaRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown persona ${idOrName}`);
     const name = input.name === undefined ? existing.name : normalizeName(input.name);
     const description = input.description === undefined ? existing.description : input.description.trim();
     const body = input.body === undefined ? existing.body : input.body.trim();
     this.validateRequired(name, description, body);
-    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])], 'Personas');
     const duplicate = store.personas.find((persona) => persona.id !== existing.id && persona.name.toLowerCase() === name.toLowerCase());
-    if (duplicate) throw new Error(`Persona already exists: ${duplicate.id}`);
+    if (duplicate) throw new Error(`Persona already exists ${duplicate.id}`);
     const updated: AgentPersonaRecord = {
       ...existing,
       name,
@@ -266,7 +269,7 @@ export class AgentPersonaRegistry {
   public setActive(idOrName: string): AgentPersonaRecord {
     const store = this.readStore();
     const persona = this.findInStore(store, idOrName);
-    if (!persona) throw new Error(`Unknown persona: ${idOrName}`);
+    if (!persona) throw new Error(`Unknown persona ${idOrName}`);
     this.writeStore({ ...store, activePersonaId: persona.id });
     return persona;
   }
@@ -279,7 +282,7 @@ export class AgentPersonaRegistry {
   public markReviewed(idOrName: string): AgentPersonaRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown persona ${idOrName}`);
     const updated: AgentPersonaRecord = {
       ...existing,
       reviewState: 'reviewed',
@@ -297,7 +300,7 @@ export class AgentPersonaRegistry {
   public markStale(idOrName: string, reason: string): AgentPersonaRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown persona ${idOrName}`);
     const updated: AgentPersonaRecord = {
       ...existing,
       reviewState: 'stale',
@@ -314,7 +317,7 @@ export class AgentPersonaRegistry {
   public deletePersona(idOrName: string): AgentPersonaRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
-    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    if (!existing) throw new Error(`Unknown persona ${idOrName}`);
     this.writeStore({
       ...store,
       activePersonaId: store.activePersonaId === existing.id ? null : store.activePersonaId,
@@ -351,7 +354,7 @@ export class AgentPersonaRegistry {
     try {
       return parseStore(readFileSync(this.storePath, 'utf-8'));
     } catch (error) {
-      throw new Error(`Could not read Agent persona store: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Could not read Agent persona store ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
@@ -370,10 +373,10 @@ export function buildActivePersonaPrompt(shellPaths: ShellPathService): string |
     '## Active GoodVibes Agent Persona',
     `Name: ${active.name}`,
     `Description: ${active.description}`,
-    `Review state: ${active.reviewState}`,
+    `Review: ${formatAgentRecordReviewState(active.reviewState)}`,
     '',
     active.body,
     '',
-    'Apply this persona inside the same serial assistant conversation. Do not spawn background agents because a persona is active.',
+    'Apply this persona inside the same serial assistant conversation. Do not spawn separate Agent jobs because a persona is active.',
   ].join('\n');
 }

package/src/agent/record-labels.ts

@@ -0,0 +1,107 @@
+const SOURCE_LABELS = {
+  user: 'User',
+  agent: 'Agent',
+  imported: 'Imported',
+  system: 'Built-in',
+  builtin: 'Built-in',
+  local: 'Local',
+  'agent-memory': 'Agent memory',
+} as const satisfies Readonly<Record<string, string>>;
+
+const USER_PROVENANCE_LABELS = new Set<string>([
+  'Workspace',
+  'Workspace capture',
+  'Command',
+  'Manual',
+  'Main conversation',
+]);
+
+const REVIEW_STATE_LABELS = {
+  fresh: 'Needs review',
+  reviewed: 'Reviewed',
+  stale: 'Needs refresh',
+  contradicted: 'Contradicted',
+} as const satisfies Readonly<Record<string, string>>;
+
+type SourceLabelKey = keyof typeof SOURCE_LABELS;
+type ReviewStateLabelKey = keyof typeof REVIEW_STATE_LABELS;
+
+export interface AgentRecordReference {
+  readonly kind: string;
+  readonly ref: string;
+  readonly label?: string;
+}
+
+function titleCaseWords(value: string): string {
+  return value
+    .trim()
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+
+export function formatAgentRecordSource(source: string | undefined): string {
+  const normalized = (source ?? '').trim().toLowerCase();
+  if (!normalized) return 'Unknown';
+  if (normalized in SOURCE_LABELS) return SOURCE_LABELS[normalized as SourceLabelKey];
+  return titleCaseWords(source ?? '');
+}
+
+export function formatAgentRecordReviewState(reviewState: string | undefined): string {
+  const normalized = (reviewState ?? '').trim().toLowerCase();
+  if (!normalized) return REVIEW_STATE_LABELS.fresh;
+  if (normalized in REVIEW_STATE_LABELS) return REVIEW_STATE_LABELS[normalized as ReviewStateLabelKey];
+  return titleCaseWords(reviewState ?? '');
+}
+
+export function formatAgentRecordProvenance(provenance: string | undefined): string {
+  const raw = (provenance ?? '').trim();
+  const normalized = raw.toLowerCase();
+  if (!raw) return '';
+  if (normalized === 'agent-workspace') return 'Workspace';
+  if (normalized === 'agent-workspace-learned-behavior') return 'Workspace capture';
+  if (normalized === 'workspace capture') return 'Workspace capture';
+  if (normalized === 'slash-command') return 'Command';
+  if (normalized === 'agent-memory') return 'Agent memory';
+  if (normalized === 'manual') return 'Manual';
+  if (normalized === 'main-conversation') return 'Main conversation';
+  if (normalized === 'plan-command') return 'Planning command';
+  if (normalized === 'agent-media-generation') return 'Media generation';
+  if (normalized === 'agent-channel-send') return 'Channel delivery';
+  if (normalized === 'project-memory') return 'Project memory';
+
+  const discovered = raw.match(/^discovered:([^:]+):(.+)$/i);
+  if (discovered) {
+    return `Imported file (${discovered[1]}): ${discovered[2]}`;
+  }
+
+  const starter = raw.match(/^goodvibes-agent starter:(.+)$/i);
+  if (starter) {
+    return `Starter profile: ${starter[1]}`;
+  }
+
+  return titleCaseWords(raw);
+}
+
+export function formatAgentRecordOrigin(source: string | undefined, provenance: string | undefined): string {
+  const sourceLabel = formatAgentRecordSource(source);
+  const provenanceLabel = formatAgentRecordProvenance(provenance);
+  if (!provenanceLabel || provenanceLabel === sourceLabel) return sourceLabel;
+  if (sourceLabel === 'User' && USER_PROVENANCE_LABELS.has(provenanceLabel)) {
+    return provenanceLabel;
+  }
+  if (sourceLabel === 'Imported' && provenanceLabel.startsWith('Imported file')) {
+    return provenanceLabel;
+  }
+  return `${sourceLabel} (${provenanceLabel})`;
+}
+
+export function formatAgentRecordReference(reference: AgentRecordReference): string {
+  const kind = titleCaseWords(reference.kind);
+  const label = reference.label?.trim();
+  return `${kind}: ${reference.ref}${label ? ` (${label})` : ''}`;
+}
+
+export function formatAgentRecordReferences(references: readonly AgentRecordReference[]): string {
+  return references.map(formatAgentRecordReference).join(', ');
+}

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

@@ -22,20 +22,29 @@ function scheduleValue(preview: ReminderSchedulePreview): string {
   return String(preview.payload.at);
 }
 
+function formatReminderScheduleFailureKind(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 formatReminderSchedulePreview(preview: ReminderSchedulePreview): string {
   const delivery = preview.payload.delivery;
   const deliveryTargetCount = delivery?.targets.length ?? 0;
   return [
     'GoodVibes schedule preview for Agent reminder',
-    `  route: ${preview.method} ${preview.route}`,
-    `  name: ${String(preview.payload.name ?? '(service default)')}`,
-    `  reminder: ${preview.message}`,
-    `  schedule: ${preview.payload.kind} ${scheduleValue(preview)}`,
-    `  enabled: ${preview.payload.enabled === false ? 'no' : 'yes'}`,
-    `  delivery: ${delivery?.mode ?? 'none'}${deliveryTargetCount > 0 ? ` (${deliveryTargetCount} target${deliveryTargetCount === 1 ? '' : 's'})` : ''}`,
-    '  target: connected GoodVibes services/main conversation route',
-    '  policy: reminder delivery only; isolated Agent Knowledge only; no default wiki/non-Agent fallback',
-    '  next: rerun with --yes to create this connected reminder schedule',
+    `  route ${preview.method} ${preview.route}`,
+    `  name ${String(preview.payload.name ?? '(service default)')}`,
+    `  reminder ${preview.message}`,
+    `  schedule ${preview.payload.kind} ${scheduleValue(preview)}`,
+    `  enabled ${preview.payload.enabled === false ? 'no' : 'yes'}`,
+    `  delivery ${delivery?.mode ?? 'none'}${deliveryTargetCount > 0 ? ` (${deliveryTargetCount} target${deliveryTargetCount === 1 ? '' : 's'})` : ''}`,
+    '  target connected GoodVibes host/main conversation route',
+    '  policy reminder delivery only; isolated Agent Knowledge only; no default knowledge/non-Agent fallback',
+    '  next rerun with --yes to create this connected reminder schedule',
   ].join('\n');
 }
 
@@ -45,31 +54,31 @@ export function formatReminderScheduleSuccess(result: ReminderScheduleSuccess):
   const status = readString(record, 'status') ?? (record.enabled === false ? 'paused' : 'enabled');
   return [
     'Created GoodVibes schedule for Agent reminder',
-    `  schedule: ${id}`,
-    `  status: ${status}`,
-    `  route: ${result.kind} ${result.route}`,
-    `  reminder: ${result.message}`,
-    '  next: inspect with /schedule list',
+    `  schedule ${id}`,
+    `  status ${status}`,
+    `  route ${result.kind} ${result.route}`,
+    `  reminder ${result.message}`,
+    '  next inspect with /schedule list',
   ].join('\n');
 }
 
 export function formatReminderScheduleFailure(failure: ReminderScheduleFailure): string {
   return [
-    `GoodVibes reminder schedule error: ${failure.kind}`,
+    `GoodVibes reminder schedule error ${formatReminderScheduleFailureKind(failure.kind)}`,
     `  ${failure.error}`,
-    failure.baseUrl ? `  service: ${failure.baseUrl}` : null,
-    `  route: ${REMINDER_SCHEDULE_METHOD} ${failure.route}`,
-    failure.kind === 'version_mismatch' && failure.daemonVersion && failure.expectedSdkVersion
-      ? `  versions: service=${failure.daemonVersion} expected=${failure.expectedSdkVersion}`
+    failure.baseUrl ? `  connected host ${failure.baseUrl}` : null,
+    `  route ${REMINDER_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');
 }