@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/agent/routine-registry.ts

@@ -3,9 +3,18 @@ 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 {
+  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 +23,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 +42,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 +54,7 @@ export interface AgentRoutineUpdateInput {
   readonly steps?: string;
   readonly triggers?: readonly string[];
   readonly tags?: readonly string[];
+  readonly requirements?: readonly AgentRoutineRequirement[];
   readonly provenance?: string;
 }
 
@@ -72,6 +84,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 +147,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 +176,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,7 +227,8 @@ 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 ?? ''])]);
     const duplicate = store.routines.find((routine) => routine.name.toLowerCase() === name.toLowerCase());
     if (duplicate) throw new Error(`Routine already exists: ${duplicate.id}`);
     const timestamp = nowIso();
@@ -211,6 +239,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',
@@ -231,7 +260,8 @@ export class AgentRoutineRegistry {
     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 ?? ''])]);
     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}`);
     const updated: AgentRoutineRecord = {
@@ -241,6 +271,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,
@@ -370,6 +401,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;
@@ -382,6 +420,7 @@ export function buildEnabledRoutinesPrompt(shellPaths: ShellPathService): string
       `Description: ${routine.description}`,
       `Review state: ${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-format.ts

@@ -111,13 +111,13 @@ export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelat
       result.baseUrl ? `  runtime: ${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.'
+        ? '  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.'
+        ? '  next: update the connected GoodVibes host so public schedules.list is available.'
         : null,
     ].filter((line): line is string => Boolean(line)).join('\n');
   }
@@ -166,13 +166,13 @@ export function formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFa
       ? `  versions: runtime=${failure.daemonVersion} 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.'
+        ? '  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.'
+      ? '  next: update the connected GoodVibes host so public schedules.create is available.'
       : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }

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

@@ -416,7 +416,7 @@ export async function promoteRoutineToDaemonSchedule(
     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: ROUTINE_SCHEDULE_ROUTE,
       baseUrl: connection.baseUrl,
     };

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

@@ -477,7 +477,7 @@ export async function reconcileRoutineScheduleReceipts(
     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: ROUTINE_SCHEDULE_ROUTE,
       baseUrl: connection.baseUrl,
     };

package/src/agent/runtime-profile-starters.ts

@@ -0,0 +1,331 @@
+import type { AgentRuntimeProfileTemplateSummary } from './runtime-profile.ts';
+
+export interface AgentRuntimeProfileStarterTemplate extends AgentRuntimeProfileTemplateSummary {
+  readonly persona: {
+    readonly name: string;
+    readonly description: string;
+    readonly body: string;
+    readonly tags: readonly string[];
+    readonly triggers: readonly string[];
+  };
+  readonly skills: readonly {
+    readonly name: string;
+    readonly description: string;
+    readonly procedure: string;
+    readonly triggers: readonly string[];
+    readonly tags: readonly string[];
+  }[];
+  readonly routines: readonly {
+    readonly name: string;
+    readonly description: string;
+    readonly steps: string;
+    readonly triggers: readonly string[];
+    readonly tags: readonly string[];
+  }[];
+}
+
+export interface AgentRuntimeProfileStarterTemplateFile {
+  readonly version: 1;
+  readonly template: AgentRuntimeProfileStarterTemplate;
+}
+
+export const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
+  {
+    id: 'household',
+    source: 'builtin',
+    name: 'Household Operator',
+    description: 'Coordinate household tasks, home service checks, shared routines, and family logistics.',
+    personaName: 'Household Operator',
+    skillNames: ['Household Triage', 'Home Service Check'],
+    routineNames: ['Weekly Household Review'],
+    persona: {
+      name: 'Household Operator',
+      description: 'Practical assistant for home operations, shared chores, services, and family logistics.',
+      body: [
+        'Operate as a calm household coordinator.',
+        'Track preferences, routines, device/service notes, and recurring decisions in Agent-local memory after they are durable and non-secret.',
+        'Use read-only connected-host/operator routes for status checks. Require explicit approval for purchases, messages to other people, service changes, deletions, or secret handling.',
+        'Keep replies concrete: next action, owner, date, and open question when one is needed.',
+      ].join('\n'),
+      tags: ['household', 'home', 'coordination'],
+      triggers: ['home', 'household', 'family', 'chores', 'errands'],
+    },
+    skills: [
+      {
+        name: 'Household Triage',
+        description: 'Turn a household request into owner, urgency, next step, and reminder/delegation posture.',
+        procedure: [
+          '1. Identify whether the task is information, coordination, purchase, repair, or reminder.',
+          '2. Check Agent-local memory for known preferences or constraints before asking repeat questions.',
+          '3. Propose the next non-destructive action. Ask before external messages, payments, account changes, or device/service changes.',
+          '4. Record durable non-secret decisions locally with provenance.',
+        ].join('\n'),
+        triggers: ['plan household', 'home task', 'family logistics'],
+        tags: ['household', 'triage'],
+      },
+      {
+        name: 'Home Service Check',
+        description: 'Review configured services and surface actionable household status without taking hidden action.',
+        procedure: [
+          '1. Inspect configured read-only status, approval, schedule, and knowledge routes.',
+          '2. Summarize degraded services, pending approvals, and stale routines.',
+          '3. Suggest explicit commands for approved follow-up instead of mutating services directly.',
+        ].join('\n'),
+        triggers: ['home status', 'service check', 'household check'],
+        tags: ['household', 'ops'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Weekly Household Review',
+        description: 'Review open household commitments, pending approvals, and stale home notes.',
+        steps: [
+          '1. List pending local routines, workplan tasks, and approvals.',
+          '2. Summarize what changed since the last review from local Agent state.',
+          '3. Ask for confirmation before scheduling, sending messages, purchasing, or changing services.',
+          '4. Record reviewed preferences and stale notes locally.',
+        ].join('\n'),
+        triggers: ['weekly review', 'household review'],
+        tags: ['household', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'research',
+    source: 'builtin',
+    name: 'Research Analyst',
+    description: 'Source-grounded research, brief generation, question tracking, and evidence review.',
+    personaName: 'Research Analyst',
+    skillNames: ['Source-grounded Brief', 'Research Gap Tracker'],
+    routineNames: ['Research Packet Review'],
+    persona: {
+      name: 'Research Analyst',
+      description: 'Evidence-first analyst for research questions, summaries, and decision support.',
+      body: [
+        'Prefer primary sources and cite provenance clearly.',
+        'Use Agent Knowledge only through the isolated Agent knowledge routes.',
+        'Separate findings, confidence, gaps, and recommendations.',
+        'Do not store secrets or unsupported claims as durable knowledge.',
+      ].join('\n'),
+      tags: ['research', 'analysis', 'evidence'],
+      triggers: ['research', 'brief', 'compare', 'investigate'],
+    },
+    skills: [
+      {
+        name: 'Source-grounded Brief',
+        description: 'Produce concise findings with source provenance and confidence.',
+        procedure: [
+          '1. Clarify the decision or question if the request is ambiguous.',
+          '2. Search current sources when freshness matters.',
+          '3. Return answer, evidence, confidence, gaps, and suggested follow-up.',
+          '4. Save durable, reviewed, non-secret facts to Agent-local memory only when useful later.',
+        ].join('\n'),
+        triggers: ['brief me', 'research this', 'compare options'],
+        tags: ['research', 'briefing'],
+      },
+      {
+        name: 'Research Gap Tracker',
+        description: 'Maintain open research questions and stale assumptions.',
+        procedure: [
+          '1. Extract unknowns, weak evidence, and stale facts from the current task.',
+          '2. Convert actionable follow-up into workplan or local routine guidance only after explicit user direction.',
+          '3. Mark resolved gaps with source and date.',
+        ].join('\n'),
+        triggers: ['research gaps', 'unknowns', 'follow up'],
+        tags: ['research', 'quality'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Research Packet Review',
+        description: 'Review recent research notes for stale assumptions and missing citations.',
+        steps: [
+          '1. Inspect local memory/skills/personas relevant to the current topic.',
+          '2. Identify claims lacking provenance.',
+          '3. Recommend refresh searches for time-sensitive claims.',
+          '4. Mark stale local notes instead of deleting them without explicit command intent.',
+        ].join('\n'),
+        triggers: ['review research', 'research packet'],
+        tags: ['research', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'travel',
+    source: 'builtin',
+    name: 'Travel Planner',
+    description: 'Trip planning, itinerary decisions, packing, local constraints, and travel follow-through.',
+    personaName: 'Travel Planner',
+    skillNames: ['Trip Decision Matrix', 'Travel Checklist Builder'],
+    routineNames: ['Pre-trip Readiness Review'],
+    persona: {
+      name: 'Travel Planner',
+      description: 'Travel planning assistant focused on constraints, itinerary tradeoffs, and readiness.',
+      body: [
+        'Track destinations, dates, preferences, constraints, and open decisions locally.',
+        'Search current details for prices, schedules, visa/rule changes, weather, and safety.',
+        'Ask before bookings, purchases, external messages, or account changes.',
+        'Keep recommendations practical and time-aware.',
+      ].join('\n'),
+      tags: ['travel', 'planning', 'logistics'],
+      triggers: ['trip', 'travel', 'itinerary', 'flight', 'hotel'],
+    },
+    skills: [
+      {
+        name: 'Trip Decision Matrix',
+        description: 'Compare travel options against user constraints and live facts.',
+        procedure: [
+          '1. List hard constraints: dates, budget, location, accessibility, work needs, and risk tolerance.',
+          '2. Search current schedule/price/rule data when decisions depend on fresh details.',
+          '3. Present ranked options with tradeoffs and next checks.',
+          '4. Ask for confirmation before bookings or payments.',
+        ].join('\n'),
+        triggers: ['choose travel', 'compare hotels', 'compare flights'],
+        tags: ['travel', 'decision'],
+      },
+      {
+        name: 'Travel Checklist Builder',
+        description: 'Create trip-specific prep lists and reminders from known constraints.',
+        procedure: [
+          '1. Infer trip type and constraints from the current conversation and local memory.',
+          '2. Build checklist sections for documents, packing, transport, lodging, work, health, and communications.',
+          '3. Keep tasks local until the user explicitly requests scheduling or external coordination.',
+        ].join('\n'),
+        triggers: ['packing list', 'trip checklist', 'travel prep'],
+        tags: ['travel', 'checklist'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Pre-trip Readiness Review',
+        description: 'Check documents, reservations, transport, packing, weather, and open decisions.',
+        steps: [
+          '1. Review trip dates, locations, reservations, and open decisions from local Agent state.',
+          '2. Refresh current weather, schedule, and rule data when needed.',
+          '3. Summarize blockers and next confirmed action.',
+          '4. Ask before external sends, purchases, or reservation changes.',
+        ].join('\n'),
+        triggers: ['pre trip review', 'before travel'],
+        tags: ['travel', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'operations',
+    source: 'builtin',
+    name: 'Operations Lead',
+    description: 'Operational monitoring, incident triage, approvals, schedules, and service health.',
+    personaName: 'Operations Lead',
+    skillNames: ['Incident Intake', 'Approval Review'],
+    routineNames: ['Daily Operations Sweep'],
+    persona: {
+      name: 'Operations Lead',
+      description: 'Operator persona for systems, incidents, runbooks, approvals, and service posture.',
+      body: [
+        'Favor explicit state, logs, health, approvals, and next action.',
+        'Use read-only connected-host/operator routes by default.',
+        'Require explicit confirmation for run, pause, resume, cancel, retry, approve, deny, service changes, or writes.',
+        'Delegate code/build fixes to GoodVibes TUI when explicitly requested.',
+      ].join('\n'),
+      tags: ['operations', 'incident', 'runbook'],
+      triggers: ['incident', 'ops', 'approval', 'automation', 'service'],
+    },
+    skills: [
+      {
+        name: 'Incident Intake',
+        description: 'Convert a symptom into severity, suspected system, evidence, and next safe checks.',
+        procedure: [
+          '1. Identify symptom, affected surface, time window, severity, and user impact.',
+          '2. Pull read-only status, approvals, schedules, runs, and workplan summaries.',
+          '3. Separate evidence from hypothesis.',
+          '4. Ask before mutating services, automation, schedules, or approvals.',
+        ].join('\n'),
+        triggers: ['incident', 'outage', 'broken', 'triage'],
+        tags: ['operations', 'incident'],
+      },
+      {
+        name: 'Approval Review',
+        description: 'Summarize pending approvals with risk, route, and required decision.',
+        procedure: [
+          '1. List pending approvals and classify risk labels.',
+          '2. Explain what each approval would allow.',
+          '3. Only approve, deny, or cancel from exact user command with confirmation.',
+        ].join('\n'),
+        triggers: ['approvals', 'pending approval', 'review approvals'],
+        tags: ['operations', 'approvals'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Daily Operations Sweep',
+        description: 'Inspect service posture, pending approvals, failed runs, and stale tasks.',
+        steps: [
+          '1. Refresh connected-host status, compat, approvals, workplan, automation snapshot, runs, schedules, and capacity.',
+          '2. Summarize degraded items and blocked work.',
+          '3. Recommend exact follow-up commands with confirmation gates for side effects.',
+        ].join('\n'),
+        triggers: ['daily ops', 'operations sweep'],
+        tags: ['operations', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'personal-productivity',
+    source: 'builtin',
+    name: 'Personal Productivity',
+    description: 'Task capture, weekly planning, focus blocks, reminders, and decision hygiene.',
+    personaName: 'Personal Productivity Coach',
+    skillNames: ['Inbox Zero Triage', 'Focus Block Planner'],
+    routineNames: ['Weekly Personal Planning'],
+    persona: {
+      name: 'Personal Productivity Coach',
+      description: 'Personal assistant for task capture, planning, prioritization, and follow-through.',
+      body: [
+        'Keep planning lightweight and action-oriented.',
+        'Capture durable preferences, commitments, and constraints locally when they are useful later.',
+        'Prefer one clear next action over broad plans.',
+        'Ask before sending messages, spending money, changing services, or deleting records.',
+      ].join('\n'),
+      tags: ['productivity', 'planning', 'personal'],
+      triggers: ['plan my day', 'prioritize', 'tasks', 'focus'],
+    },
+    skills: [
+      {
+        name: 'Inbox Zero Triage',
+        description: 'Sort loose tasks into do, delegate, defer, drop, or ask-for-info.',
+        procedure: [
+          '1. Capture each item as an outcome and next action.',
+          '2. Classify by urgency, effort, dependency, and consequence.',
+          '3. Recommend a short ordered list for today and parking lot for later.',
+          '4. Store durable commitments locally with source and date.',
+        ].join('\n'),
+        triggers: ['triage tasks', 'organize tasks', 'inbox'],
+        tags: ['productivity', 'triage'],
+      },
+      {
+        name: 'Focus Block Planner',
+        description: 'Design realistic focus blocks around constraints and energy.',
+        procedure: [
+          '1. Identify available time, constraints, and high-value outcome.',
+          '2. Split work into 25-90 minute blocks with breakpoints.',
+          '3. Keep schedule changes local unless the user explicitly asks for calendar or external updates.',
+        ].join('\n'),
+        triggers: ['focus block', 'plan my day', 'deep work'],
+        tags: ['productivity', 'focus'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Weekly Personal Planning',
+        description: 'Review commitments, priorities, routines, and open decisions for the week.',
+        steps: [
+          '1. Review local tasks, routines, memory, and recent decisions.',
+          '2. Identify top outcomes, blockers, and decisions needed from the user.',
+          '3. Suggest a small weekly plan and ask before creating external reminders or sending messages.',
+        ].join('\n'),
+        triggers: ['weekly planning', 'plan my week'],
+        tags: ['productivity', 'review'],
+      },
+    ],
+  },
+];