@pellux/goodvibes-agent 0.1.33 → 0.1.35

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.35 - 2026-05-31
+
+- 2c25d5e Add local starter profile import export
+
+## 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,15 @@ 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 profiles templates export research ./research-starter.json --yes
+goodvibes-agent profiles templates import ./research-starter.json --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; exported starter JSON can be edited and re-imported as a local starter. 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; `profiles templates export/import` supports local custom starters.
 - Local personas, routines, and Agent skills are stored under the Agent surface root and are injected only into the serial Agent conversation.
 - 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,15 @@ 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 profiles templates export research ./research-starter.json --yes
+goodvibes-agent profiles templates import ./research-starter.json --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; exported starter JSON can be edited and re-imported as a local starter. 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; starter JSON can be exported/imported for local custom lanes; 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.
+- Guided starter profile authoring inside the fullscreen Agent workspace.
 - 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.35",
   "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,23 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, 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 = string;
+export type AgentRuntimeProfileTemplateSource = 'builtin' | 'local';
+
+export interface AgentRuntimeProfileTemplateSummary {
+  readonly id: AgentRuntimeProfileTemplateId;
+  readonly name: string;
+  readonly description: string;
+  readonly personaName: string;
+  readonly skillNames: readonly string[];
+  readonly routineNames: readonly string[];
+  readonly source: AgentRuntimeProfileTemplateSource;
+  readonly path?: string;
+}
 
 export interface AgentRuntimeProfileResolution {
   readonly id: string;
@@ -8,6 +26,23 @@ 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 source: AgentRuntimeProfileTemplateSource;
+  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 +50,19 @@ export interface AgentRuntimeProfileCommandResult {
   readonly kind:
     | 'agent.profiles.list'
     | 'agent.profiles.show'
+    | 'agent.profiles.templates'
+    | 'agent.profiles.template.export'
+    | 'agent.profiles.template.import'
     | '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 template?: AgentRuntimeProfileTemplateSummary;
+    readonly path?: string;
     readonly nextCommand?: string;
   };
   readonly error?: string;
@@ -29,6 +71,336 @@ 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()
@@ -54,6 +426,10 @@ export function getAgentRuntimeProfilesRoot(baseHomeDirectory: string): string {
   return join(baseHomeDirectory, '.goodvibes', 'agent', 'profile-homes');
 }
 
+export function getAgentRuntimeProfileTemplatesRoot(baseHomeDirectory: string): string {
+  return join(baseHomeDirectory, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'profile-starters');
+}
+
 export function resolveAgentRuntimeProfileHome(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileResolution {
   const id = assertValidAgentRuntimeProfileId(profileName);
   return {
@@ -74,12 +450,258 @@ 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 {
+  if (typeof value !== 'string') return false;
+  try {
+    assertValidAgentRuntimeProfileId(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function summarizeTemplate(template: AgentRuntimeProfileStarterTemplate): AgentRuntimeProfileTemplateSummary {
+  return {
+    id: template.id,
+    name: template.name,
+    description: template.description,
+    personaName: template.personaName,
+    skillNames: [...template.skillNames],
+    routineNames: [...template.routineNames],
+    source: template.source,
+    path: template.path,
+  };
+}
+
+function parseStringArray(value: unknown): readonly string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function readTemplateTextBlock(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Starter template ${field} is required.`);
+  return value.trim();
+}
+
+function readTemplateObject(value: unknown, field: string): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`Starter template ${field} must be an object.`);
+  return value as Record<string, unknown>;
+}
+
+function parseTemplateSkill(value: unknown): AgentRuntimeProfileStarterTemplate['skills'][number] {
+  const record = readTemplateObject(value, 'skill');
+  return {
+    name: readTemplateTextBlock(record.name, 'skill.name'),
+    description: readTemplateTextBlock(record.description, 'skill.description'),
+    procedure: readTemplateTextBlock(record.procedure, 'skill.procedure'),
+    triggers: parseStringArray(record.triggers),
+    tags: parseStringArray(record.tags),
+  };
+}
+
+function parseTemplateRoutine(value: unknown): AgentRuntimeProfileStarterTemplate['routines'][number] {
+  const record = readTemplateObject(value, 'routine');
+  return {
+    name: readTemplateTextBlock(record.name, 'routine.name'),
+    description: readTemplateTextBlock(record.description, 'routine.description'),
+    steps: readTemplateTextBlock(record.steps, 'routine.steps'),
+    triggers: parseStringArray(record.triggers),
+    tags: parseStringArray(record.tags),
+  };
+}
+
+function parseStarterTemplate(raw: unknown, source: AgentRuntimeProfileTemplateSource, path?: string): AgentRuntimeProfileStarterTemplate {
+  const file = readTemplateObject(raw, 'file');
+  const templateRecord = readTemplateObject(file.template ?? raw, 'template');
+  const id = assertValidAgentRuntimeProfileId(readTemplateTextBlock(templateRecord.id, 'id'));
+  const personaRecord = readTemplateObject(templateRecord.persona, 'persona');
+  const skills = Array.isArray(templateRecord.skills) ? templateRecord.skills.map(parseTemplateSkill) : [];
+  const routines = Array.isArray(templateRecord.routines) ? templateRecord.routines.map(parseTemplateRoutine) : [];
+  if (skills.length === 0) throw new Error(`Starter template ${id} must include at least one skill.`);
+  if (routines.length === 0) throw new Error(`Starter template ${id} must include at least one routine.`);
+  const persona = {
+    name: readTemplateTextBlock(personaRecord.name, 'persona.name'),
+    description: readTemplateTextBlock(personaRecord.description, 'persona.description'),
+    body: readTemplateTextBlock(personaRecord.body, 'persona.body'),
+    tags: parseStringArray(personaRecord.tags),
+    triggers: parseStringArray(personaRecord.triggers),
+  };
+  return {
+    id,
+    source,
+    path,
+    name: readTemplateTextBlock(templateRecord.name, 'name'),
+    description: readTemplateTextBlock(templateRecord.description, 'description'),
+    personaName: typeof templateRecord.personaName === 'string' && templateRecord.personaName.trim() ? templateRecord.personaName.trim() : persona.name,
+    skillNames: skills.map((skill) => skill.name),
+    routineNames: routines.map((routine) => routine.name),
+    persona,
+    skills,
+    routines,
+  };
+}
+
+function readLocalTemplate(path: string): AgentRuntimeProfileStarterTemplate | null {
+  try {
+    return parseStarterTemplate(JSON.parse(readFileSync(path, 'utf-8')), 'local', path);
+  } catch {
+    return null;
+  }
+}
+
+function listLocalTemplates(baseHomeDirectory: string): readonly AgentRuntimeProfileStarterTemplate[] {
+  const root = getAgentRuntimeProfileTemplatesRoot(baseHomeDirectory);
+  if (!existsSync(root)) return [];
+  return readdirSync(root)
+    .filter((entry) => entry.endsWith('.json'))
+    .map((entry) => readLocalTemplate(join(root, entry)))
+    .filter((entry): entry is AgentRuntimeProfileStarterTemplate => entry !== null)
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function resolveAgentRuntimeProfileTemplate(templateId: AgentRuntimeProfileTemplateId, baseHomeDirectory?: string): AgentRuntimeProfileStarterTemplate {
+  const id = assertValidAgentRuntimeProfileId(templateId);
+  const builtin = STARTER_TEMPLATES.find((template) => template.id === id);
+  if (builtin) return builtin;
+  const local = baseHomeDirectory ? listLocalTemplates(baseHomeDirectory).find((template) => template.id === id) : undefined;
+  if (local) return local;
+  const suffix = baseHomeDirectory ? ' Use profiles templates to list starters.' : '';
+  throw new Error(`Unknown Agent starter profile template: ${templateId}.${suffix}`);
+}
+
+export function listAgentRuntimeProfileTemplates(baseHomeDirectory?: string): readonly AgentRuntimeProfileTemplateSummary[] {
+  const builtins = STARTER_TEMPLATES.map(summarizeTemplate);
+  const locals = baseHomeDirectory ? listLocalTemplates(baseHomeDirectory).map(summarizeTemplate) : [];
+  return [...builtins, ...locals];
+}
+
+export function getAgentRuntimeProfileTemplate(templateId: AgentRuntimeProfileTemplateId, baseHomeDirectory?: string): AgentRuntimeProfileTemplateSummary {
+  return summarizeTemplate(resolveAgentRuntimeProfileTemplate(templateId, baseHomeDirectory));
+}
+
+function templateFilePayload(template: AgentRuntimeProfileStarterTemplate): AgentRuntimeProfileStarterTemplateFile {
+  return {
+    version: 1,
+    template: {
+      ...template,
+      source: 'local',
+      path: undefined,
+    },
+  };
+}
+
+export function exportAgentRuntimeProfileTemplate(baseHomeDirectory: string, templateId: AgentRuntimeProfileTemplateId, outputPath: string): AgentRuntimeProfileTemplateSummary {
+  const template = resolveAgentRuntimeProfileTemplate(templateId, baseHomeDirectory);
+  const target = outputPath.trim();
+  if (!target) throw new Error('Template export path is required.');
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, `${JSON.stringify(templateFilePayload(template), null, 2)}\n`, 'utf-8');
+  return { ...summarizeTemplate(template), path: target };
+}
+
+export function importAgentRuntimeProfileTemplate(baseHomeDirectory: string, sourcePath: string): AgentRuntimeProfileTemplateSummary {
+  const source = sourcePath.trim();
+  if (!source) throw new Error('Template import path is required.');
+  const parsed = parseStarterTemplate(JSON.parse(readFileSync(source, 'utf-8')), 'local');
+  const root = getAgentRuntimeProfileTemplatesRoot(baseHomeDirectory);
+  mkdirSync(root, { recursive: true });
+  const target = join(root, `${parsed.id}.json`);
+  writeFileSync(target, `${JSON.stringify(templateFilePayload({ ...parsed, source: 'local', path: target }), null, 2)}\n`, 'utf-8');
+  return summarizeTemplate({ ...parsed, source: 'local', path: target });
+}
+
+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, baseHomeDirectory?: string): AgentRuntimeProfileTemplateApplication {
+  const template = resolveAgentRuntimeProfileTemplate(templateId, baseHomeDirectory);
+  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,
+    source: template.source,
+    appliedAt: new Date().toISOString(),
+    personaIds: [persona.id],
+    skillIds,
+    routineIds,
   };
 }
 
@@ -99,16 +721,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, baseHomeDirectory)
+    : 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 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 runtime 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 the externally owned daemon.',
+    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'],
   },
   models: {
     usage: ['models [provider]', 'models current', 'models use <registryKey>', 'models pin <registryKey>', 'models recent'],

package/src/cli/profiles-command.ts

@@ -1,8 +1,13 @@
 import {
   createAgentRuntimeProfile,
   deleteAgentRuntimeProfile,
+  exportAgentRuntimeProfileTemplate,
+  importAgentRuntimeProfileTemplate,
+  isAgentRuntimeProfileTemplateId,
   listAgentRuntimeProfiles,
+  listAgentRuntimeProfileTemplates,
   resolveAgentRuntimeProfileHome,
+  type AgentRuntimeProfileTemplateId,
   type AgentRuntimeProfileCommandResult,
   type AgentRuntimeProfileInfo,
 } from '../agent/runtime-profile.ts';
@@ -26,26 +31,84 @@ 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.source}]`,
+        `    ${template.description}`,
+        `    persona: ${template.personaName}`,
+        `    skills: ${template.skillNames.join(', ')}`,
+        `    routines: ${template.routineNames.join(', ')}`,
+      ].join('\n')),
+      'Use: goodvibes-agent profiles create <name> --template <id> --yes',
+      'Export/edit/import: goodvibes-agent profiles templates export <id> <path> --yes',
+    ].join('\n');
+  }
+  if (result.kind === 'agent.profiles.template.export' && result.data?.template && result.data.path) {
+    return [
+      `Agent starter template exported: ${result.data.template.id}`,
+      `  path: ${result.data.path}`,
+      '  edit the JSON, then import it with: goodvibes-agent profiles templates import <path> --yes',
+    ].join('\n');
+  }
+  if (result.kind === 'agent.profiles.template.import' && result.data?.template) {
+    return [
+      `Agent starter template imported: ${result.data.template.id}`,
+      `  name: ${result.data.template.name}`,
+      `  source: ${result.data.template.source}`,
+      `  use: goodvibes-agent profiles create <name> --template ${result.data.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 +140,87 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
       };
     }
 
+    if (sub === 'templates' || sub === 'starters') {
+      const [templateAction, templateId, templatePath] = values;
+      if (templateAction === 'export') {
+        if (!templateId || !templatePath) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: 'Usage: goodvibes-agent profiles templates export <id> <path> --yes',
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        if (!hasYes(rawRest)) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: `Refusing to export Agent starter template ${templateId} without --yes.`,
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        const template = exportAgentRuntimeProfileTemplate(runtime.homeDirectory, templateId, templatePath);
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.template.export',
+          data: { template, path: templatePath },
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
+      if (templateAction === 'import') {
+        if (!templateId) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: 'Usage: goodvibes-agent profiles templates import <path> --yes',
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        if (!hasYes(rawRest)) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: `Refusing to import Agent starter template ${templateId} without --yes.`,
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        const template = importAgentRuntimeProfileTemplate(runtime.homeDirectory, templateId);
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.template.import',
+          data: { template, path: templateId },
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.templates',
+        data: { templates: listAgentRuntimeProfileTemplates(runtime.homeDirectory) },
+      };
+      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 +235,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 +255,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 +273,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 +336,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,8 @@ 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-template-edit', label: 'Customize starter', detail: 'Use goodvibes-agent profiles templates export <id> <path> --yes, edit the JSON, then import it with profiles templates import <path> --yes.', 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, and users can export/edit/import local starters.',
+    configure: ['/personas create ...', '/agent-skills create ...', '/routines create ...', '/memory add ...', 'goodvibes-agent profiles create research --template research --yes', 'goodvibes-agent profiles templates import ./starter.json --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', 'editable starter JSON for repeatable operator lanes'],
+    next: ['Add guided starter authoring inside the fullscreen Agent workspace.'],
   },
   {
     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, starter profile templates, and local starter import/export.',
+    configure: ['GOODVIBES_AGENT_HOME=<path> goodvibes-agent status', 'goodvibes-agent profiles create household --template household --yes', 'goodvibes-agent profiles templates export research ./starter.json --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', 'editable starter templates'],
+    next: ['Add guided starter authoring inside the fullscreen Agent workspace.'],
   },
   {
     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.35';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {