@pellux/goodvibes-agent 0.1.114 → 0.1.116

package/src/agent/runtime-profile.ts

@@ -4,6 +4,11 @@ import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { AgentPersonaRegistry } from './persona-registry.ts';
 import { AgentRoutineRegistry } from './routine-registry.ts';
 import { AgentSkillRegistry } from './skill-registry.ts';
+import { discoverPersonas, type DiscoveredPersonaRecord } from './persona-discovery.ts';
+import { discoverRoutines, type DiscoveredRoutineRecord } from './routine-discovery.ts';
+import { discoverSkills, type SkillRecord } from './skill-discovery.ts';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { STARTER_TEMPLATES, type AgentRuntimeProfileStarterTemplate, type AgentRuntimeProfileStarterTemplateFile } from './runtime-profile-starters.ts';
 
 export type AgentRuntimeProfileTemplateId = string;
 export type AgentRuntimeProfileTemplateSource = 'builtin' | 'local';
@@ -45,6 +50,21 @@ export interface CreateAgentRuntimeProfileOptions {
   readonly templateId?: AgentRuntimeProfileTemplateId;
 }
 
+export interface CreateAgentRuntimeProfileTemplateFromDiscoveredOptions {
+  readonly id: AgentRuntimeProfileTemplateId;
+  readonly name?: string;
+  readonly description?: string;
+  readonly persona?: string;
+  readonly skills?: readonly string[];
+  readonly routines?: readonly string[];
+  readonly replace?: boolean;
+}
+
+export interface CreateAgentRuntimeProfileFromDiscoveredOptions extends Omit<CreateAgentRuntimeProfileTemplateFromDiscoveredOptions, 'id'> {
+  readonly profileName: string;
+  readonly templateId?: AgentRuntimeProfileTemplateId;
+}
+
 export interface AgentRuntimeProfileCommandResult {
   readonly ok: boolean;
   readonly kind:
@@ -53,6 +73,8 @@ export interface AgentRuntimeProfileCommandResult {
     | 'agent.profiles.templates'
     | 'agent.profiles.template.export'
     | 'agent.profiles.template.import'
+    | 'agent.profiles.template.from_discovered'
+    | 'agent.profiles.create_from_discovered'
     | 'agent.profiles.create'
     | 'agent.profiles.delete'
     | 'agent.profiles.error';
@@ -71,336 +93,6 @@ export interface AgentRuntimeProfileCommandResult {
 const PROFILE_CREATED_FILE = 'profile.json';
 const PROFILE_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
 
-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[];
-  }[];
-}
-
-interface AgentRuntimeProfileStarterTemplateFile {
-  readonly version: 1;
-  readonly template: AgentRuntimeProfileStarterTemplate;
-}
-
-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 daemon/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 daemon/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 daemon 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'],
-      },
-    ],
-  },
-];
-
 export function normalizeAgentRuntimeProfileId(value: string): string {
   return value
     .trim()
@@ -514,6 +206,72 @@ function parseStringArray(value: unknown): readonly string[] {
   return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function splitFrontmatterList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function normalizedLookupValues(value: string, path?: string): readonly string[] {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = path?.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [value, slug, path ?? '', basename].map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+}
+
+function selectDiscoveredRecord<T extends { readonly name: string; readonly path: string }>(
+  records: readonly T[],
+  selector: string | undefined,
+  label: string,
+): T {
+  if (records.length === 0) throw new Error(`No discovered Agent ${label} files found.`);
+  if (!selector?.trim()) return records[0]!;
+  const lookup = selector.trim().toLowerCase();
+  const match = records.find((record) => normalizedLookupValues(record.name, record.path).includes(lookup));
+  if (!match) throw new Error(`Unknown discovered Agent ${label}: ${selector}.`);
+  return match;
+}
+
+function selectDiscoveredRecords<T extends { readonly name: string; readonly path: string }>(
+  records: readonly T[],
+  selectors: readonly string[] | undefined,
+  label: string,
+): readonly T[] {
+  if (records.length === 0) throw new Error(`No discovered Agent ${label} files found.`);
+  if (!selectors || selectors.length === 0 || selectors.includes('all')) return records;
+  return selectors.map((selector) => selectDiscoveredRecord(records, selector, label));
+}
+
+function discoveredSkillToTemplate(skill: SkillRecord): AgentRuntimeProfileStarterTemplate['skills'][number] {
+  if (!skill.body.trim()) throw new Error(`Discovered Agent skill ${skill.name} has no procedure body.`);
+  return {
+    name: skill.name,
+    description: skill.description || `Imported skill from ${skill.origin} skill file.`,
+    procedure: skill.body,
+    triggers: splitFrontmatterList(skill.frontmatter.triggers),
+    tags: splitFrontmatterList(skill.frontmatter.tags),
+  };
+}
+
+function discoveredRoutineToTemplate(routine: DiscoveredRoutineRecord): AgentRuntimeProfileStarterTemplate['routines'][number] {
+  if (!routine.steps.trim()) throw new Error(`Discovered Agent routine ${routine.name} has no steps.`);
+  return {
+    name: routine.name,
+    description: routine.description || `Imported routine from ${routine.origin} markdown file.`,
+    steps: routine.steps,
+    triggers: splitFrontmatterList(routine.frontmatter.triggers),
+    tags: splitFrontmatterList(routine.frontmatter.tags),
+  };
+}
+
+function discoveredPersonaToTemplate(persona: DiscoveredPersonaRecord): AgentRuntimeProfileStarterTemplate['persona'] {
+  return {
+    name: persona.name,
+    description: persona.description || `Imported persona from ${persona.origin} markdown file.`,
+    body: persona.body,
+    tags: splitFrontmatterList(persona.frontmatter.tags),
+    triggers: splitFrontmatterList(persona.frontmatter.triggers),
+  };
+}
+
 function readTemplateTextBlock(value: unknown, field: string): string {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`Starter template ${field} is required.`);
   return value.trim();
@@ -650,6 +408,68 @@ export function importAgentRuntimeProfileTemplate(baseHomeDirectory: string, sou
   return summarizeTemplate({ ...parsed, source: 'local', path: target });
 }
 
+export async function createAgentRuntimeProfileTemplateFromDiscovered(
+  shellPaths: Pick<ShellPathService, 'homeDirectory' | 'workingDirectory'>,
+  options: CreateAgentRuntimeProfileTemplateFromDiscoveredOptions,
+): Promise<AgentRuntimeProfileTemplateSummary> {
+  const id = assertValidAgentRuntimeProfileId(options.id);
+  const [personas, skills, routines] = await Promise.all([
+    discoverPersonas(shellPaths),
+    discoverSkills(shellPaths),
+    discoverRoutines(shellPaths),
+  ]);
+  const selectedPersona = selectDiscoveredRecord(personas, options.persona, 'persona');
+  const selectedSkills = selectDiscoveredRecords(skills, options.skills, 'skill');
+  const selectedRoutines = selectDiscoveredRecords(routines, options.routines, 'routine');
+  const target = join(getAgentRuntimeProfileTemplatesRoot(shellPaths.homeDirectory), `${id}.json`);
+  if (existsSync(target) && options.replace !== true) {
+    throw new Error(`Agent starter template already exists: ${id}. Rerun with --replace to overwrite it.`);
+  }
+  const persona = discoveredPersonaToTemplate(selectedPersona);
+  const template: AgentRuntimeProfileStarterTemplate = {
+    id,
+    source: 'local',
+    path: target,
+    name: options.name?.trim() || `${persona.name} Starter`,
+    description: options.description?.trim() || 'Agent starter template assembled from discovered local persona, skill, and routine files.',
+    personaName: persona.name,
+    skillNames: selectedSkills.map((skill) => skill.name),
+    routineNames: selectedRoutines.map((routine) => routine.name),
+    persona,
+    skills: selectedSkills.map(discoveredSkillToTemplate),
+    routines: selectedRoutines.map(discoveredRoutineToTemplate),
+  };
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, `${JSON.stringify(templateFilePayload(template), null, 2)}\n`, 'utf-8');
+  return summarizeTemplate(template);
+}
+
+export async function createAgentRuntimeProfileFromDiscovered(
+  shellPaths: Pick<ShellPathService, 'homeDirectory' | 'workingDirectory'>,
+  options: CreateAgentRuntimeProfileFromDiscoveredOptions,
+): Promise<{
+  readonly profile: AgentRuntimeProfileInfo;
+  readonly template: AgentRuntimeProfileTemplateSummary;
+}> {
+  const profileId = assertValidAgentRuntimeProfileId(options.profileName);
+  const resolution = resolveAgentRuntimeProfileHome(shellPaths.homeDirectory, profileId);
+  if (existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile already exists: ${resolution.id}`);
+  }
+  const templateId = assertValidAgentRuntimeProfileId(options.templateId ?? profileId);
+  const template = await createAgentRuntimeProfileTemplateFromDiscovered(shellPaths, {
+    id: templateId,
+    name: options.name,
+    description: options.description,
+    persona: options.persona,
+    skills: options.skills,
+    routines: options.routines,
+    replace: options.replace,
+  });
+  const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, profileId, { templateId: template.id });
+  return { profile, template };
+}
+
 function createMissingSkill(registry: AgentSkillRegistry, template: AgentRuntimeProfileStarterTemplate['skills'][number]): string {
   const existing = registry.get(template.name);
   if (existing) return existing.id;

package/src/cli/help.ts

@@ -157,9 +157,9 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     examples: ['providers', 'providers inspect openai-subscriber', 'providers use openai openai:gpt-5.4'],
   },
   profiles: {
-    usage: ['profiles list', 'profiles templates', 'profiles templates export <id> <path> --yes', 'profiles templates import <path> --yes', 'profiles show <name>', 'profiles create <name> [--template <id>] --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
+    usage: ['profiles list', 'profiles templates', 'profiles templates from-discovered <id> --yes', 'profiles create-from-discovered <name> --yes', 'profiles templates export <id> <path> --yes', 'profiles templates import <path> --yes', 'profiles show <name>', 'profiles create <name> [--template <id>] --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
     summary: 'Create and inspect isolated Agent profile homes, with starter templates for household, research, travel, operations, personal productivity, and local imported starters. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing connected GoodVibes services.',
-    examples: ['profiles templates', 'profiles templates export research ./research-starter.json --yes', 'profiles templates import ./research-starter.json --yes', 'profiles create household --template household --yes', '--agent-profile household status'],
+    examples: ['profiles templates', 'profiles create-from-discovered research-desk --yes', 'profiles templates from-discovered research-desk --yes', 'profiles templates export research ./research-starter.json --yes', 'profiles templates import ./research-starter.json --yes', 'profiles create household --template household --yes', '--agent-profile household status'],
   },
   personas: {
     usage: [