@pellux/goodvibes-agent 0.1.33 → 0.1.34

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.34 - 2026-05-31
+
+- 28838cc Add curated Agent profile starters
+
 ## 0.1.33 - 2026-05-31
 
 - bfe0127 Add profile portability workspace coverage

package/README.md

@@ -49,12 +49,13 @@ Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/He
 Use isolated Agent runtime profiles when one machine needs separate operator identities or local state:
 
 ```sh
-goodvibes-agent profiles create household --yes
+goodvibes-agent profiles templates
+goodvibes-agent profiles create household --template household --yes
 goodvibes-agent --agent-profile household status
 GOODVIBES_AGENT_HOME=/path/to/agent-home goodvibes-agent status
 ```
 
-Profiles isolate Agent-local config, sessions, local memory, personas, skills, routines, and setup state. The daemon is still external and shared unless your daemon host is separately configured otherwise.
+Profiles isolate Agent-local config, sessions, local memory, personas, skills, routines, and setup state. Starter templates seed local personas, skills, and routines for household, research, travel, operations, and personal productivity profiles. The daemon is still external and shared unless your daemon host is separately configured otherwise.
 
 Local Agent behavior is editable from the TUI:
 

package/docs/README.md

@@ -20,7 +20,8 @@ Important baseline constraints:
 - 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 exposes `goodvibes-agent capabilities` and `/capabilities` to compare OpenClaw/Hermes capability targets against current Agent readiness and configuration paths.
-- Agent supports isolated runtime homes with `GOODVIBES_AGENT_HOME=<path>` and named profile homes with `goodvibes-agent profiles create <name> --yes` plus `--agent-profile <name>`.
+- 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.
 - Local personas, routines, and Agent skills are stored under the Agent surface root and are injected only into the serial Agent conversation.
 - Normal assistant chat is not coding-session delegation.
 - Build/fix/review delegation to GoodVibes TUI must be explicit; WRFC is not the default Agent behavior.

package/docs/getting-started.md

@@ -48,12 +48,13 @@ GOODVIBES_AGENT_HOME=/path/to/agent-home goodvibes-agent status
 Use named runtime profiles for repeatable local identities:
 
 ```sh
-goodvibes-agent profiles create household --yes
+goodvibes-agent profiles templates
+goodvibes-agent profiles create household --template household --yes
 goodvibes-agent --agent-profile household status
 goodvibes-agent --agent-profile household
 ```
 
-Named profiles isolate Agent-local config, sessions, memory, personas, skills, routines, and setup state under a profile-specific home. They do not start or isolate the external daemon by themselves.
+Named profiles isolate Agent-local config, sessions, memory, personas, skills, routines, and setup state under a profile-specific home. Starter templates seed local personas, skills, and routines for household, research, travel, operations, and personal productivity profiles. They do not start or isolate the external daemon by themselves.
 
 ## Local Personas, Routines, And Skills
 

package/docs/operator-capability-benchmark.md

@@ -57,7 +57,7 @@ Primary sources used for the benchmark:
 | Tools/MCP | Broad toolsets, MCP, browser, media, terminal, files | GoodVibes SDK tools with Agent policy guards and MCP/provider integrations |
 | Voice/media/canvas/nodes | Voice, TTS, mobile nodes, live canvas, browser automation | GoodVibes media/voice/browser/node primitives with an Agent workspace for setup, image input, browser posture, MCP, and remote/node inspection |
 | Build/code work | Direct terminal/file/code tools and subagents | Explicit delegation to GoodVibes TUI; local WRFC/spawn fanout blocked |
-| Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; the Agent workspace exposes profile and portability flows; daemon remains external |
+| Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; starter templates seed local personas/skills/routines; the Agent workspace exposes profile and portability flows; daemon remains external |
 | Security | DM pairing, approvals, sandboxing, allowlists | Daemon approvals, auth diagnostics, secret refs, confirmation gates, model-tool policy |
 
 ## Exceed Targets
@@ -75,7 +75,7 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 
 - Live daemon account health and last delivery errors in the Channels workspace once a stable read-only route is available.
 - Artifact and multimodal Agent Knowledge ingest affordances once Agent-specific routes are stable.
-- Curated profile starter templates for household, research, travel, operations, and personal productivity profiles.
+- Custom starter profile authoring/import for teams and repeatable operator lanes.
 - Artifact and multimodal Agent Knowledge ingestion when the isolated Agent route accepts artifact-backed media.
 - Delegation receipts and artifact review inside the operator workspace.
 - Approval center with route risk labels and saved policy presets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "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",

package/src/agent/runtime-profile.ts

@@ -1,5 +1,20 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+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';
+
+export type AgentRuntimeProfileTemplateId = 'household' | 'research' | 'travel' | 'operations' | 'personal-productivity';
+
+export interface AgentRuntimeProfileTemplateSummary {
+  readonly id: AgentRuntimeProfileTemplateId;
+  readonly name: string;
+  readonly description: string;
+  readonly personaName: string;
+  readonly skillNames: readonly string[];
+  readonly routineNames: readonly string[];
+}
 
 export interface AgentRuntimeProfileResolution {
   readonly id: string;
@@ -8,6 +23,22 @@ export interface AgentRuntimeProfileResolution {
 
 export interface AgentRuntimeProfileInfo extends AgentRuntimeProfileResolution {
   readonly createdAt: string | null;
+  readonly starterTemplateId?: AgentRuntimeProfileTemplateId;
+  readonly starterTemplateName?: string;
+  readonly starterTemplateApplication?: AgentRuntimeProfileTemplateApplication;
+}
+
+export interface AgentRuntimeProfileTemplateApplication {
+  readonly id: AgentRuntimeProfileTemplateId;
+  readonly name: string;
+  readonly appliedAt: string;
+  readonly personaIds: readonly string[];
+  readonly skillIds: readonly string[];
+  readonly routineIds: readonly string[];
+}
+
+export interface CreateAgentRuntimeProfileOptions {
+  readonly templateId?: AgentRuntimeProfileTemplateId;
 }
 
 export interface AgentRuntimeProfileCommandResult {
@@ -15,12 +46,15 @@ export interface AgentRuntimeProfileCommandResult {
   readonly kind:
     | 'agent.profiles.list'
     | 'agent.profiles.show'
+    | 'agent.profiles.templates'
     | 'agent.profiles.create'
     | 'agent.profiles.delete'
     | 'agent.profiles.error';
   readonly data?: {
     readonly profiles?: readonly AgentRuntimeProfileInfo[];
     readonly profile?: AgentRuntimeProfileInfo;
+    readonly templates?: readonly AgentRuntimeProfileTemplateSummary[];
+    readonly appliedTemplate?: AgentRuntimeProfileTemplateApplication;
     readonly nextCommand?: string;
   };
   readonly error?: string;
@@ -29,6 +63,326 @@ 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[];
+  }[];
+}
+
+const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
+  {
+    id: 'household',
+    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',
+    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',
+    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',
+    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',
+    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()
@@ -74,12 +428,126 @@ function readProfileCreatedAt(homeDirectory: string): string | null {
   return null;
 }
 
+function readProfileStarterTemplate(homeDirectory: string): Pick<AgentRuntimeProfileInfo, 'starterTemplateId' | 'starterTemplateName'> {
+  const path = join(homeDirectory, PROFILE_CREATED_FILE);
+  if (!existsSync(path)) return {};
+  try {
+    const raw: unknown = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+    const record = raw as Record<string, unknown>;
+    const starter = record.starterTemplate;
+    if (!starter || typeof starter !== 'object' || Array.isArray(starter)) return {};
+    const starterRecord = starter as Record<string, unknown>;
+    const id = starterRecord.id;
+    const name = starterRecord.name;
+    if (!isAgentRuntimeProfileTemplateId(id) || typeof name !== 'string') return {};
+    return {
+      starterTemplateId: id,
+      starterTemplateName: name,
+    };
+  } catch {
+    return {};
+  }
+}
+
 function buildProfileInfo(baseHomeDirectory: string, id: string): AgentRuntimeProfileInfo {
   const { homeDirectory } = resolveAgentRuntimeProfileHome(baseHomeDirectory, id);
   return {
     id,
     homeDirectory,
     createdAt: readProfileCreatedAt(homeDirectory),
+    ...readProfileStarterTemplate(homeDirectory),
+  };
+}
+
+function profileStorePath(homeDirectory: string, folder: string, file: string): string {
+  return join(homeDirectory, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, folder, file);
+}
+
+export function isAgentRuntimeProfileTemplateId(value: unknown): value is AgentRuntimeProfileTemplateId {
+  return typeof value === 'string' && STARTER_TEMPLATES.some((template) => template.id === value);
+}
+
+export function listAgentRuntimeProfileTemplates(): readonly AgentRuntimeProfileTemplateSummary[] {
+  return STARTER_TEMPLATES.map((template) => ({
+    id: template.id,
+    name: template.name,
+    description: template.description,
+    personaName: template.personaName,
+    skillNames: [...template.skillNames],
+    routineNames: [...template.routineNames],
+  }));
+}
+
+export function getAgentRuntimeProfileTemplate(templateId: AgentRuntimeProfileTemplateId): AgentRuntimeProfileTemplateSummary {
+  const template = STARTER_TEMPLATES.find((entry) => entry.id === templateId);
+  if (!template) throw new Error(`Unknown Agent starter profile template: ${templateId}`);
+  return {
+    id: template.id,
+    name: template.name,
+    description: template.description,
+    personaName: template.personaName,
+    skillNames: [...template.skillNames],
+    routineNames: [...template.routineNames],
+  };
+}
+
+function createMissingSkill(registry: AgentSkillRegistry, template: AgentRuntimeProfileStarterTemplate['skills'][number]): string {
+  const existing = registry.get(template.name);
+  if (existing) return existing.id;
+  return registry.create({
+    name: template.name,
+    description: template.description,
+    procedure: template.procedure,
+    triggers: template.triggers,
+    tags: template.tags,
+    enabled: true,
+    source: 'system',
+    provenance: `goodvibes-agent starter:${template.name}`,
+  }).id;
+}
+
+function createMissingRoutine(registry: AgentRoutineRegistry, template: AgentRuntimeProfileStarterTemplate['routines'][number]): string {
+  const existing = registry.get(template.name);
+  if (existing) return existing.id;
+  return registry.create({
+    name: template.name,
+    description: template.description,
+    steps: template.steps,
+    triggers: template.triggers,
+    tags: template.tags,
+    enabled: true,
+    source: 'system',
+    provenance: `goodvibes-agent starter:${template.name}`,
+  }).id;
+}
+
+export function applyAgentRuntimeProfileTemplate(homeDirectory: string, templateId: AgentRuntimeProfileTemplateId): AgentRuntimeProfileTemplateApplication {
+  const template = STARTER_TEMPLATES.find((entry) => entry.id === templateId);
+  if (!template) throw new Error(`Unknown Agent starter profile template: ${templateId}`);
+  const personaRegistry = new AgentPersonaRegistry(profileStorePath(homeDirectory, 'personas', 'personas.json'));
+  const skillRegistry = new AgentSkillRegistry(profileStorePath(homeDirectory, 'skills', 'skills.json'));
+  const routineRegistry = new AgentRoutineRegistry(profileStorePath(homeDirectory, 'routines', 'routines.json'));
+  const existingPersona = personaRegistry.get(template.persona.name);
+  const persona = existingPersona ?? personaRegistry.create({
+    name: template.persona.name,
+    description: template.persona.description,
+    body: template.persona.body,
+    tags: template.persona.tags,
+    triggers: template.persona.triggers,
+    source: 'system',
+    provenance: `goodvibes-agent starter:${template.name}`,
+  });
+  personaRegistry.setActive(persona.id);
+  const skillIds = template.skills.map((skill) => createMissingSkill(skillRegistry, skill));
+  const routineIds = template.routines.map((routine) => createMissingRoutine(routineRegistry, routine));
+  return {
+    id: template.id,
+    name: template.name,
+    appliedAt: new Date().toISOString(),
+    personaIds: [persona.id],
+    skillIds,
+    routineIds,
   };
 }
 
@@ -99,16 +567,29 @@ export function listAgentRuntimeProfiles(baseHomeDirectory: string): readonly Ag
     .map((entry) => buildProfileInfo(baseHomeDirectory, entry));
 }
 
-export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileInfo {
+export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName: string, options: CreateAgentRuntimeProfileOptions = {}): AgentRuntimeProfileInfo {
   const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
   mkdirSync(resolution.homeDirectory, { recursive: true });
   const createdAt = new Date().toISOString();
+  const appliedTemplate = options.templateId
+    ? applyAgentRuntimeProfileTemplate(resolution.homeDirectory, options.templateId)
+    : undefined;
   writeFileSync(
     join(resolution.homeDirectory, PROFILE_CREATED_FILE),
-    `${JSON.stringify({ id: resolution.id, createdAt }, null, 2)}\n`,
+    `${JSON.stringify({
+      id: resolution.id,
+      createdAt,
+      starterTemplate: appliedTemplate,
+    }, null, 2)}\n`,
     'utf-8',
   );
-  return { ...resolution, createdAt };
+  return {
+    ...resolution,
+    createdAt,
+    starterTemplateId: appliedTemplate?.id,
+    starterTemplateName: appliedTemplate?.name,
+    starterTemplateApplication: appliedTemplate,
+  };
 }
 
 export function deleteAgentRuntimeProfile(baseHomeDirectory: string, profileName: string): boolean {

package/src/cli/help.ts

@@ -96,7 +96,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} models current`,
     `  ${binary} models use openai:gpt-5.2`,
     `  ${binary} providers inspect openai`,
-    `  ${binary} profiles create household --yes`,
+    `  ${binary} profiles create household --template household --yes`,
     `  ${binary} --agent-profile household`,
     `  ${binary} compat`,
     `  ${binary} capabilities`,
@@ -154,9 +154,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 show <name>', 'profiles create <name> --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
-    summary: 'Create and inspect isolated Agent runtime profile homes. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the externally owned daemon.',
-    examples: ['profiles create household --yes', 'profiles list', '--agent-profile household status', '--agent-profile household'],
+    usage: ['profiles list', 'profiles templates', 'profiles show <name>', 'profiles create <name> [--template <id>] --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
+    summary: 'Create and inspect isolated Agent runtime profile homes, with starter templates for household, research, travel, operations, and personal productivity. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the externally owned daemon.',
+    examples: ['profiles templates', 'profiles create household --template household --yes', 'profiles list', '--agent-profile household status', '--agent-profile household'],
   },
   models: {
     usage: ['models [provider]', 'models current', 'models use <registryKey>', 'models pin <registryKey>', 'models recent'],

package/src/cli/profiles-command.ts

@@ -1,8 +1,11 @@
 import {
   createAgentRuntimeProfile,
   deleteAgentRuntimeProfile,
+  isAgentRuntimeProfileTemplateId,
   listAgentRuntimeProfiles,
+  listAgentRuntimeProfileTemplates,
   resolveAgentRuntimeProfileHome,
+  type AgentRuntimeProfileTemplateId,
   type AgentRuntimeProfileCommandResult,
   type AgentRuntimeProfileInfo,
 } from '../agent/runtime-profile.ts';
@@ -26,26 +29,68 @@ function commandValues(args: readonly string[]): readonly string[] {
   return values;
 }
 
+function flagValue(args: readonly string[], names: readonly string[]): string | null {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    for (const name of names) {
+      if (token === name) {
+        const next = args[index + 1];
+        return next && !next.startsWith('--') ? next : null;
+      }
+      if (token.startsWith(`${name}=`)) return token.slice(name.length + 1);
+    }
+  }
+  return null;
+}
+
+function parseTemplate(args: readonly string[]): AgentRuntimeProfileTemplateId | undefined {
+  const raw = flagValue(args, ['--template', '--starter']);
+  if (!raw || raw === 'blank') return undefined;
+  const normalized = raw.trim().toLowerCase().replace(/_/g, '-');
+  if (isAgentRuntimeProfileTemplateId(normalized)) return normalized;
+  throw new Error(`Unknown Agent starter profile template: ${raw}. Use profiles templates to list starters.`);
+}
+
 function profileLine(profile: AgentRuntimeProfileInfo): string {
   const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
-  return `  ${profile.id}  home=${profile.homeDirectory}${created}`;
+  const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
+  return `  ${profile.id}  home=${profile.homeDirectory}${created}${starter}`;
 }
 
 function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string {
   if (!result.ok) return result.error ?? 'Agent profile command failed.';
   if (result.kind === 'agent.profiles.list') {
     const profiles = result.data?.profiles ?? [];
-    if (profiles.length === 0) return 'No Agent runtime profiles. Use: goodvibes-agent profiles create <name> --yes';
+    if (profiles.length === 0) return 'No Agent runtime profiles. Use: goodvibes-agent profiles create <name> --template <id> --yes';
     return [
       `Agent runtime profiles (${profiles.length})`,
       ...profiles.map(profileLine),
     ].join('\n');
   }
+  if (result.kind === 'agent.profiles.templates') {
+    const templates = result.data?.templates ?? [];
+    return [
+      `Agent starter profile templates (${templates.length})`,
+      ...templates.map((template) => [
+        `  ${template.id}  ${template.name}`,
+        `    ${template.description}`,
+        `    persona: ${template.personaName}`,
+        `    skills: ${template.skillNames.join(', ')}`,
+        `    routines: ${template.routineNames.join(', ')}`,
+      ].join('\n')),
+      'Use: goodvibes-agent profiles create <name> --template <id> --yes',
+    ].join('\n');
+  }
   const profile = result.data?.profile;
   if (result.kind === 'agent.profiles.create' && profile) {
+    const template = result.data?.appliedTemplate;
     return [
       `Agent runtime profile created: ${profile.id}`,
       `  home: ${profile.homeDirectory}`,
+      ...(template ? [
+        `  starter: ${template.id} (${template.name})`,
+        `  seeded: ${template.personaIds.length} persona, ${template.skillIds.length} skills, ${template.routineIds.length} routine`,
+      ] : []),
       `  use: ${result.data?.nextCommand ?? `goodvibes-agent --agent-profile ${profile.id}`}`,
     ].join('\n');
   }
@@ -77,6 +122,18 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
       };
     }
 
+    if (sub === 'templates' || sub === 'starters') {
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.templates',
+        data: { templates: listAgentRuntimeProfileTemplates() },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
     if (sub === 'show' || sub === 'path' || sub === 'home') {
       const name = values[0];
       if (!name) {
@@ -91,12 +148,14 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         };
       }
       const profile = resolveAgentRuntimeProfileHome(runtime.homeDirectory, name);
+      const info = listAgentRuntimeProfiles(runtime.homeDirectory).find((entry) => entry.id === profile.id) ?? { ...profile, createdAt: null };
       const result: AgentRuntimeProfileCommandResult = {
         ok: true,
         kind: 'agent.profiles.show',
-        data: { profile: { ...profile, createdAt: null } },
+        data: { profile: info },
       };
-      const text = [`Agent runtime profile: ${profile.id}`, `  home: ${profile.homeDirectory}`, `  use: goodvibes-agent --agent-profile ${profile.id}`].join('\n');
+      const starter = info.starterTemplateId ? [`  starter: ${info.starterTemplateId} (${info.starterTemplateName ?? info.starterTemplateId})`] : [];
+      const text = [`Agent runtime profile: ${profile.id}`, `  home: ${profile.homeDirectory}`, ...starter, `  use: goodvibes-agent --agent-profile ${profile.id}`].join('\n');
       return {
         output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(result, null, 2) : text,
         exitCode: 0,
@@ -109,7 +168,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         const result: AgentRuntimeProfileCommandResult = {
           ok: false,
           kind: 'agent.profiles.error',
-          error: 'Usage: goodvibes-agent profiles create <name> --yes',
+          error: 'Usage: goodvibes-agent profiles create <name> [--template <id>] --yes',
         };
         return {
           output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
@@ -127,12 +186,14 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
           exitCode: 2,
         };
       }
-      const profile = createAgentRuntimeProfile(runtime.homeDirectory, name);
+      const templateId = parseTemplate(rawRest);
+      const profile = createAgentRuntimeProfile(runtime.homeDirectory, name, { templateId });
       const result: AgentRuntimeProfileCommandResult = {
         ok: true,
         kind: 'agent.profiles.create',
         data: {
           profile,
+          appliedTemplate: profile.starterTemplateApplication,
           nextCommand: `goodvibes-agent --agent-profile ${profile.id}`,
         },
       };
@@ -188,7 +249,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
     const result: AgentRuntimeProfileCommandResult = {
       ok: false,
       kind: 'agent.profiles.error',
-      error: 'Usage: goodvibes-agent profiles [list|show <name>|create <name> --yes|delete <name> --yes]',
+      error: 'Usage: goodvibes-agent profiles [list|templates|show <name>|create <name> [--template <id>] --yes|delete <name> --yes]',
     };
     return {
       output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),

package/src/input/agent-workspace.ts

@@ -525,7 +525,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'profile-sync-list', label: 'Profile sync list', detail: 'Inspect saved config profiles available for export/import.', command: '/profilesync list', kind: 'command', safety: 'read-only' },
       { id: 'profile-sync-export', label: 'Export profile sync', detail: 'Export config profiles to a portable bundle. Requires a real path and explicit --yes.', command: '/profilesync export <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'setup-transfer-export', label: 'Export setup transfer', detail: 'Export Agent setup transfer data from the current home. Requires a real path and explicit --yes.', command: '/setup transfer export <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'runtime-profile-create', label: 'Create runtime profile', detail: 'Use the CLI command goodvibes-agent profiles create <name> --yes, then launch with --agent-profile <name>. Runtime profile homes isolate Agent-local state and do not start a daemon.', kind: 'guidance', safety: 'safe' },
+      { id: 'runtime-profile-create', label: 'Create runtime profile', detail: 'Use goodvibes-agent profiles templates, then goodvibes-agent profiles create <name> --template <id> --yes. Starters seed local personas, skills, and routines without touching the daemon.', kind: 'guidance', safety: 'safe' },
       { id: 'runtime-profile-switch', label: 'Switch runtime profile', detail: 'Launch goodvibes-agent --agent-profile <name> to use that isolated Agent home. This workspace cannot switch the current process home after startup.', kind: 'guidance', safety: 'safe' },
     ],
   },

package/src/operator/capability-benchmark.ts

@@ -100,11 +100,11 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'ready',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Skills/procedural memory, persona files, profile state, durable memory, and recurring workflows.',
-    goodvibesAgent: 'Typed local registries for Agent personas, skills, routines, and local memory; active items are injected into the serial main conversation.',
-    configure: ['/personas create ...', '/agent-skills create ...', '/routines create ...', '/memory add ...'],
-    use: ['/personas use <id>', '/skills local list', '/routines start <id>', '/memory search <query>'],
-    exceedsBy: ['Review/stale lifecycle fields', 'secret-value rejection', 'Agent-local state that does not contaminate wiki or HomeGraph'],
-    next: ['Add CLI parity for local registry lifecycle and a curated starter pack of operator skills/routines.'],
+    goodvibesAgent: 'Typed local registries for Agent personas, skills, routines, and local memory; active items are injected into the serial main conversation. Runtime profile starters seed curated persona, skill, and routine bundles.',
+    configure: ['/personas create ...', '/agent-skills create ...', '/routines create ...', '/memory add ...', 'goodvibes-agent profiles create research --template research --yes'],
+    use: ['/personas use <id>', '/skills local list', '/routines start <id>', '/memory search <query>', 'goodvibes-agent profiles templates'],
+    exceedsBy: ['Review/stale lifecycle fields', 'secret-value rejection', 'Agent-local state that does not contaminate wiki or HomeGraph', 'starter bundles that remain local and reviewable'],
+    next: ['Add import/export editing for custom starter templates.'],
   },
   {
     id: 'automation-schedules',
@@ -160,11 +160,11 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'ready',
     competitors: ['hermes'],
     competitorBaseline: 'Profiles run independent agents with isolated configs, sessions, skills, memory, cron jobs, and gateway state.',
-    goodvibesAgent: 'Supports GOODVIBES_AGENT_HOME and named --agent-profile homes for isolated Agent-local config, sessions, memory, personas, skills, routines, setup, and bundles; daemon remains shared/external by design. The Agent workspace exposes runtime profile posture, config profiles, profile sync, and setup transfer shortcuts.',
-    configure: ['GOODVIBES_AGENT_HOME=<path> goodvibes-agent status', 'goodvibes-agent profiles create household --yes', '/agent → Profiles & Portability'],
+    goodvibesAgent: 'Supports GOODVIBES_AGENT_HOME and named --agent-profile homes for isolated Agent-local config, sessions, memory, personas, skills, routines, setup, and bundles; daemon remains shared/external by design. The Agent workspace exposes runtime profile posture, config profiles, profile sync, setup transfer shortcuts, and starter profile templates.',
+    configure: ['GOODVIBES_AGENT_HOME=<path> goodvibes-agent status', 'goodvibes-agent profiles create household --template household --yes', '/agent → Profiles & Portability'],
     use: ['goodvibes-agent --agent-profile household', '/profiles', '/profilesync list', '/setup transfer export <path> --yes'],
-    exceedsBy: ['Typed support bundles', 'explicit daemon boundary', 'no accidental cross-product knowledge fallback', 'profile isolation without hidden daemon lifecycle ownership', 'fullscreen profile and portability workflow discovery'],
-    next: ['Add curated profile starter templates for household, research, travel, operations, and personal productivity profiles.'],
+    exceedsBy: ['Typed support bundles', 'explicit daemon boundary', 'no accidental cross-product knowledge fallback', 'profile isolation without hidden daemon lifecycle ownership', 'fullscreen profile and portability workflow discovery', 'curated local starter packs'],
+    next: ['Add custom starter template authoring and import.'],
   },
   {
     id: 'security-approvals',

package/src/renderer/agent-workspace.ts

@@ -134,6 +134,7 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: `Runtime profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
       { text: `Config profiles: ${snapshot.configProfileCount}`, fg: PALETTE.info },
       { text: 'Named runtime profiles isolate Agent-local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
+      { text: 'Starter templates: household, research, travel, operations, personal-productivity.', fg: PALETTE.info },
       { text: 'The external daemon remains shared unless the daemon host is configured separately.', fg: PALETTE.warn },
       { text: 'Portable bundles require explicit export/import commands with real paths and --yes.', fg: PALETTE.muted },
     );

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.33';
+let _version = '0.1.34';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {